sysml-diagram 0.42.0 → 0.43.0

package/out/main.js

@@ -163505,6 +163505,792 @@ function variantKindCompatibility(node, resolve8) {
   return specializesKind(variantKind, ownerKind) ? "compatible" : "incompatible";
 }
 
+// ../language-server/out/src/services/metadata-semantics.js
+var MAX_DEPTH = 32;
+var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([
+  ":>",
+  "specializes",
+  ":>>",
+  "redefines",
+  "subsets"
+]);
+var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var STRUCTURAL_FEATURE_NAMES = /* @__PURE__ */ new Set(["self", "annotatedElement"]);
+var ANNOTATED_ELEMENT = "annotatedElement";
+var METAOBJECT_ROOT = "Metaobject";
+function isMetadataUsage(node) {
+  if (node.$type === "MetadataAnnotation")
+    return true;
+  return node.$type === "MetadataDecl" && node.isDef !== true;
+}
+function isMetadataPrefixTag(node) {
+  return node.$type === "PrefixMetadataTag";
+}
+function metadataTypeNamesOf(node) {
+  const usage = node;
+  const names = [];
+  const add = (text) => {
+    const trimmed = text?.trim();
+    if (trimmed)
+      names.push(trimmed);
+  };
+  add((usage.type ?? usage.typing?.type)?.$refText);
+  for (const more of usage.typing?.moreTypes ?? [])
+    add(more.$refText);
+  for (const typing of usage.moreTypings ?? []) {
+    add(typing.type?.$refText);
+    for (const more of typing.moreTypes ?? [])
+      add(more.$refText);
+  }
+  return names;
+}
+function metadataTypeNodeOf(node, resolve8) {
+  const usage = node;
+  const reference = usage.type ?? usage.typing?.type;
+  if (reference?.ref)
+    return reference.ref;
+  const written = reference?.$refText?.trim();
+  return written ? resolve8(written, node) : void 0;
+}
+function metadataBindingsOf(node) {
+  const bindings = [];
+  for (const member of node.members ?? []) {
+    if (NON_BINDING_MEMBER_TYPES.has(member.$type))
+      continue;
+    const redefined = redefinedNameOf(member);
+    if (redefined) {
+      bindings.push({ name: redefined, form: "redefinition", node: member, value: member.value });
+      continue;
+    }
+    if (member.name) {
+      bindings.push({ name: member.name, form: "shorthand", node: member, value: member.value });
+    }
+  }
+  return bindings;
+}
+var NON_BINDING_MEMBER_TYPES = /* @__PURE__ */ new Set([
+  "DocCommentMember",
+  "CommentStmt",
+  "RepStmt",
+  "MetadataAnnotation",
+  "PrefixMetadataMember",
+  "Import",
+  "AliasDecl",
+  "FilterMember"
+]);
+function redefinedNameOf(member) {
+  for (const relationship of [...member.preRelationships ?? [], ...member.relationships ?? []]) {
+    if (!relationship.kind || !REDEFINITION_KINDS2.has(relationship.kind))
+      continue;
+    const target = (relationship.targets ?? [])[0];
+    const simple = target?.split(/::|\./u).pop()?.trim();
+    if (simple)
+      return simple;
+  }
+  return void 0;
+}
+function metadataFeaturesOf(type, resolve8, implicitBaseNames = () => []) {
+  const features = /* @__PURE__ */ new Map();
+  const inherited = new Set(STRUCTURAL_FEATURE_NAMES);
+  const seen = /* @__PURE__ */ new Set();
+  let complete = true;
+  const collectNames = (owner, depth, visited) => {
+    if (!owner || depth > MAX_DEPTH || visited.has(owner))
+      return;
+    visited.add(owner);
+    for (const member of owner.members ?? []) {
+      const name = member.name ?? redefinedNameOf(member);
+      if (name)
+        inherited.add(name);
+    }
+    for (const supertype of specializationTargetsOf(owner)) {
+      collectNames(resolve8(supertype, owner), depth + 1, visited);
+    }
+  };
+  const walk = (owner, depth) => {
+    if (!owner || depth > MAX_DEPTH || seen.has(owner)) {
+      if (!owner)
+        complete = false;
+      return;
+    }
+    seen.add(owner);
+    for (const base of implicitBaseNames(owner)) {
+      collectNames(resolve8(base, owner), 0, /* @__PURE__ */ new Set());
+    }
+    for (const member of owner.members ?? []) {
+      if (!isFeatureMember(member))
+        continue;
+      const name = member.name ?? redefinedNameOf(member);
+      if (!name)
+        continue;
+      const known2 = features.get(name);
+      if (known2) {
+        if (suppliedValueOf(member) !== void 0) {
+          known2.hasDefault = true;
+          known2.required = false;
+        }
+        continue;
+      }
+      features.set(name, {
+        name,
+        node: member,
+        typeName: writtenTypeNameOf(member),
+        hasDefault: suppliedValueOf(member) !== void 0,
+        required: isRequiredFeature(member)
+      });
+    }
+    for (const supertype of specializationTargetsOf(owner)) {
+      const resolved = resolve8(supertype, owner);
+      if (!resolved) {
+        complete = false;
+        continue;
+      }
+      if (isMetaobjectRoot(supertype, resolved)) {
+        collectNames(resolved, 0, /* @__PURE__ */ new Set());
+        continue;
+      }
+      walk(resolved, depth + 1);
+    }
+  };
+  if (!type)
+    return { features: [], inherited, complete: false };
+  walk(type, 0);
+  return { features: [...features.values()], inherited, complete };
+}
+function isMetaobjectRoot(written, resolved) {
+  return written.split(/::|\./u).pop()?.trim() === METAOBJECT_ROOT || resolved.name === METAOBJECT_ROOT;
+}
+function isFeatureMember(member) {
+  if (NON_BINDING_MEMBER_TYPES.has(member.$type))
+    return false;
+  if (member.$type === "MetadataDecl" && member.isDef === true)
+    return false;
+  return member.name !== void 0 || redefinedNameOf(member) !== void 0;
+}
+function writtenTypeNameOf(member) {
+  const written = member.typing?.type?.$refText?.trim();
+  return written && written.length > 0 ? written : void 0;
+}
+function suppliedValueOf(member) {
+  return member.value ?? member.default?.value;
+}
+function isRequiredFeature(member) {
+  if (suppliedValueOf(member) !== void 0)
+    return false;
+  if ((member.modifiers ?? []).includes("abstract"))
+    return false;
+  if (STRUCTURAL_FEATURE_NAMES.has(member.name ?? ""))
+    return false;
+  if (STRUCTURAL_FEATURE_NAMES.has(redefinedNameOf(member) ?? ""))
+    return false;
+  const lower2 = member.multiplicity?.lower;
+  if (!lower2)
+    return true;
+  if (lower2.star === true)
+    return false;
+  if (lower2.intVal === void 0)
+    return false;
+  return lower2.intVal >= 1;
+}
+function annotatedElementRestrictionsOf(type, resolve8) {
+  const restrictions = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (owner, depth) => {
+    if (!owner || depth > MAX_DEPTH || seen.has(owner))
+      return;
+    seen.add(owner);
+    for (const member of owner.members ?? []) {
+      const binds = member.name === ANNOTATED_ELEMENT || redefinedNameOf(member) === ANNOTATED_ELEMENT || subsetTargetsOf(member).includes(ANNOTATED_ELEMENT);
+      if (!binds)
+        continue;
+      const typeName = writtenTypeNameOf(member);
+      if (typeName) {
+        restrictions.push({ typeName, node: member, owner, resolvedType: resolve8(typeName, member) });
+      }
+    }
+    for (const supertype of specializationTargetsOf(owner))
+      walk(resolve8(supertype, owner), depth + 1);
+  };
+  walk(type, 0);
+  return restrictions;
+}
+function subsetTargetsOf(member) {
+  const targets = [];
+  for (const relationship of [...member.preRelationships ?? [], ...member.relationships ?? []]) {
+    if (relationship.kind !== ":>" && relationship.kind !== "subsets")
+      continue;
+    for (const target of relationship.targets ?? []) {
+      const simple = target.split(/::|\./u).pop()?.trim();
+      if (simple)
+        targets.push(simple);
+    }
+  }
+  return targets;
+}
+function metadataTargetsOf(node, resolve8) {
+  const usage = node;
+  const written = usage.targets ?? [];
+  if (written.length > 0) {
+    return written.map((text, occurrence) => ({
+      text: text.trim(),
+      node: resolve8(text.trim(), occurrence),
+      explicit: true
+    }));
+  }
+  const owner = annotatedOwnerOf(node);
+  if (!owner)
+    return [];
+  return [{ text: owner.name ?? owner.$type, node: owner, explicit: false }];
+}
+function annotatedOwnerOf(node) {
+  const container = node.$container;
+  if (container?.$type === "PrefixMetadataMember") {
+    return container.element;
+  }
+  if (!container)
+    return void 0;
+  if (!NON_ANNOTATED_CONTAINERS.has(container.$type))
+    return container;
+  if (node.$type !== "MetadataAnnotation")
+    return void 0;
+  return followingDeclarationOf(node, container);
+}
+function followingDeclarationOf(node, container) {
+  const members = container.members ?? container.elements ?? [];
+  const index2 = members.indexOf(node);
+  if (index2 < 0)
+    return void 0;
+  for (let next = index2 + 1; next < members.length; next += 1) {
+    const candidate = members[next];
+    if (candidate.$type === "MetadataAnnotation")
+      continue;
+    return candidate;
+  }
+  return void 0;
+}
+var NON_ANNOTATED_CONTAINERS = /* @__PURE__ */ new Set(["Document", "Package", "NamespaceDecl"]);
+function valueEvaluability(value, resolve8) {
+  if (!value)
+    return "unknown";
+  let verdict = "model-level";
+  for (const node of [value, ...ast_utils_exports.streamAllContents(value)]) {
+    if (node.$type !== "PathExpr")
+      continue;
+    const written = pathTextOf(node);
+    if (!written)
+      return "unknown";
+    const segments = written.split(/::|\./u).map((segment) => segment.trim()).filter(Boolean);
+    const root4 = segments.length > 0 ? resolve8(segments[0], node) : void 0;
+    if (root4 && isOccurrenceUsage(root4))
+      return "instance-level";
+    if (segments.length > 1) {
+      if (!root4)
+        return "unknown";
+      continue;
+    }
+    const target = resolve8(written, node);
+    if (!target)
+      return "unknown";
+    if (referentEvaluability(target) === "unknown")
+      verdict = "unknown";
+  }
+  return verdict;
+}
+function pathTextOf(node) {
+  const text = node.$cstNode?.text?.trim();
+  return text && text.length > 0 ? text : void 0;
+}
+function referentEvaluability(target) {
+  if (isOwnedEnumerationValue(target))
+    return "model-level";
+  const node = target;
+  if (node.isDef === true)
+    return "model-level";
+  if (node.value !== void 0)
+    return "model-level";
+  return isOccurrenceUsage(node) ? "instance-level" : "unknown";
+}
+function isOccurrenceUsage(node) {
+  return node.isDef !== true && OCCURRENCE_USAGE_TYPES.has(node.$type);
+}
+var OCCURRENCE_USAGE_TYPES = /* @__PURE__ */ new Set([
+  "PartDecl",
+  "ItemDecl",
+  "PortDecl",
+  "ActionDecl",
+  "StateDecl",
+  "OccurrenceDecl",
+  "ConnectionDecl",
+  "InterfaceDecl",
+  "AllocationDecl",
+  "EventDecl"
+]);
+function specializationTargetsOf(node) {
+  const owner = node;
+  const targets = [];
+  for (const relationship of [...owner.preRelationships ?? [], ...owner.relationships ?? []]) {
+    if (relationship.kind && SPECIALIZATION_KINDS2.has(relationship.kind)) {
+      targets.push(...relationship.targets ?? []);
+    }
+  }
+  const typed = owner.typing?.type?.$refText;
+  if (typed)
+    targets.push(typed);
+  return targets.map((target) => target.trim()).filter((target) => target.length > 0);
+}
+
+// ../language-server/out/src/services/semantic-metadata.js
+var SEMANTIC_METADATA = "SemanticMetadata";
+var BASE_TYPE = "baseType";
+var MAX_DEPTH2 = 32;
+var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([
+  ":>",
+  "specializes",
+  ":>>",
+  "redefines",
+  "subsets"
+]);
+var NON_TYPE_NODE_TYPES = /* @__PURE__ */ new Set([
+  "Document",
+  "Package",
+  "NamespaceDecl",
+  "Import",
+  "ImportSeg",
+  "AliasDecl",
+  "DocCommentMember",
+  "CommentStmt",
+  "RepStmt",
+  "FilterMember",
+  "MultiplicityDecl",
+  // A dependency is a Relationship between elements, not a Type, so it can
+  // neither be a base type nor carry a semantic tag (Codex review of PR 294).
+  "DependencyDecl"
+]);
+var KERML_CLASSIFIER_TYPES = /* @__PURE__ */ new Set([
+  "TypeDecl",
+  "ClassDecl",
+  "ClassifierDecl",
+  "StructDecl",
+  "DatatypeDecl",
+  "MetaclassDecl",
+  "AssociationDecl",
+  "BehaviorDecl",
+  "InteractionDecl",
+  "FunctionDecl",
+  "PredicateDecl"
+]);
+function semanticFormOf(node) {
+  if (!node)
+    return "not-a-type";
+  if (NON_TYPE_NODE_TYPES.has(node.$type))
+    return "not-a-type";
+  if (node.$type === "BareDefDecl")
+    return "definition";
+  if (node.isDef === true)
+    return "definition";
+  return KERML_CLASSIFIER_TYPES.has(node.$type) ? "definition" : "usage";
+}
+function semanticEdgeFor(annotated, base) {
+  if (annotated === "definition" && base === "definition") {
+    return { metaclass: "Specialization", written: ":>", phrase: "specializes" };
+  }
+  if (annotated === "usage" && base === "definition") {
+    return { metaclass: "FeatureTyping", written: ":", phrase: "defined by" };
+  }
+  if (annotated === "usage" && base === "usage") {
+    return { metaclass: "Subsetting", written: ":>", phrase: "subsets" };
+  }
+  return void 0;
+}
+function semanticMetadataVerdictOf(type, resolve8) {
+  if (!type)
+    return { isSemantic: false, complete: false };
+  let complete = true;
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (owner, depth) => {
+    if (!owner || depth > MAX_DEPTH2 || seen.has(owner))
+      return false;
+    seen.add(owner);
+    for (const target of specializationTargetsOf2(owner)) {
+      if (simpleNameOf(target) === SEMANTIC_METADATA)
+        return true;
+      const resolved = resolve8(target, owner);
+      if (!resolved) {
+        complete = false;
+        continue;
+      }
+      if (nameOf(resolved) === SEMANTIC_METADATA)
+        return true;
+      if (walk(resolved, depth + 1))
+        return true;
+    }
+    return false;
+  };
+  const isSemantic = nameOf(type) === SEMANTIC_METADATA || walk(type, 0);
+  return { isSemantic, complete };
+}
+function baseTypeBindingsOf(type, resolve8) {
+  const bindings = [];
+  const seen = /* @__PURE__ */ new Set();
+  let complete = true;
+  const walk = (owner, depth) => {
+    if (!owner || depth > MAX_DEPTH2 || seen.has(owner))
+      return;
+    seen.add(owner);
+    for (const member of owner.members ?? []) {
+      if (boundFeatureNameOf(member) !== BASE_TYPE)
+        continue;
+      const value = member.value ?? member.default?.value;
+      const read = baseTypeValueOf(value);
+      if (read)
+        bindings.push({ ...read, node: member, owner });
+    }
+    for (const target of specializationTargetsOf2(owner)) {
+      const resolved = resolve8(target, owner);
+      if (!resolved) {
+        complete = false;
+        continue;
+      }
+      walk(resolved, depth + 1);
+    }
+  };
+  if (!type)
+    return { bindings: [], complete: false };
+  walk(type, 0);
+  return { bindings, complete };
+}
+function baseTypeValueOf(value) {
+  if (!value)
+    return void 0;
+  const node = value;
+  if (node.$type === "ClassifyOp" && (node.op === "meta" || node.op === "as")) {
+    const written = pathTextOf2(node.left);
+    if (!written)
+      return void 0;
+    return { written, castTypeName: node.type?.$refText?.trim() || void 0 };
+  }
+  if (node.$type === "PathExpr") {
+    const written = pathTextOf2(node);
+    return written ? { written } : void 0;
+  }
+  return void 0;
+}
+function resolveSemanticBase(binding, resolve8) {
+  const node = resolve8(binding.written, binding.node) ?? resolve8(binding.written, binding.owner);
+  if (node)
+    return { binding, node, form: semanticFormOf(node), unresolved: false };
+  const cast = binding.castTypeName ? metaclassFormOf(binding.castTypeName) : void 0;
+  return { binding, form: cast ?? "not-a-type", unresolved: true };
+}
+function metaclassFormOf(name) {
+  const simple = simpleNameOf(name);
+  if (simple.endsWith("Usage"))
+    return "usage";
+  if (simple.endsWith("Definition"))
+    return "definition";
+  return void 0;
+}
+var SemanticMetadataModel = class {
+  resolve;
+  resolveTarget;
+  byElement = /* @__PURE__ */ new Map();
+  typeVerdicts = /* @__PURE__ */ new Map();
+  typeBases = /* @__PURE__ */ new Map();
+  /**
+   * `resolveTarget` resolves one written `about` path. It takes the usage the
+   * path is written on, because a path is read in the scope it sits in: the
+   * bare {@link MetadataTargetResolver} signature carries only the text and its
+   * position, which is enough for one usage at a time but not for a model that
+   * reads a whole document.
+   */
+  constructor(resolve8, resolveTarget = () => void 0) {
+    this.resolve = resolve8;
+    this.resolveTarget = resolveTarget;
+  }
+  /** Read every metadata usage in one parsed document. */
+  build(root4) {
+    for (const node of [root4, ...ast_utils_exports.streamAllContents(root4)]) {
+      if (!isMetadataUsage(node) && !isMetadataPrefixTag(node))
+        continue;
+      for (const annotation of this.readUsage(node)) {
+        const known2 = this.byElement.get(annotation.annotated);
+        if (known2)
+          known2.push(annotation);
+        else
+          this.byElement.set(annotation.annotated, [annotation]);
+      }
+    }
+    return this;
+  }
+  /** The semantic annotations on one element, in document order. */
+  annotationsOf(node) {
+    return this.byElement.get(node) ?? [];
+  }
+  /**
+   * The edges one element gains, deduplicated by the base each one reaches.
+   *
+   * Two tags naming one base state one edge, so the second is dropped rather
+   * than drawn twice. Two tags naming DIFFERENT bases both stand: subsetting
+   * two features is ordinary SysML, and it is the `baseType` hierarchy, not
+   * the tag count, that `SSM059` judges.
+   */
+  edgesOf(node) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const annotation of this.annotationsOf(node)) {
+      if (!annotation.edge || !annotation.base)
+        continue;
+      const key2 = annotation.base.node ? this.keyOf(annotation.base.node) : `written:${annotation.base.binding.written}`;
+      if (seen.has(key2))
+        continue;
+      seen.add(key2);
+      out.push(annotation);
+    }
+    return out;
+  }
+  /** Every element this document tags, for a caller that walks the model. */
+  annotatedElements() {
+    return [...this.byElement.keys()];
+  }
+  /**
+   * issue #169 - does the implied edge come back to the element it starts
+   * from?
+   *
+   * A written `part def A :> A;` is rejected by the ordinary specialization
+   * checks; the implied one has to be judged the same way, and it is easier to
+   * write by accident: a keyword whose base type is itself tagged with that
+   * keyword closes the loop without either declaration looking wrong on its
+   * own. The walk follows BOTH kinds of edge for that reason - the written
+   * supertypes and the implied ones - and is depth-capped, so a model that is
+   * already cyclic cannot hang the pass that reports it.
+   */
+  isCyclicBase(annotated, base) {
+    if (!base.node)
+      return false;
+    if (base.node === annotated)
+      return true;
+    return this.reaches(base.node, annotated, 0, /* @__PURE__ */ new Set([annotated]));
+  }
+  reaches(from, goal, depth, seen) {
+    if (depth > MAX_DEPTH2 || seen.has(from))
+      return false;
+    seen.add(from);
+    for (const written of specializationTargetsOf2(from)) {
+      const next = this.resolve(written, from);
+      if (!next)
+        continue;
+      if (next === goal)
+        return true;
+      if (this.reaches(next, goal, depth + 1, seen))
+        return true;
+    }
+    for (const annotation of this.annotationsOf(from)) {
+      const next = annotation.edge && annotation.base?.node;
+      if (!next)
+        continue;
+      if (next === goal)
+        return true;
+      if (this.reaches(next, goal, depth + 1, seen))
+        return true;
+    }
+    return false;
+  }
+  /** Identity of a resolved base, which may live in another document. The CST
+   *  offset alone would collide across files, so the document is part of it. */
+  keyOf(node) {
+    const root4 = ast_utils_exports.findRootNode(node);
+    const uri = root4.$document?.uri;
+    return `${String(uri ?? "")}#${node.$cstNode?.offset ?? node.name ?? ""}`;
+  }
+  readUsage(usage) {
+    const type = metadataTypeNodeOf(usage, this.resolve);
+    const verdict = this.verdictOf(type);
+    if (!verdict.isSemantic)
+      return [];
+    const reading = this.basesOf(type);
+    const binding = reading.bindings[0];
+    const base = binding ? resolveSemanticBase(binding, this.resolve) : void 0;
+    const complete = verdict.complete && reading.complete;
+    const forUsage = (text, occurrence) => this.resolveTarget(usage, text, occurrence);
+    const targets = metadataTargetsOf(usage, forUsage);
+    const out = [];
+    for (const target of targets) {
+      if (!target.node)
+        continue;
+      out.push({
+        usage,
+        type,
+        annotated: target.node,
+        base,
+        complete,
+        bindings: reading.bindings,
+        edge: base ? semanticEdgeFor(semanticFormOf(target.node), base.form) : void 0
+      });
+    }
+    return out;
+  }
+  verdictOf(type) {
+    if (!type)
+      return { isSemantic: false, complete: false };
+    const cached = this.typeVerdicts.get(type);
+    if (cached)
+      return cached;
+    const built = semanticMetadataVerdictOf(type, this.resolve);
+    this.typeVerdicts.set(type, built);
+    return built;
+  }
+  basesOf(type) {
+    if (!type)
+      return { bindings: [], complete: false };
+    const cached = this.typeBases.get(type);
+    if (cached)
+      return cached;
+    const built = baseTypeBindingsOf(type, this.resolve);
+    this.typeBases.set(type, built);
+    return built;
+  }
+};
+var KEYWORDLESS_DECL_TYPES = /* @__PURE__ */ new Set(["EnumValueDecl", "BareDefDecl"]);
+function effectiveKindOf(node, annotations) {
+  if (!KEYWORDLESS_DECL_TYPES.has(node.$type))
+    return void 0;
+  const isDef = node.$type === "BareDefDecl";
+  for (const annotation of annotations) {
+    const baseNode = annotation.base?.node;
+    const declType = baseNode ? baseNode.$type : metaclassDeclTypeOf(annotation.base?.binding.castTypeName);
+    if (!declType || declType === node.$type)
+      continue;
+    return { declType, isDef, from: annotation };
+  }
+  return void 0;
+}
+function effectiveKeywordOf(kind) {
+  const words = kind.declType.replace(/Decl$/u, "").replace(/([A-Z])/gu, " $1").trim().toLowerCase();
+  const keyword = words === "calc" ? "calc" : words;
+  return kind.isDef ? `${keyword} def` : keyword;
+}
+function isKeywordlessDeclaration(node) {
+  return KEYWORDLESS_DECL_TYPES.has(node.$type);
+}
+function isMetadataDefinition(node) {
+  return node.$type === "MetadataDecl" && node.isDef === true;
+}
+function statesOwnBaseTypeOptionally(node) {
+  const decl = node;
+  return nameOf(node) === SEMANTIC_METADATA || (decl.modifiers ?? []).includes("abstract");
+}
+function metaclassDeclTypeOf(name) {
+  if (!name)
+    return void 0;
+  const simple = simpleNameOf(name).replace(/(?:Usage|Definition)$/u, "");
+  return METACLASS_DECL_TYPES[simple];
+}
+var METACLASS_DECL_TYPES = Object.freeze({
+  Part: "PartDecl",
+  Item: "ItemDecl",
+  Port: "PortDecl",
+  Attribute: "AttributeDecl",
+  Action: "ActionDecl",
+  State: "StateDecl",
+  Occurrence: "OccurrenceDecl",
+  Event: "EventDecl",
+  Connection: "ConnectionDecl",
+  Interface: "InterfaceDecl",
+  Allocation: "AllocationDecl",
+  Constraint: "ConstraintDecl",
+  Requirement: "RequirementDecl",
+  Concern: "ConcernDecl",
+  Case: "CaseDecl",
+  UseCase: "UseCaseDecl",
+  AnalysisCase: "AnalysisCaseDecl",
+  VerificationCase: "VerificationCaseDecl",
+  Calculation: "CalcDecl",
+  View: "ViewDecl",
+  Viewpoint: "ViewpointDecl",
+  Rendering: "RenderingDecl",
+  Enumeration: "EnumDecl",
+  Metadata: "MetadataDecl"
+});
+function metadataUsagesAnnotating(node) {
+  const container = node.$container;
+  const candidates = [];
+  if (container?.$type === "PrefixMetadataMember")
+    candidates.push(...container.tags ?? []);
+  candidates.push(...node.members ?? []);
+  const siblings = container?.members ?? container?.elements;
+  if (siblings) {
+    const index2 = siblings.indexOf(node);
+    for (let before = index2 - 1; before >= 0; before -= 1) {
+      const candidate = siblings[before];
+      if (candidate.$type !== "MetadataAnnotation")
+        break;
+      candidates.push(candidate);
+    }
+  }
+  return candidates.filter((candidate) => (isMetadataUsage(candidate) || isMetadataPrefixTag(candidate)) && annotatedOwnerOf(candidate) === node);
+}
+function metadataNameResolver(sources) {
+  return (name, from) => {
+    const normalized = name.trim();
+    if (!normalized)
+      return void 0;
+    if (from) {
+      const scoped = sources.visibleCandidates(from, normalized);
+      if (scoped.length === 1)
+        return scoped[0];
+    }
+    let descriptions = sources.descriptionsFor(normalized);
+    if (descriptions.length === 0) {
+      const simple = simpleNameOf(normalized);
+      descriptions = simple ? sources.descriptionsFor(simple) : [];
+    }
+    if (descriptions.length === 0)
+      return void 0;
+    const unique = /* @__PURE__ */ new Map();
+    for (const description of descriptions) {
+      unique.set(`${String(description.documentUri)}#${description.path}`, description);
+    }
+    if (unique.size !== 1)
+      return void 0;
+    return sources.nodeFor([...unique.values()][0]);
+  };
+}
+function specializationTargetsOf2(node) {
+  const owner = node;
+  const targets = [];
+  for (const relationship of [...owner.preRelationships ?? [], ...owner.relationships ?? []]) {
+    if (relationship.kind && SPECIALIZATION_KINDS3.has(relationship.kind)) {
+      targets.push(...relationship.targets ?? []);
+    }
+  }
+  const typed = owner.typing?.type?.$refText;
+  if (typed)
+    targets.push(typed);
+  return targets.map((target) => target.trim()).filter((target) => target.length > 0);
+}
+function boundFeatureNameOf(member) {
+  for (const relationship of [...member.preRelationships ?? [], ...member.relationships ?? []]) {
+    if (relationship.kind !== ":>>" && relationship.kind !== "redefines")
+      continue;
+    const simple = simpleNameOf((relationship.targets ?? [])[0] ?? "");
+    if (simple)
+      return simple;
+  }
+  return member.name;
+}
+function nameOf(node) {
+  return node.name;
+}
+function simpleNameOf(written) {
+  return written.split(/::|\./u).pop()?.trim() ?? "";
+}
+function pathTextOf2(node) {
+  if (!node)
+    return void 0;
+  const written = node.path?.trim() ?? node.$cstNode?.text?.trim();
+  return written && written.length > 0 ? written : void 0;
+}
+
 // ../language-server/out/src/services/feature-path-resolver.js
 function isPublic(node) {
   for (let current2 = node; current2; current2 = current2.$container) {
@@ -163517,28 +164303,30 @@ function isPublic(node) {
   }
   return true;
 }
-var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 var inheritanceByNode = /* @__PURE__ */ new WeakMap();
 function inheritanceSyntax(node) {
   const cached = inheritanceByNode.get(node);
   if (cached)
     return cached;
   const shape = node;
-  const relationships = [...shape.preRelationships ?? [], ...shape.relationships ?? []].filter((relation) => relation.kind && SPECIALIZATION_KINDS2.has(relation.kind));
+  const relationships = [...shape.preRelationships ?? [], ...shape.relationships ?? []].filter((relation) => relation.kind && SPECIALIZATION_KINDS4.has(relation.kind));
   const implicitVariant = implicitVariantSpecialization(node)?.target;
   const externalVariant = !!externalVariantPath(node);
   const enumUsage = node.$type === "EnumDecl" && shape.isDef !== true;
+  const semanticTags = metadataUsagesAnnotating(node);
   const result = {
     relationships,
     implicitVariant,
     externalVariant,
     enumUsage,
-    hasSources: !!shape.typing || relationships.length > 0 || !!implicitVariant || externalVariant || enumUsage
+    semanticTags,
+    hasSources: !!shape.typing || relationships.length > 0 || !!implicitVariant || externalVariant || enumUsage || semanticTags.length > 0
   };
   inheritanceByNode.set(node, result);
   return result;
 }
-function nameOf(node) {
+function nameOf2(node) {
   if (node) {
     const external = externalVariantName(node);
     if (external)
@@ -163611,7 +164399,7 @@ function directNamedChildren(node) {
     const child = unwrap(raw);
     if (isReferenceFormDeclaration(child))
       continue;
-    if (!nameOf(child) || seen.has(child))
+    if (!nameOf2(child) || seen.has(child))
       continue;
     seen.add(child);
     result.push(child);
@@ -163622,7 +164410,7 @@ function directNamedChildren(node) {
 function hasName(node, name) {
   const shortName = node.shortName?.name;
   const requested = decodeUnrestrictedName(name);
-  return [nameOf(node), shortName ? canonicalEscapedName(shortName) : void 0].some((candidate) => candidate !== void 0 && decodeUnrestrictedName(candidate) === requested);
+  return [nameOf2(node), shortName ? canonicalEscapedName(shortName) : void 0].some((candidate) => candidate !== void 0 && decodeUnrestrictedName(candidate) === requested);
 }
 function matchingChildren(node, name) {
   let index2 = childrenByName.get(node);
@@ -163630,7 +164418,7 @@ function matchingChildren(node, name) {
     index2 = /* @__PURE__ */ new Map();
     for (const child of directNamedChildren(node)) {
       const shortName = child.shortName?.name;
-      const aliases = [nameOf(child), shortName ? canonicalEscapedName(shortName) : void 0];
+      const aliases = [nameOf2(child), shortName ? canonicalEscapedName(shortName) : void 0];
       for (const alias of new Set(aliases.filter((value) => value !== void 0).map(decodeUnrestrictedName))) {
         const matches = index2.get(alias) ?? [];
         matches.push(child);
@@ -163718,6 +164506,10 @@ var FeaturePathResolver = class {
   owners = /* @__PURE__ */ new WeakMap();
   propertySegments = /* @__PURE__ */ new WeakMap();
   resolvingSpecializations = /* @__PURE__ */ new Set();
+  /** issue #169 - re-entrancy guard for the semantic-metadata base walk. It
+   *  resolves the `baseType` path through `scopedSpecializationTarget`, which
+   *  runs the owner walk, which asks for the semantic base again. */
+  resolvingSemanticBases = /* @__PURE__ */ new Set();
   enumerationPathDepth = 0;
   constructor(services) {
     this.indexManager = services?.shared.workspace.IndexManager;
@@ -164094,7 +164886,7 @@ var FeaturePathResolver = class {
   resolveRoot(node, name, snapshot) {
     if (name === "self" || name === "this" || name === "that") {
       for (let owner = node.$container; owner; owner = owner.$container) {
-        if (nameOf(owner)) {
+        if (nameOf2(owner)) {
           return this.targetForNode(owner, this.memberInventoryKnown(owner, snapshot));
         }
       }
@@ -164172,7 +164964,7 @@ var FeaturePathResolver = class {
     const declared = [
       ...record.preRelationships ?? [],
       ...record.relationships ?? []
-    ].filter((relation) => relation !== under && relation.kind && SPECIALIZATION_KINDS2.has(relation.kind));
+    ].filter((relation) => relation !== under && relation.kind && SPECIALIZATION_KINDS4.has(relation.kind));
     if (declared.length === 0)
       return true;
     const written = declared.reduce((total, relation) => total + (relation.targets?.length ?? 0), 0);
@@ -164216,7 +165008,7 @@ var FeaturePathResolver = class {
     const syntax = inheritanceSyntax(node);
     if (!syntax.hasSources)
       return [];
-    const cacheable = this.resolvingSpecializations.size === 0;
+    const cacheable = this.resolvingSpecializations.size === 0 && this.resolvingSemanticBases.size === 0;
     const depthZero = this.enumerationPathDepth === 0;
     const cached = this.owners.get(node);
     if (cached && cached.snapshot === snapshot && cached.depthZero === depthZero)
@@ -164236,6 +165028,8 @@ var FeaturePathResolver = class {
       visit(inheritedSyntax.implicitVariant);
       visit(this.inferredEnumerationTarget(candidate));
       visit(this.isEnumUsage(candidate) ? this.enumerationTypingTarget(candidate) : this.typingTarget(candidate, snapshot));
+      for (const base of this.semanticBaseTargets(candidate, inheritedSyntax, snapshot))
+        visit(base);
       for (const specialized of this.specializationTargets(candidate, snapshot))
         visit(specialized);
     };
@@ -164249,6 +165043,8 @@ var FeaturePathResolver = class {
         visit(type);
     }
     visit(this.isEnumUsage(node) ? this.enumerationTypingTarget(node) : this.typingTarget(node, snapshot));
+    for (const base of this.semanticBaseTargets(node, syntax, snapshot))
+      visit(base);
     for (const specialized of this.specializationTargets(node, snapshot))
       visit(specialized);
     if (cacheable)
@@ -164312,6 +165108,88 @@ var FeaturePathResolver = class {
     }
     return typed;
   }
+  /**
+   * issue #169 - the base type a user-defined keyword gives a declaration.
+   *
+   * OMG SysML v2 Part 1 §7.27.4: `#subsystem engine;` IS `part engine :>
+   * subsystems;`, so the scope walk has to reach `subsystems`' members from
+   * `engine` exactly as a written `:>` would. The tag's metadata definition is
+   * already a resolved cross-reference, and its `baseType` is a written path
+   * read in the DEFINITION's scope, which is what
+   * {@link scopedSpecializationTarget} answers - so this adds no resolver of
+   * its own.
+   *
+   * That resolver runs the owner walk, though, and the owner walk asks for the
+   * semantic base again, so the two call each other. `resolvingSemanticBases`
+   * is what stops that: while a node's base is being resolved, asking for it
+   * again answers "none" rather than recursing, exactly as
+   * `resolvingSpecializations` guards the written walk beside it. The cycle
+   * needs the library keywords to close, so what covers it is
+   * `packages/extension/test/diagram/annex-a-layout.test.ts`, whose Annex A
+   * source carries `#mop`, `#logical` and `#derivation`.
+   *
+   * EVERY tag that names a readable base contributes, in document order and
+   * deduplicated. Two tags state two edges, and a member reachable only
+   * through the second one has to resolve too; only the effective KIND is
+   * first-tag-wins, because one element cannot be two kinds (Codex review of
+   * PR 294).
+   */
+  // REQ-420 — SemanticMetadata and user-defined keyword specialization
+  semanticBaseTargets(node, syntax, snapshot) {
+    if (syntax.semanticTags.length === 0 || this.resolvingSemanticBases.has(node))
+      return [];
+    this.resolvingSemanticBases.add(node);
+    try {
+      const resolve8 = (name, from) => this.semanticPathTarget(name, from ?? node, snapshot);
+      const bases = [];
+      for (const tag of syntax.semanticTags) {
+        const type = metadataTypeNodeOf(tag, resolve8);
+        if (!type || !semanticMetadataVerdictOf(type, resolve8).isSemantic)
+          continue;
+        const binding = baseTypeBindingsOf(type, resolve8).bindings[0];
+        if (!binding)
+          continue;
+        const base = resolve8(binding.written, binding.node) ?? resolve8(binding.written, binding.owner);
+        if (base && base !== node && !bases.includes(base))
+          bases.push(base);
+      }
+      return bases;
+    } finally {
+      this.resolvingSemanticBases.delete(node);
+    }
+  }
+  /**
+   * issue #169 - resolve one written path from a semantic metadata definition.
+   *
+   * `scopedSpecializationTarget` answers a SIMPLE name, and the libraries write
+   * qualified ones: `baseType = SDDD::idds` in `AHFProfileLib.sysml`,
+   * `system_of_systems::locclouds` beside it. Rejecting a name with separators
+   * left those keywords with no inherited members at all, so the root segment
+   * is resolved in the definition's scope and the rest is a member descent,
+   * inherited members included (Codex review of PR 294).
+   */
+  semanticPathTarget(written, from, snapshot) {
+    const segments = written.split(/::|\./u).map((segment) => simpleRelationName(segment.trim())).filter((segment) => !!segment);
+    if (segments.length === 0)
+      return void 0;
+    let current2 = this.scopedSpecializationTarget(from, segments[0], snapshot);
+    for (let index2 = 1; current2 && index2 < segments.length; index2 += 1) {
+      const name = segments[index2];
+      const own = matchingChildren(current2, name)[0];
+      if (own) {
+        current2 = own;
+        continue;
+      }
+      let inherited;
+      for (const owner of this.typedAndSpecializedOwners(current2, snapshot)) {
+        inherited = matchingChildren(owner, name)[0];
+        if (inherited)
+          break;
+      }
+      current2 = inherited;
+    }
+    return current2;
+  }
   specializationTargets(node, snapshot) {
     const { relationships } = inheritanceSyntax(node);
     if (relationships.length === 0 || this.resolvingSpecializations.has(node))
@@ -164373,7 +165251,7 @@ var FeaturePathResolver = class {
     }
   }
   targetForNode(node, certain = false) {
-    const name = nameOf(node);
+    const name = nameOf2(node);
     let description;
     if (name && this.descriptions) {
       try {
@@ -164425,7 +165303,7 @@ var FeaturePathResolver = class {
       }
     } else {
       for (const node of [root4, ...ast_utils_exports.streamAllContents(root4)]) {
-        const name = nameOf(node);
+        const name = nameOf2(node);
         if (!name)
           continue;
         const values2 = byName.get(name) ?? [];
@@ -164453,138 +165331,6 @@ var FeaturePathResolver = class {
   }
 };
 
-// ../language-server/out/src/services/calculation-semantics.js
-function effectiveCalculationResult(node, resolve8) {
-  const seen = /* @__PURE__ */ new Set();
-  const walk = (current2, depth) => {
-    if (depth > 32 || seen.has(current2))
-      return void 0;
-    seen.add(current2);
-    const parameter = current2.members?.find((member) => member.$type === "ReturnDecl");
-    if (parameter || current2.body)
-      return {
-        parameter,
-        expression: parameter?.value ?? current2.body,
-        inherited: current2 !== node
-      };
-    const parents = supertypesOf(current2, resolve8).filter((parent) => parent.$type === "CalcDecl");
-    if (parents.length !== 1)
-      return void 0;
-    return walk(parents[0], depth + 1);
-  };
-  return walk(node, 0);
-}
-
-// ../language-server/out/src/platform/platform.js
-var current;
-function setPlatform(platform) {
-  current = platform;
-}
-function getPlatform() {
-  if (!current)
-    throw new Error("SysML: no platform installed - the entry point must call setPlatform() first.");
-  return current;
-}
-function hasPlatform() {
-  return current !== void 0;
-}
-
-// ../language-server/out/src/services/library-index-manager.js
-var SysmlIndexManager = class extends DefaultIndexManager {
-  constructor(services) {
-    super(services);
-  }
-  // REQ-075, REQ-383 — `libraryRoot` is a URI and the concrete file URIs come
-  // from the platform, because the two hosts index the same library under
-  // different schemes (`file:` on the desktop, `sysml-lib:` in a worker).
-  loadPrecomputedLibraryIndex(index2, libraryRoot) {
-    const platform = getPlatform();
-    let symbolCount = 0;
-    for (const file of index2.files) {
-      const documentUri = platform.libraryUri(libraryRoot, file.path);
-      const descriptions = file.symbols.map((symbol) => this.deserializeSymbol(symbol, documentUri));
-      const uri = documentUri.toString();
-      this.symbolIndex.set(uri, descriptions);
-      this.symbolByTypeIndex.clear(uri);
-      symbolCount += descriptions.length;
-    }
-    return symbolCount;
-  }
-  deserializeSymbol(symbol, documentUri) {
-    return {
-      name: symbol.name,
-      type: symbol.type,
-      path: symbol.path,
-      documentUri,
-      nameSegment: symbol.nameSegment,
-      selectionSegment: symbol.selectionSegment,
-      // REQ-068 — preserve declared visibility for wildcard re-export.
-      ...symbol.isPrivate ? { isPrivate: true } : {},
-      ...symbol.visibility ? { visibility: symbol.visibility } : {},
-      // issue #152 — a re-exported alias is not owned nesting.
-      ...symbol.derivedKind ? { derivedKind: symbol.derivedKind } : {},
-      // REQ-242 — issue #103 — keeps type completion to definitions.
-      ...symbol.isUsage ? { isUsage: true } : {}
-    };
-  }
-};
-function isSysmlIndexManager(value) {
-  return typeof value.loadPrecomputedLibraryIndex === "function";
-}
-var libraryRoots = /* @__PURE__ */ new Set();
-var ROOT_SEPARATOR = "\0";
-function normalizeLibraryPath(p) {
-  return p.replace(/\\/gu, "/").replace(/\/+$/u, "").toLowerCase();
-}
-function registerLibraryRoot(root4) {
-  const uri = typeof root4 === "string" ? root4.length > 0 ? URI2.file(root4) : void 0 : root4;
-  if (!uri)
-    return;
-  libraryRoots.add(`${uri.scheme}${ROOT_SEPARATOR}${normalizeLibraryPath(uri.path)}`);
-}
-function isInsideDir(fsPath, dir) {
-  return fsPath === dir || fsPath.startsWith(`${dir}/`);
-}
-function isStandardLibraryUri(uri) {
-  const fsPath = normalizeLibraryPath(uri.path);
-  for (const entry of libraryRoots) {
-    const separator = entry.indexOf(ROOT_SEPARATOR);
-    if (entry.slice(0, separator) !== uri.scheme)
-      continue;
-    if (isInsideDir(fsPath, entry.slice(separator + 1)))
-      return true;
-  }
-  return fsPath.split("/").some((segment) => segment === "sysml.library");
-}
-function isLibraryDocument(doc) {
-  return doc.isLibraryDocument === true || isStandardLibraryUri(doc.uri);
-}
-
-// ../language-server/out/src/services/namespace-kind.js
-var KERML_CLASSIFIER_DECL_TYPES = /* @__PURE__ */ new Set([
-  "AssociationDecl",
-  "BehaviorDecl",
-  "ClassDecl",
-  "ClassifierDecl",
-  "DatatypeDecl",
-  "FunctionDecl",
-  "InteractionDecl",
-  "MetaclassDecl",
-  "PredicateDecl",
-  "StructDecl",
-  "TypeDecl"
-]);
-function isNamespaceOnlyDecl(node) {
-  if (isPackage(node) || node.$type === "NamespaceDecl" || node.$type === "BareDefDecl")
-    return true;
-  if (KERML_CLASSIFIER_DECL_TYPES.has(node.$type))
-    return true;
-  return node.isDef === true;
-}
-function memberSeparator(owner) {
-  return isDocument(owner) || isNamespaceOnlyDecl(owner) ? "::" : ".";
-}
-
 // ../language-server/out/src/services/name-lookup.js
 function unquoteName(name) {
   return name.replace(/^'(.*)'$/u, "$1");
@@ -164616,7 +165362,7 @@ function pathSegments2(path10) {
   segments.push(current2);
   return segments;
 }
-function simpleNameOf(name) {
+function simpleNameOf2(name) {
   return pathSegments2(name).at(-1) ?? name;
 }
 var ELEMENT_SEPARATOR = "\0";
@@ -164672,7 +165418,7 @@ var SysmlNameLookup = class {
    * its final segment. Both readings must name exactly one element.
    */
   uniqueForPath(path10, accept) {
-    return this.unique(path10, accept) ?? this.unique(simpleNameOf(path10), accept);
+    return this.unique(path10, accept) ?? this.unique(simpleNameOf2(path10), accept);
   }
   /**
    * The declared spellings of the element `description` names — its regular
@@ -164736,8 +165482,140 @@ function nameLookupFor(shared) {
   return created;
 }
 
+// ../language-server/out/src/services/calculation-semantics.js
+function effectiveCalculationResult(node, resolve8) {
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (current2, depth) => {
+    if (depth > 32 || seen.has(current2))
+      return void 0;
+    seen.add(current2);
+    const parameter = current2.members?.find((member) => member.$type === "ReturnDecl");
+    if (parameter || current2.body)
+      return {
+        parameter,
+        expression: parameter?.value ?? current2.body,
+        inherited: current2 !== node
+      };
+    const parents = supertypesOf(current2, resolve8).filter((parent) => parent.$type === "CalcDecl");
+    if (parents.length !== 1)
+      return void 0;
+    return walk(parents[0], depth + 1);
+  };
+  return walk(node, 0);
+}
+
+// ../language-server/out/src/platform/platform.js
+var current;
+function setPlatform(platform) {
+  current = platform;
+}
+function getPlatform() {
+  if (!current)
+    throw new Error("SysML: no platform installed - the entry point must call setPlatform() first.");
+  return current;
+}
+function hasPlatform() {
+  return current !== void 0;
+}
+
+// ../language-server/out/src/services/library-index-manager.js
+var SysmlIndexManager = class extends DefaultIndexManager {
+  constructor(services) {
+    super(services);
+  }
+  // REQ-075, REQ-383 — `libraryRoot` is a URI and the concrete file URIs come
+  // from the platform, because the two hosts index the same library under
+  // different schemes (`file:` on the desktop, `sysml-lib:` in a worker).
+  loadPrecomputedLibraryIndex(index2, libraryRoot) {
+    const platform = getPlatform();
+    let symbolCount = 0;
+    for (const file of index2.files) {
+      const documentUri = platform.libraryUri(libraryRoot, file.path);
+      const descriptions = file.symbols.map((symbol) => this.deserializeSymbol(symbol, documentUri));
+      const uri = documentUri.toString();
+      this.symbolIndex.set(uri, descriptions);
+      this.symbolByTypeIndex.clear(uri);
+      symbolCount += descriptions.length;
+    }
+    return symbolCount;
+  }
+  deserializeSymbol(symbol, documentUri) {
+    return {
+      name: symbol.name,
+      type: symbol.type,
+      path: symbol.path,
+      documentUri,
+      nameSegment: symbol.nameSegment,
+      selectionSegment: symbol.selectionSegment,
+      // REQ-068 — preserve declared visibility for wildcard re-export.
+      ...symbol.isPrivate ? { isPrivate: true } : {},
+      ...symbol.visibility ? { visibility: symbol.visibility } : {},
+      // issue #152 — a re-exported alias is not owned nesting.
+      ...symbol.derivedKind ? { derivedKind: symbol.derivedKind } : {},
+      // REQ-242 — issue #103 — keeps type completion to definitions.
+      ...symbol.isUsage ? { isUsage: true } : {}
+    };
+  }
+};
+function isSysmlIndexManager(value) {
+  return typeof value.loadPrecomputedLibraryIndex === "function";
+}
+var libraryRoots = /* @__PURE__ */ new Set();
+var ROOT_SEPARATOR = "\0";
+function normalizeLibraryPath(p) {
+  return p.replace(/\\/gu, "/").replace(/\/+$/u, "").toLowerCase();
+}
+function registerLibraryRoot(root4) {
+  const uri = typeof root4 === "string" ? root4.length > 0 ? URI2.file(root4) : void 0 : root4;
+  if (!uri)
+    return;
+  libraryRoots.add(`${uri.scheme}${ROOT_SEPARATOR}${normalizeLibraryPath(uri.path)}`);
+}
+function isInsideDir(fsPath, dir) {
+  return fsPath === dir || fsPath.startsWith(`${dir}/`);
+}
+function isStandardLibraryUri(uri) {
+  const fsPath = normalizeLibraryPath(uri.path);
+  for (const entry of libraryRoots) {
+    const separator = entry.indexOf(ROOT_SEPARATOR);
+    if (entry.slice(0, separator) !== uri.scheme)
+      continue;
+    if (isInsideDir(fsPath, entry.slice(separator + 1)))
+      return true;
+  }
+  return fsPath.split("/").some((segment) => segment === "sysml.library");
+}
+function isLibraryDocument(doc) {
+  return doc.isLibraryDocument === true || isStandardLibraryUri(doc.uri);
+}
+
+// ../language-server/out/src/services/namespace-kind.js
+var KERML_CLASSIFIER_DECL_TYPES = /* @__PURE__ */ new Set([
+  "AssociationDecl",
+  "BehaviorDecl",
+  "ClassDecl",
+  "ClassifierDecl",
+  "DatatypeDecl",
+  "FunctionDecl",
+  "InteractionDecl",
+  "MetaclassDecl",
+  "PredicateDecl",
+  "StructDecl",
+  "TypeDecl"
+]);
+function isNamespaceOnlyDecl(node) {
+  if (isPackage(node) || node.$type === "NamespaceDecl" || node.$type === "BareDefDecl")
+    return true;
+  if (KERML_CLASSIFIER_DECL_TYPES.has(node.$type))
+    return true;
+  return node.isDef === true;
+}
+function memberSeparator(owner) {
+  return isDocument(owner) || isNamespaceOnlyDecl(owner) ? "::" : ".";
+}
+
 // ../language-server/out/src/services/effective-name.js
-var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var REDEFINITION_KINDS3 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var NO_CANDIDATES = [];
 var NO_RESOLVER = () => NO_CANDIDATES;
 var nameable = /* @__PURE__ */ new Map();
@@ -164771,7 +165649,7 @@ function firstRedefinitionPath(node) {
     for (const relationship of group) {
       if (typeof relationship?.kind !== "string")
         continue;
-      if (!REDEFINITION_KINDS2.has(relationship.kind))
+      if (!REDEFINITION_KINDS3.has(relationship.kind))
         continue;
       const targets = relationship.targets;
       if (!Array.isArray(targets))
@@ -164785,7 +165663,7 @@ function firstRedefinitionPath(node) {
   return void 0;
 }
 function writtenNameOf(path10) {
-  const segment = simpleNameOf(path10).replace(/\s*\[[^\]]*\]\s*$/u, "").trim();
+  const segment = simpleNameOf2(path10).replace(/\s*\[[^\]]*\]\s*$/u, "").trim();
   return segment.length > 0 ? segment : void 0;
 }
 var memos = /* @__PURE__ */ new WeakMap();
@@ -165816,7 +166694,7 @@ function nearestUnits(symbol, limit) {
 }
 
 // ../language-server/out/src/services/conformance.js
-var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([
+var SPECIALIZATION_KINDS5 = /* @__PURE__ */ new Set([
   ":>",
   ":>>",
   "specializes",
@@ -165848,7 +166726,7 @@ function specializedNamesOf(node) {
   const decl = node;
   const out = [];
   for (const rel2 of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
-    if (!rel2.kind || !SPECIALIZATION_KINDS3.has(rel2.kind))
+    if (!rel2.kind || !SPECIALIZATION_KINDS5.has(rel2.kind))
       continue;
     for (const target of rel2.targets ?? []) {
       const text = target.trim();
@@ -166499,7 +167377,7 @@ function candidatesOf(node) {
       continue;
     out.push({ text: written.text, ref: written.ref });
   }
-  for (const target of specializationTargetsOf(node))
+  for (const target of specializationTargetsOf3(node))
     out.push({ text: target });
   return out;
 }
@@ -166523,7 +167401,7 @@ function owningOccurrenceOf(node) {
   return NON_OCCURRENCE_DECL_TYPES.has(owner.$type) ? void 0 : owner;
 }
 var MAX_ALIAS_HOPS = 8;
-var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([
+var SPECIALIZATION_KINDS6 = /* @__PURE__ */ new Set([
   ":>",
   "subsets",
   ":>>",
@@ -166531,11 +167409,11 @@ var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([
   "specializes",
   "subtype"
 ]);
-function specializationTargetsOf(node) {
+function specializationTargetsOf3(node) {
   const decl = node;
   const out = [];
   for (const rel2 of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
-    if (!rel2.kind || !SPECIALIZATION_KINDS4.has(rel2.kind))
+    if (!rel2.kind || !SPECIALIZATION_KINDS6.has(rel2.kind))
       continue;
     for (const target of rel2.targets ?? []) {
       const text = target.trim();
@@ -166742,7 +167620,7 @@ function isAstDescendantOrSelf(node, ancestor) {
   return false;
 }
 function ivEditMeta(part, instanceId, definition, localUsage, localPath, uri) {
-  const declarationId = nameOf2(part) ? qnameOf(part) || instanceId : instanceId;
+  const declarationId = nameOf3(part) ? qnameOf(part) || instanceId : instanceId;
   const definitionId = definition ? qnameOf(definition) : void 0;
   const localUsageId = localUsage ? qnameOf(localUsage) : void 0;
   return {
@@ -166751,19 +167629,19 @@ function ivEditMeta(part, instanceId, definition, localUsage, localPath, uri) {
     declarationName: effectiveNameOf(part),
     declarationSource: sourceOf2(part, uri),
     definitionId,
-    definitionName: definition ? nameOf2(definition) : void 0,
+    definitionName: definition ? nameOf3(definition) : void 0,
     definitionSource: definition ? sourceOf2(definition, uri) : void 0,
     localUsageId,
-    localUsageName: localUsage ? nameOf2(localUsage) : void 0,
+    localUsageName: localUsage ? nameOf3(localUsage) : void 0,
     localUsageSource: localUsage ? sourceOf2(localUsage, uri) : void 0,
     localUsagePath: [...localPath],
     expandedFromDefinition: declarationId !== instanceId,
     // A named declaration remains local even when an anonymous `:>>`
     // wrapper removes its name from the rendered occurrence path.
-    localDeclaration: !!nameOf2(part) && !!localUsage && isAstDescendantOrSelf(part, localUsage)
+    localDeclaration: !!nameOf3(part) && !!localUsage && isAstDescendantOrSelf(part, localUsage)
   };
 }
-var nameOf2 = (node) => {
+var nameOf3 = (node) => {
   const external = externalVariantName(node);
   if (external)
     return external;
@@ -166792,7 +167670,7 @@ function qnameOf(node) {
   const parts = [];
   let cur = node;
   while (cur && !isDocument(cur)) {
-    const nm = nameOf2(cur);
+    const nm = nameOf3(cur);
     if (nm)
       parts.unshift(nm);
     cur = cur.$container;
@@ -166914,7 +167792,7 @@ function declaredConnectionEndNotation(node) {
     }
   }
   return mergeConnectionEndNotation({
-    role: n2.innerName ?? nameOf2(node) ?? redefines.map(lastSeg).find(Boolean),
+    role: n2.innerName ?? nameOf3(node) ?? redefines.map(lastSeg).find(Boolean),
     multiplicity: connectionEndMultiplicity(node),
     direction,
     properties,
@@ -166944,9 +167822,9 @@ var prefixTagsOf = (node) => {
   return [...own, ...wrap2].map((t) => t.type?.$refText).filter((s) => !!s);
 };
 var metadataAttrsText = (node) => {
-  const pairs = membersOf(node).filter((m) => m.$type === "EnumValueDecl" && nameOf2(m) && m.value).map((m) => {
+  const pairs = membersOf(node).filter((m) => m.$type === "EnumValueDecl" && nameOf3(m) && m.value).map((m) => {
     const value = m.value.$cstNode?.text ?? "";
-    return `${nameOf2(m)} = ${value}`.replace(/\s+/g, " ").trim();
+    return `${nameOf3(m)} = ${value}`.replace(/\s+/g, " ").trim();
   });
   return pairs.length ? pairs.join(", ") : void 0;
 };
@@ -166967,10 +167845,24 @@ function parameterKeyword(node) {
   }
   return owner && (isConstraintDecl(owner) || isCalcDecl(owner)) ? `${direction} parameter` : void 0;
 }
+var effectiveSemanticKinds = /* @__PURE__ */ new WeakMap();
+var isEffectivePartDecl = (node) => isPartDecl(node) || effectiveDeclTypeOf(node) === "PartDecl";
+function semanticKeywordOf(node) {
+  if (!isKeywordlessDeclaration(node))
+    return void 0;
+  const kind = effectiveSemanticKinds.get(node);
+  return kind ? effectiveKeywordOf(kind) : void 0;
+}
+function effectiveDeclTypeOf(node) {
+  return effectiveSemanticKinds.get(node)?.declType ?? node.$type;
+}
 function keywordFor(node) {
   const n2 = node;
   if (node.$type === "VariantReference")
     return "variant";
+  const semantic = semanticKeywordOf(node);
+  if (semantic)
+    return semantic;
   const def = n2.isDef === true;
   const t = node.$type;
   const base = {
@@ -167092,7 +167984,7 @@ var ANONYMOUS_INTERFACE_NAME = "(anonymous)";
 var isEndMember = (node) => node.$type === "EndDecl" || modifiersOf2(node).includes("end");
 function endRowText(node) {
   const end = node;
-  const name = nameOf2(node) ?? end.innerName;
+  const name = nameOf3(node) ?? end.innerName;
   const type = typeText(node) ?? end.innerTyping?.type?.$refText;
   const mult = declaredMultText(node) ?? multiplicityText(end.innerMultiplicity) ?? multiplicityText(end.endMultiplicity);
   const head2 = `${name ?? ""}${type ? `${name ? " " : ""}: ${type}` : ""}`.trim();
@@ -167122,14 +168014,14 @@ var individualMetaOf = (node) => {
     }
   };
 };
-var redefinedNameOf = (node) => {
+var redefinedNameOf2 = (node) => {
   const names = effectiveNamesOf(node, localResolverFor(node));
   return names.origin === "derived" || names.origin === "written" ? names.name ?? names.shortName : void 0;
 };
-var effectiveNameOf = (node) => nameOf2(node) ?? redefinedNameOf(node);
+var effectiveNameOf = (node) => nameOf3(node) ?? redefinedNameOf2(node);
 var portionLabelOf = (node) => effectiveNameOf(node);
 function diagramNodeId(node) {
-  const name = nameOf2(node);
+  const name = nameOf3(node);
   if (name)
     return qnameOf(node) || name;
   const label = portionLabelOf(node);
@@ -167153,10 +168045,10 @@ var GV_EXPLICIT_USAGE_KINDS = /* @__PURE__ */ new Set([
   "VariantReference"
 ]);
 function isGvAnnotationNode(node) {
-  return ["CommentStmt", "RepStmt", "DocCommentMember", "MetadataAnnotation"].includes(node.$type) || isMetadataDecl(node) && !isDefinitionNode(node) && !!(nameOf2(node) || typeText(node));
+  return ["CommentStmt", "RepStmt", "DocCommentMember", "MetadataAnnotation"].includes(node.$type) || isMetadataDecl(node) && !isDefinitionNode(node) && !!(nameOf3(node) || typeText(node));
 }
 function isGvExplicitUsage(node) {
-  return !isDefinitionNode(node) && !isGvAnnotationNode(node) && !(node.$type === "PerformStmt" && node.actionKw !== true) && !(isInterfaceDecl(node) && node.target !== void 0 && node.connect === void 0) && !!(effectiveNameOf(node) ?? nameOf2(node)) && (isDefinitionKind(node) || isDeclaredEventOccurrence(node) || GV_EXPLICIT_USAGE_KINDS.has(node.$type) || isActionFlowStep(node));
+  return !isDefinitionNode(node) && !isGvAnnotationNode(node) && !(node.$type === "PerformStmt" && node.actionKw !== true) && !(isInterfaceDecl(node) && node.target !== void 0 && node.connect === void 0) && !!(effectiveNameOf(node) ?? nameOf3(node)) && (isDefinitionKind(node) || isDeclaredEventOccurrence(node) || GV_EXPLICIT_USAGE_KINDS.has(node.$type) || isActionFlowStep(node));
 }
 function specializationTargets(node) {
   const n2 = node;
@@ -167342,10 +168234,11 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       notes: [note]
     });
     const index2 = this.localIndex(root4);
+    const semantic = this.primeSemanticKeywords(root4);
     const anchor = !rootSymbol && preferFileOverview ? this.fileOverviewAnchor(root4) : this.findAnchor(root4, rootSymbol, kind, index2);
     if (!anchor)
       return empty2(`No anchor element found for the ${kind.toUpperCase()} view.`);
-    const ctx = { uri, index: index2, anchor, diagramRoot: anchor, gridPreset, matrixRelationship };
+    const ctx = { uri, index: index2, anchor, diagramRoot: anchor, gridPreset, matrixRelationship, semantic };
     const overview = isPackage(anchor) || isDocument(anchor);
     const build = () => {
       switch (kind) {
@@ -167553,7 +168446,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   hasAnyGridContent(anchor) {
     const scope = this.packageScopeOf(anchor);
     for (const node of ast_utils_exports.streamAllContents(scope)) {
-      if (isDefinitionKind(node) && nameOf2(node))
+      if (isDefinitionKind(node) && nameOf3(node))
         return true;
       const n2 = node;
       if (node.$type === "AllocateStmt" || node.$type === "DependencyDecl" || node.$type === "SatisfyStmt" || node.$type === "FlowStmt" && n2.flowKind !== "message" || node.$type === "ConnectStmt" || node.$type === "ConnectionDecl" && n2.isDef !== true && n2.connect !== void 0)
@@ -167574,7 +168467,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     for (const node of [root4, ...this.rootContents(root4)]) {
       if (node.$type === "ImportSeg")
         continue;
-      const nm = nameOf2(node);
+      const nm = nameOf3(node);
       if (nm && !map3.has(nm))
         map3.set(nm, node);
     }
@@ -167630,7 +168523,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           annotation: comment,
           owner,
           keyword: "comment",
-          label: nameOf2(comment) ?? "comment",
+          label: nameOf3(comment) ?? "comment",
           body: annotationText(trailingBlockBody(comment))
         });
       }
@@ -167642,7 +168535,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         annotation: doc,
         owner: doc.$container,
         keyword: "doc",
-        label: nameOf2(doc) ?? "doc",
+        label: nameOf3(doc) ?? "doc",
         body: annotationText(docCommentBody(doc))
       });
     }
@@ -167685,6 +168578,38 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return void 0;
     return multiplicity2.text;
   }
+  /**
+   * issue #293 — read the document's user-defined keywords once, and record
+   * the effective kind each one gives a keywordless declaration.
+   *
+   * Called before anything projects the AST, so `keywordFor` and the kind
+   * tests see the model rather than the parse. The result is cached per parse
+   * AND per workspace-index epoch, because a `baseType` may name an element in
+   * another file whose resolution changes as the index fills.
+   */
+  // REQ-420 — SemanticMetadata and user-defined keyword specialization
+  primeSemanticKeywords(root4) {
+    const cache = this.perParse(root4);
+    if (cache.semanticKeywords?.epoch === this.indexEpoch)
+      return cache.semanticKeywords.model;
+    const paths = this.annotationPathResolver(root4);
+    const lookup = this.shared ? nameLookupFor(this.shared) : void 0;
+    const model = new SemanticMetadataModel(metadataNameResolver({
+      visibleCandidates: (from, name) => paths.resolveVisibleNameCandidates(from, name),
+      descriptionsFor: (name) => lookup?.descriptions(name) ?? [],
+      nodeFor: (description) => this.annotationDescriptionNode(root4, description)
+    }), (usage, _text, occurrence) => {
+      const candidates = paths.resolvePropertyPathCandidates(usage, "targets", occurrence);
+      return candidates.length === 1 ? candidates[0] : void 0;
+    }).build(root4);
+    for (const element of model.annotatedElements()) {
+      const kind = effectiveKindOf(element, model.annotationsOf(element));
+      if (kind)
+        effectiveSemanticKinds.set(element, kind);
+    }
+    cache.semanticKeywords = { epoch: this.indexEpoch, model };
+    return model;
+  }
   annotationDescriptionNode(context, description) {
     if (!description)
       return void 0;
@@ -167718,12 +168643,12 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const unrooted = path10.replace(/^\s*\$\s*::\s*/u, "");
       if (!/::|\./u.test(unrooted)) {
         for (let scope = comment.$container; scope; scope = scope.$container) {
-          const local = membersOf(scope).find((member) => member !== comment && nameOf2(member) === unrooted);
+          const local = membersOf(scope).find((member) => member !== comment && nameOf3(member) === unrooted);
           if (local)
             return local;
           const declaringIndex = this.localIndex(this.documentRootOf(scope));
           for (const inherited of this.inheritedFeatureOwnersOf(scope, declaringIndex)) {
-            const inheritedMember = membersOf(inherited).find((member) => nameOf2(member) === unrooted);
+            const inheritedMember = membersOf(inherited).find((member) => nameOf3(member) === unrooted);
             if (inheritedMember)
               return inheritedMember;
           }
@@ -167847,7 +168772,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
    * in definition-sync mode address this feature, while child insertion still
    * addresses the feature's typing definition. */
   synchronizationDeclarationOf(node, index2) {
-    if (nameOf2(node))
+    if (nameOf3(node))
       return node;
     const wanted = effectiveNameOf(node);
     return this.inheritedFeatureOwnersOf(node, index2).find((candidate) => candidate.isDef !== true && effectiveNameOf(candidate) === wanted && (isPartDecl(node) ? isPartDecl(candidate) : isPortDecl(node) ? isPortDecl(candidate) : true));
@@ -167939,7 +168864,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return this.hasAnchorContent(root4, "bv", index2) ? root4 : void 0;
     }
     if (rootSymbol) {
-      const resolved = all.find((n2) => n2.$type !== "ImportSeg" && nameOf2(n2) !== void 0 && qnameOf(n2) === rootSymbol) ?? index2.get(rootSymbol) ?? index2.get(lastSeg(rootSymbol));
+      const resolved = all.find((n2) => n2.$type !== "ImportSeg" && nameOf3(n2) !== void 0 && qnameOf(n2) === rootSymbol) ?? index2.get(rootSymbol) ?? index2.get(lastSeg(rootSymbol));
       if (resolved) {
         if (kind === "bv")
           return resolved;
@@ -168007,7 +168932,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // the no-rootSymbol fallback still prefers a contentful anchor.
   canHostView(node, kind) {
     if (kind === "iv")
-      return isPartDecl(node) && node.isDef !== true;
+      return isEffectivePartDecl(node) && node.isDef !== true;
     if (kind === "gev")
       return isPartDecl(node) || isPackage(node) || isDocument(node);
     return false;
@@ -168027,7 +168952,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       case "gv":
         return true;
       case "iv":
-        return isPartDecl(node);
+        return isEffectivePartDecl(node);
       case "afv":
         return isActionDecl(node) || isCalcDecl(node) || isPartDecl(node) || this.isCaseLike(node);
       case "stv":
@@ -168052,7 +168977,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // and `findAnchor` drills to them, so a view opened on the OWNER of an empty
   // action definition shows the same thing the package overview does.
   isAfvScaffoldAnchor(node) {
-    return (isActionDecl(node) || isCalcDecl(node)) && !!nameOf2(node) && (node.isDef === true || this.isDirectPackageMember(node));
+    return (isActionDecl(node) || isCalcDecl(node)) && !!nameOf3(node) && (node.isDef === true || this.isDirectPackageMember(node));
   }
   // REQ-196 — a member that is a STEP of the flow its holder runs: an action
   // usage, a send/accept/assign node, or a `perform`. An action DEFINITION is
@@ -168159,13 +169084,13 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return own;
     };
     const memberNamed3 = (holder, seg) => {
-      const own = pathVisibleMembers(holder).find((m) => nameOf2(m) === seg);
+      const own = pathVisibleMembers(holder).find((m) => nameOf3(m) === seg);
       if (own)
         return own;
       const def = holder.isDef === true ? void 0 : this.resolveType(holder, index2);
       if (!def || def === holder)
         return void 0;
-      return pathVisibleMembers(def).find((m) => nameOf2(m) === seg);
+      return pathVisibleMembers(def).find((m) => nameOf3(m) === seg);
     };
     let cur;
     for (let owner = stmt.$container; owner && !cur; owner = owner.$container) {
@@ -168173,7 +169098,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     }
     if (!cur) {
       const indexed = index2.get(segs[0]);
-      cur = indexed && declares(indexed) ? indexed : this.rootContents(this.documentRootOf(stmt)).find((n2) => declares(n2) && nameOf2(n2) === segs[0]);
+      cur = indexed && declares(indexed) ? indexed : this.rootContents(this.documentRootOf(stmt)).find((n2) => declares(n2) && nameOf3(n2) === segs[0]);
     }
     for (const seg of segs.slice(1)) {
       if (!cur)
@@ -168240,7 +169165,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         ...paramType && !repeatedType ? membersOf(paramType) : []
       ];
       for (const inner of sources) {
-        const nn = nameOf2(inner);
+        const nn = nameOf3(inner);
         if (!nn || !directionOf(inner) || seen.has(nn))
           continue;
         seen.add(nn);
@@ -168258,7 +169183,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const result = effectiveCalculationResult(action, (name) => index2.get(name));
       if (result) {
         const parameter = result.parameter;
-        const name = parameter ? nameOf2(parameter) ?? "result" : "result";
+        const name = parameter ? nameOf3(parameter) ?? "result" : "result";
         pins.push({
           id: `${ownerId}.${name}`,
           name,
@@ -168296,16 +169221,16 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       if (node.isDef === true)
         continue;
       const def = this.resolveType(node, index2);
-      if (!def || def.isDef !== true || !nameOf2(def) || def === node)
+      if (!def || def.isDef !== true || !nameOf3(def) || def === node)
         continue;
       if (!ownedByDiagramRoot(def, root4))
         continue;
       if (!seen.has(def)) {
-        const defId = qnameOf(def) || nameOf2(def);
+        const defId = qnameOf(def) || nameOf3(def);
         if (!drawnIds.has(defId)) {
           nodes.push({
             id: defId,
-            name: nameOf2(def),
+            name: nameOf3(def),
             keyword: keywordFor(def),
             isDef: true,
             shape,
@@ -168390,19 +169315,19 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           return true;
         if (!isPackage(node) && !isDocument(node))
           return false;
-        return ast_utils_exports.streamAllContents(node).some((member) => isDefinitionNode(member) && !!nameOf2(member) || isGvExplicitUsage(member) || isGvAnnotationNode(member) || isPackage(member) && !!nameOf2(member));
+        return ast_utils_exports.streamAllContents(node).some((member) => isDefinitionNode(member) && !!nameOf3(member) || isGvExplicitUsage(member) || isGvAnnotationNode(member) || isPackage(member) && !!nameOf3(member));
       }
       case "iv":
         if (isPartDecl(node)) {
           return this.hasNestedPartUsages(node, index2) || this.hasRenderablePorts(node, index2);
         }
-        return (isPackage(node) || isDocument(node)) && this.nestedUsages(node, isPartDecl).some((n2) => nameOf2(n2) !== void 0);
+        return (isPackage(node) || isDocument(node)) && this.nestedUsages(node, isPartDecl).some((n2) => nameOf3(n2) !== void 0);
       case "afv": {
         if (isCalcDecl(node))
           return true;
         if (isActionDecl(node) || this.isCaseLike(node)) {
           const actions = membersOf(node).map((member) => this.thenActionMemberNode(member) ?? member).filter((n2) => isActionDecl(n2) || isCalcDecl(n2));
-          if (actions.some((n2) => nameOf2(n2) !== void 0))
+          if (actions.some((n2) => nameOf3(n2) !== void 0))
             return true;
           return node.inlineBody !== void 0;
         }
@@ -168415,15 +169340,15 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       case "stv":
         if (!(isExhibitStateDecl(node) || isStateDecl(node)))
           return false;
-        if (membersOf(node).some((n2) => isStateDecl(n2) && nameOf2(n2) !== void 0))
+        if (membersOf(node).some((n2) => isStateDecl(n2) && nameOf3(n2) !== void 0))
           return true;
         const stateDef = node.isDef !== true ? this.resolveType(node, index2) : void 0;
-        return !!stateDef && stateDef !== node && membersOf(stateDef).some((n2) => isStateDecl(n2) && nameOf2(n2) !== void 0);
+        return !!stateDef && stateDef !== node && membersOf(stateDef).some((n2) => isStateDecl(n2) && nameOf3(n2) !== void 0);
       // REQ-202 — a focused Sequence View may be opened as a participant
       // scaffold before messages are added; package tiling applies the
       // stricter interaction filter in collectOverviewAnchors.
       case "sv":
-        return (isPartDecl(node) || isOccurrenceDecl(node) || this.isCaseLike(node) || isPackage(node)) && this.nestedUsages(node, isPartDecl).some((n2) => nameOf2(n2) !== void 0);
+        return (isPartDecl(node) || isOccurrenceDecl(node) || this.isCaseLike(node) || isPackage(node)) && this.nestedUsages(node, isPartDecl).some((n2) => nameOf3(n2) !== void 0);
       case "cv": {
         if (!(this.isCaseLike(node) || isPackage(node) || isDocument(node)))
           return false;
@@ -168438,7 +169363,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         return this.hasAnyGridContent(node);
       }
       case "bv":
-        return (isPackage(node) || isDocument(node)) && [...ast_utils_exports.streamAllContents(node)].some((n2) => nameOf2(n2) !== void 0);
+        return (isPackage(node) || isDocument(node)) && [...ast_utils_exports.streamAllContents(node)].some((n2) => nameOf3(n2) !== void 0);
     }
   }
   // REQ-205 — the Geometry View shows ONLY geometry objects, so a node anchors
@@ -168477,7 +169402,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // The predicate form of `childUsagesOf`, so an anchor that only INHERITS
   // internals is recognised as having them.
   hasNestedPartUsages(node, index2) {
-    return this.structuralChildUsagesOf(node, index2).some((usage) => nameOf2(usage) !== void 0);
+    return this.structuralChildUsagesOf(node, index2).some((usage) => nameOf3(usage) !== void 0);
   }
   nestedUsages(node, guard) {
     return membersOf(node).filter((m) => guard(m) && m.isDef !== true);
@@ -168505,10 +169430,10 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
    * fold used for other effective inventories. Authored subsets of an inherited
    * library collection stay visible; only the inherited recursive role is hidden. */
   structuralChildUsagesOf(part, index2) {
-    const out = this.nestedUsages(part, isPartDecl);
+    const out = this.nestedUsages(part, isEffectivePartDecl);
     const have = new Set(out.map(effectiveNameOf).filter((name) => !!name));
     for (const source of this.inheritedFeatureOwnersOf(part, index2)) {
-      for (const usage of this.nestedUsages(source, isPartDecl)) {
+      for (const usage of this.nestedUsages(source, isEffectivePartDecl)) {
         if (this.isInheritedLibraryBackboneFeature(source, usage, index2))
           continue;
         const name = effectiveNameOf(usage);
@@ -168566,13 +169491,13 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       node,
       this.resolveType(node, index2) ?? this.effectiveEnumerationType(node) ?? (featureInheritanceTargets(node).length ? this.inheritedFeatureOwnersOf(node, index2).find(isDefinitionNode) : void 0)
     ]));
-    const defNodes = all.filter((n2) => isDefinitionNode(n2) && nameOf2(n2));
+    const defNodes = all.filter((n2) => isDefinitionNode(n2) && nameOf3(n2));
     const packageOverview = isPackage(ctx.anchor) || isDocument(ctx.anchor);
     const isDirectPackageInterfaceUsage = (n2) => isInterfaceDecl(n2) && n2.isDef !== true && this.isDirectPackageMember(n2);
-    const hasOwnedMemberNode = defNodes.length > 0 || usageNodes.length > 0 || annotationNodes.length > 0 || all.some((n2) => isPackage(n2) && !!nameOf2(n2) || isDirectPackageInterfaceUsage(n2));
+    const hasOwnedMemberNode = defNodes.length > 0 || usageNodes.length > 0 || annotationNodes.length > 0 || all.some((n2) => isPackage(n2) && !!nameOf3(n2) || isDirectPackageInterfaceUsage(n2));
     const packageNodes = [
-      ...packageOverview && hasOwnedMemberNode && isPackage(scope) && nameOf2(scope) ? [scope] : [],
-      ...all.filter((p) => isPackage(p) && nameOf2(p))
+      ...packageOverview && hasOwnedMemberNode && isPackage(scope) && nameOf3(scope) ? [scope] : [],
+      ...all.filter((p) => isPackage(p) && nameOf3(p))
     ];
     const semanticNodes = /* @__PURE__ */ new Set([...packageNodes, ...defNodes, ...usageNodes, ...annotationNodes]);
     const semanticOwners = /* @__PURE__ */ new Map();
@@ -168600,20 +169525,23 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     };
     const readsAsAttribute = (node) => isAttributeDecl(node) || isAttributeDecl(this.resolveType(node, index2));
     const implicitlyRedefined = (node) => {
-      const name = nameOf2(node);
+      const name = nameOf3(node);
       const owner = semanticOwner(node);
       if (!name || !owner || owner.isDef === true)
         return void 0;
       const definition = usageDefinitions.get(owner);
       if (!definition)
         return void 0;
-      return membersOf(definition).find((member) => nameOf2(member) === name);
+      return membersOf(definition).find((member) => nameOf3(member) === name);
     };
     const attributeUsages = new Set(usageNodes.filter((node) => {
       if (isDefinitionParameter(node))
         return false;
       if (isAttributeDecl(node))
         return true;
+      const effective = effectiveDeclTypeOf(node);
+      if (effective !== node.$type)
+        return effective === "AttributeDecl";
       const owner = semanticOwner(node);
       if (node.$type === "EnumValueDecl")
         return !!owner && !isEnumDecl(owner);
@@ -168657,7 +169585,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       let ownerId = current2 ? ids.get(current2) ?? "" : "";
       for (let i = lineage.length - 1; i >= 0; i--) {
         const { member, owner } = lineage[i];
-        let segment = effectiveNameOf(member) ?? nameOf2(member) ?? (member.$type === "MetadataAnnotation" ? member.declName : void 0);
+        let segment = effectiveNameOf(member) ?? nameOf3(member) ?? (member.$type === "MetadataAnnotation" ? member.declName : void 0);
         if (!segment && !isDocument(member)) {
           const counts = unnamedOrdinals.get(owner ?? member) ?? /* @__PURE__ */ new Map();
           unnamedOrdinals.set(owner ?? member, counts);
@@ -168686,13 +169614,13 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       emitted.add(n2);
       nodes.push({
         id: id2,
-        name: effectiveNameOf(n2) ?? nameOf2(n2),
+        name: effectiveNameOf(n2) ?? nameOf3(n2),
         keyword: keywordFor(n2),
         isDef,
         shape,
         abstract: isAbstract(n2) || void 0,
         multiplicity: this.multText(n2),
-        type: typeText(n2) ?? (usageDefinitions.get(n2) ? nameOf2(usageDefinitions.get(n2)) : void 0),
+        type: typeText(n2) ?? (usageDefinitions.get(n2) ? nameOf3(usageDefinitions.get(n2)) : void 0),
         ...attributeUsages.has(n2) ? { value: attributeValue(n2) } : {},
         // REQ-208/209 — the constraint or calculation expression field.
         ...showsExpressionField(n2) ? { value: expressionBody(n2) } : {},
@@ -168722,9 +169650,9 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       if (!definition || !isConstraintDecl(definition))
         continue;
       const usageId = semanticId(usage);
-      const local = new Set(membersOf(usage).flatMap((member) => [nameOf2(member), ...redefinitionTargetsOf(member)]).filter((name) => !!name));
+      const local = new Set(membersOf(usage).flatMap((member) => [nameOf3(member), ...redefinitionTargetsOf(member)]).filter((name) => !!name));
       for (const member of membersOf(definition)) {
-        const name = nameOf2(member);
+        const name = nameOf3(member);
         if (!name || local.has(name))
           continue;
         if (directionOf(member) === void 0 && !isAttributeDecl(member))
@@ -168754,7 +169682,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
             // REQ-364 — the concrete usage that owns a local edit, plus
             // the relative redefinition path to write inside it.
             localUsageId: usageId,
-            localUsageName: nameOf2(usage),
+            localUsageName: nameOf3(usage),
             localUsageSource: sourceOf2(usage, uri),
             localUsagePath: [name],
             expandedFromDefinition: true,
@@ -168772,7 +169700,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     }
     const byName = /* @__PURE__ */ new Map();
     for (const n2 of [...defNodes, ...usageNodes, ...packageNodes]) {
-      const name = effectiveNameOf(n2) ?? nameOf2(n2);
+      const name = effectiveNameOf(n2) ?? nameOf3(n2);
       if (name && !byName.has(name))
         byName.set(name, n2);
     }
@@ -168820,7 +169748,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         continue;
       const node = nodes.find((nd) => nd.id === ids.get(target));
       if (node)
-        node.meta = { ...node.meta, alias: nameOf2(a2) };
+        node.meta = { ...node.meta, alias: nameOf3(a2) };
     }
     const edges = [];
     let e = 0;
@@ -168843,6 +169771,22 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           });
         }
       }
+      for (const annotation of ctx.semantic?.edgesOf(d) ?? []) {
+        const base = annotation.base?.node;
+        if (!base || !annotation.edge || !ids.has(base))
+          continue;
+        const tag = metadataTypeNamesOf(annotation.usage)[0];
+        const subsets = annotation.edge.metaclass === "Subsetting" ? "{subsets}" : void 0;
+        edges.push({
+          id: `e${e++}`,
+          from: ids.get(d),
+          to: ids.get(base),
+          kind: annotation.edge.metaclass === "FeatureTyping" ? "definedBy" : "specialization",
+          label: [subsets, tag ? `\xAB${tag}\xBB` : void 0].filter(Boolean).join(" ") || void 0,
+          meta: { impliedBySemanticMetadata: true, ...tag ? { semanticKeyword: tag } : {} },
+          source: sourceOf2(d, uri)
+        });
+      }
     }
     for (const definition of defNodes.filter(isConnectionDecl)) {
       const definitionId = ids.get(definition);
@@ -168869,9 +169813,9 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       }
       const common = {
         kind: "connect",
-        name: nameOf2(definition),
+        name: nameOf3(definition),
         isDef: true,
-        label: `\xABconnection def\xBB ${nameOf2(definition) ?? ""}`.trim(),
+        label: `\xABconnection def\xBB ${nameOf3(definition) ?? ""}`.trim(),
         source: sourceOf2(definition, uri),
         meta: { connectionDefinitionGraphical: true, connectionDefinitionId: definitionId },
         ...hasElaboration ? { elaboration: definitionId } : {}
@@ -168893,7 +169837,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         const hubId = `${definitionId}::__connection__`;
         nodes.push({
           id: hubId,
-          name: nameOf2(definition) ?? "",
+          name: nameOf3(definition) ?? "",
           keyword: "connection def",
           isDef: true,
           shape: "dot",
@@ -168996,7 +169940,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         from,
         to,
         kind: "reference",
-        name: nameOf2(binding.ref),
+        name: nameOf3(binding.ref),
         type: typeText(binding.target),
         source: sourceOf2(binding.ref, uri)
       });
@@ -169106,7 +170050,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const dn = dep;
       const clients = (dn.clients ?? []).map((c) => resolveDrawnByText(String(c ?? ""))).filter((n2) => !!n2 && ids.has(n2));
       const suppliers = (dn.suppliers ?? []).map((s) => resolveDrawnByText(String(s ?? ""))).filter((n2) => !!n2 && ids.has(n2));
-      const label = nameOf2(dep) ? `\xABdependency\xBB ${nameOf2(dep)}` : "\xABdependency\xBB";
+      const label = nameOf3(dep) ? `\xABdependency\xBB ${nameOf3(dep)}` : "\xABdependency\xBB";
       const isNary = (dn.clients?.length ?? 0) > 1 || (dn.suppliers?.length ?? 0) > 1;
       if (!isNary) {
         const from = clients[0];
@@ -169121,7 +170065,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const hubId = `dependency-hub-${dep.$cstNode?.offset ?? nodes.length}`;
       nodes.push({
         id: hubId,
-        name: nameOf2(dep) ?? "",
+        name: nameOf3(dep) ?? "",
         keyword: "dependency",
         isDef: false,
         shape: "dot",
@@ -169184,7 +170128,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         const dotId = `__derivation_${derivationCount++}__`;
         nodes.push({
           id: dotId,
-          name: nameOf2(c) ?? "derivation",
+          name: nameOf3(c) ?? "derivation",
           keyword: "derivation",
           isDef: false,
           shape: "dot",
@@ -169248,19 +170192,19 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       if (m.$type === "CommentStmt") {
         const rawTargets = m.targets ?? [];
         const targets = rawTargets.length ? this.commentTargets(m, index2).map(drawnAnnotationTarget).filter((target) => target !== void 0) : void 0;
-        annotate(m, "comment", nameOf2(m) ?? "comment", annotationText(trailingBlockBody(m)), targets);
+        annotate(m, "comment", nameOf3(m) ?? "comment", annotationText(trailingBlockBody(m)), targets);
       } else if (m.$type === "RepStmt") {
         const lang = `language "${String(m.language ?? "")}"`;
         const body = annotationText(trailingBlockBody(m));
-        annotate(m, "rep", nameOf2(m) ?? "rep", body ? `${lang} - ${body}` : lang, void 0);
+        annotate(m, "rep", nameOf3(m) ?? "rep", body ? `${lang} - ${body}` : lang, void 0);
       } else if (m.$type === "DocCommentMember") {
         const owner = semanticOwner(m);
         const body = annotationText(docCommentBody(m));
-        annotate(m, "doc", nameOf2(m) ?? "doc", body, owner ? [owner] : void 0);
+        annotate(m, "doc", nameOf3(m) ?? "doc", body, owner ? [owner] : void 0);
       } else if ((isMetadataDecl(m) || m.$type === "MetadataAnnotation") && m.isDef !== true && annotationNodeSet.has(m) && !emitted.has(m)) {
         const attrs = metadataAttrsText(m);
         const detail = typeText(m) ? `${typeText(m)}${attrs ? ` { ${attrs} }` : ""}` : attrs;
-        const declaredName3 = nameOf2(m) ?? m.declName;
+        const declaredName3 = nameOf3(m) ?? m.declName;
         annotate(m, "metadata", declaredName3 ?? lastSeg(typeText(m) ?? "metadata"), detail, void 0);
       }
     }
@@ -169282,7 +170226,7 @@ ${edge.to}`));
       node.meta = {
         ...node.meta,
         gvExplicit: true,
-        gvDeclaredName: nameOf2(original) ?? (original.$type === "MetadataAnnotation" ? original.declName : void 0),
+        gvDeclaredName: nameOf3(original) ?? (original.$type === "MetadataAnnotation" ? original.declName : void 0),
         gvMetadataAnnotation: original.$type === "MetadataAnnotation" || void 0,
         ...original.$type === "DocCommentMember" ? { gvDocumentation: docCommentBody(original) ?? "" } : {},
         gvOwnerId: ownerId,
@@ -169765,7 +170709,7 @@ ${node.id}`;
         const resolved = this.featurePaths.resolveDeclarationPath(member);
         const localPath = reference.path === reference.simpleName || reference.path.replaceAll("::", ".") === `self.${reference.simpleName}`;
         const effective = interconnection && localPath ? members.find((candidate) => (isConstraintDecl(candidate) || isInlineConstraintClaim(candidate)) && [effectiveNameOf(candidate), ...redefinitionTargetsOf(candidate).map(lastSeg)].includes(reference.simpleName)) : void 0;
-        const found = effective ?? resolved.segments.at(-1)?.target ?? membersOf(owner).find((candidate) => candidate !== member && nameOf2(candidate) === reference.path) ?? index2.get(reference.path) ?? index2.get(reference.simpleName);
+        const found = effective ?? resolved.segments.at(-1)?.target ?? membersOf(owner).find((candidate) => candidate !== member && nameOf3(candidate) === reference.path) ?? index2.get(reference.path) ?? index2.get(reference.simpleName);
         if (!found || found === member)
           continue;
         target = found;
@@ -169839,8 +170783,8 @@ ${node.id}`;
       if (existing)
         return existing;
       const parent = ensurePkgFrame(enclosingPackage(pkg));
-      const id2 = qnameOf(pkg) || nameOf2(pkg) || `__pkg_${frames.length}__`;
-      frames.push({ id: id2, label: nameOf2(pkg) ?? lastSeg(id2), keyword: "package", parent, source: sourceOf2(pkg, uri) });
+      const id2 = qnameOf(pkg) || nameOf3(pkg) || `__pkg_${frames.length}__`;
+      frames.push({ id: id2, label: nameOf3(pkg) ?? lastSeg(id2), keyword: "package", parent, source: sourceOf2(pkg, uri) });
       pkgFrame.set(pkg, id2);
       return id2;
     };
@@ -169857,8 +170801,8 @@ ${node.id}`;
           const constraint = isConstraintDecl(member) || isInlineConstraintClaim(member);
           if (namedRelationship || constraint) {
             const names = [
-              nameOf2(member),
-              redefinedNameOf(member),
+              nameOf3(member),
+              redefinedNameOf2(member),
               ...constraint ? redefinitionTargetsOf(member).map(lastSeg) : []
             ].filter((name) => name !== void 0);
             if (names.some((name) => claimedNames.has(name)))
@@ -169962,8 +170906,8 @@ ${node.id}`;
         pendingDefinitions.push(typeDef);
       }
       const typeQ = typeDef ? qnameOf(typeDef) : void 0;
-      const declarationId = nameOf2(part) ? qnameOf(part) || instanceId : instanceId;
-      const projected = nameOf2(part) === void 0 || declarationId !== instanceId;
+      const declarationId = nameOf3(part) ? qnameOf(part) || instanceId : instanceId;
+      const projected = nameOf3(part) === void 0 || declarationId !== instanceId;
       const localUsage = part.isDef !== true && !projected ? part : inheritedLocalUsage;
       const localPath = part.isDef !== true && !projected ? [] : inheritedLocalPath;
       const projectedPorts = this.portsOf(part, index2, uri, instanceId, localUsage);
@@ -169984,7 +170928,7 @@ ${node.id}`;
       const children2 = depth < 8 && !(typeQ !== void 0 && seenTypes.has(typeQ)) ? childUsagesOf(part) : [];
       const concretePerformPath = (statement, target2) => {
         if (!this.isAnonymousBehaviorReference(statement)) {
-          return qnameOf(statement) || nameOf2(statement) || "perform";
+          return qnameOf(statement) || nameOf3(statement) || "perform";
         }
         const segments = this.featurePaths.resolveDeclarationPath(statement).segments;
         const featureStart = segments.findIndex((segment, at) => at > 0 && segment.separator === ".");
@@ -169997,7 +170941,7 @@ ${node.id}`;
           const rootSegments = segments.slice(0, featureStart).map((segment) => segment.text);
           const rootName = rootSegments.at(-1);
           const wanted = rootSegments.join("::");
-          const declaresRoot = (candidate) => candidate !== statement && !this.referencesBehavior(candidate) && nameOf2(candidate) === rootName;
+          const declaresRoot = (candidate) => candidate !== statement && !this.referencesBehavior(candidate) && nameOf3(candidate) === rootName;
           let root4;
           for (let owner = statement.$container; owner && !root4; owner = owner.$container) {
             const local = membersOf(owner).find(declaresRoot);
@@ -170009,16 +170953,16 @@ ${node.id}`;
             return [qnameOf(root4), ...segments.slice(featureStart).map((segment) => segment.text)].join("::");
           }
         }
-        return qnameOf(target2) || nameOf2(target2) || segments.map((segment) => segment.text).join("::");
+        return qnameOf(target2) || nameOf3(target2) || segments.map((segment) => segment.text).join("::");
       };
-      const performedActions = depth < 8 && !(typeQ !== void 0 && seenTypes.has(typeQ)) ? effectiveMembersOf(part).filter((m) => m.$type === "PerformStmt" && !!nameOf2(m)).map((act) => {
+      const performedActions = depth < 8 && !(typeQ !== void 0 && seenTypes.has(typeQ)) ? effectiveMembersOf(part).filter((m) => m.$type === "PerformStmt" && !!nameOf3(m)).map((act) => {
         const pinSource = this.performTargetOf(act, index2) ?? act;
-        const pathSegments4 = this.isAnonymousBehaviorReference(act) ? this.featurePaths.resolveDeclarationPath(act).segments.map((segment) => segment.text) : [nameOf2(act)];
+        const pathSegments4 = this.isAnonymousBehaviorReference(act) ? this.featurePaths.resolveDeclarationPath(act).segments.map((segment) => segment.text) : [nameOf3(act)];
         return {
           act,
           pinSource,
           pathSegments: pathSegments4,
-          name: pathSegments4.at(-1) ?? nameOf2(act),
+          name: pathSegments4.at(-1) ?? nameOf3(act),
           key: concretePerformPath(act, pinSource)
         };
       }).filter((entry, i, list) => list.findIndex((other) => other.key === entry.key) === i) : [];
@@ -170115,7 +171059,7 @@ ${node.id}`;
         claimFrame.compartments = withoutCompartments(claimFrame.compartments, "assert constraints", "assume constraints", "require constraints");
     };
     const packageOfRoot = (root4) => enclosingPackage(root4) ?? scope;
-    const rootBaseId = (root4) => qnameOf(root4) || nameOf2(root4) || `__root_${root4.$cstNode?.offset ?? 0}__`;
+    const rootBaseId = (root4) => qnameOf(root4) || nameOf3(root4) || `__root_${root4.$cstNode?.offset ?? 0}__`;
     const rootsByBaseId = /* @__PURE__ */ new Map();
     for (const root4 of roots) {
       const base = rootBaseId(root4);
@@ -170153,7 +171097,7 @@ ${node.id}`;
         continue;
       if (!ownedByDiagramRoot(definition, diagramRoot))
         continue;
-      const definitionId = qnameOf(definition) || nameOf2(definition);
+      const definitionId = qnameOf(definition) || nameOf3(definition);
       if (!definitionId)
         continue;
       renderedDefinitions.add(definition);
@@ -170179,7 +171123,7 @@ ${node.id}`;
   // rendered by the SAME recursive renderer as the package overview.
   buildInterconnectionView(ctx) {
     const anchor = ctx.anchor;
-    const anchorId = qnameOf(anchor) || nameOf2(anchor) || "__anchor__";
+    const anchorId = qnameOf(anchor) || nameOf3(anchor) || "__anchor__";
     const { nodes, edges, frames, definitionLayer } = this.renderIvRoots(ctx, [anchor], { packageFrames: false });
     if (anchor.isDef === true && frames.length === 0 && nodes.every((n2) => !n2.ports?.length && !n2.compartments?.length)) {
       return this.model("iv", anchor, [], []);
@@ -170216,14 +171160,14 @@ ${node.id}`;
       const candidates = nodes.filter((node) => node.meta?.constraintUsage === true && (!frameId || node.id.startsWith(`${frameId}::`) || edges.some((edge) => edge.from === frameId && edge.to === node.id))).flatMap((node) => (node.ports ?? []).filter((pin) => `${node.name}.${pin.name}` === path10 || pin.id.replaceAll("::", ".") === path10));
       if (candidates.length === 1)
         return candidates[0].id;
-      const attribute = memberList2.find((member) => isAttributeDecl(member) && nameOf2(member) === path10);
+      const attribute = memberList2.find((member) => isAttributeDecl(member) && nameOf3(member) === path10);
       if (!attribute || !frameId)
         return void 0;
-      const id2 = `${frameId}::${nameOf2(attribute)}`;
+      const id2 = `${frameId}::${nameOf3(attribute)}`;
       if (!nodes.some((node) => node.id === id2))
         nodes.push({
           id: id2,
-          name: nameOf2(attribute),
+          name: nameOf3(attribute),
           keyword: "attribute",
           isDef: false,
           shape: "box",
@@ -170339,7 +171283,7 @@ ${node.id}`;
     for (const m of memberList2) {
       if (isConnectorDecl(m)) {
         const cn = m;
-        const name = nameOf2(m);
+        const name = nameOf3(m);
         const type = typeText(m);
         const label = name ?? type;
         const clauseEnds = (cn.ends ?? []).map((clause) => clause.end).filter(Boolean);
@@ -170417,7 +171361,7 @@ ${node.id}`;
       } else if (isInterfaceDecl(m) && m.isDef !== true) {
         const interfaceUsage = m;
         if (interfaceUsage.target !== void 0 && interfaceUsage.connect === void 0) {
-          const sourcePath = shorthandSourcePath(m) ?? [nameOf2(m) ?? "", ...interfaceUsage.srcSegs ?? []].filter(Boolean).join(".");
+          const sourcePath = shorthandSourcePath(m) ?? [nameOf3(m) ?? "", ...interfaceUsage.srcSegs ?? []].filter(Boolean).join(".");
           const targetPath = this.featurePath(interfaceUsage.target) ?? "";
           const from = resolveEnd(sourcePath);
           const to = resolveEnd(targetPath);
@@ -170707,8 +171651,8 @@ ${node.id}`;
     const { index: index2 } = ctx;
     const scope = ctx.anchor;
     const all = [...ast_utils_exports.streamAllContents(scope)];
-    const isUsagePart = (n2) => isPartDecl(n2) && n2.isDef !== true && nameOf2(n2) !== void 0;
-    const isDefPart = (n2) => isPartDecl(n2) && n2.isDef === true && nameOf2(n2) !== void 0;
+    const isUsagePart = (n2) => isPartDecl(n2) && n2.isDef !== true && nameOf3(n2) !== void 0;
+    const isDefPart = (n2) => isPartDecl(n2) && n2.isDef === true && nameOf3(n2) !== void 0;
     const hasInternalParts = (d) => [d, ...this.inheritedFeatureOwnersOf(d, index2)].some((source) => this.nestedUsages(source, isPartDecl).length > 0);
     const insideAPart = (n2) => {
       let c = n2.$container;
@@ -170734,7 +171678,7 @@ ${node.id}`;
       if (def && isDefPart(def))
         usedDefs.add(def);
     }
-    const byName = (a2, b) => (qnameOf(a2) || nameOf2(a2) || "").localeCompare(qnameOf(b) || nameOf2(b) || "");
+    const byName = (a2, b) => (qnameOf(a2) || nameOf3(a2) || "").localeCompare(qnameOf(b) || nameOf3(b) || "");
     const rootDefs = all.filter((d) => isDefPart(d) && !usedDefs.has(d) && !insideAPart(d) && !insideAnOccurrence(d) && hasInternalParts(d));
     const rootUsages = all.filter((u) => isUsagePart(u) && !insideAPart(u) && !insideAnOccurrence(u));
     let roots = [...rootDefs, ...rootUsages].sort(byName);
@@ -170747,7 +171691,7 @@ ${node.id}`;
     if (definitionLayer)
       model.layers = { definitions: definitionLayer };
     model.meta = { ...model.meta, overview: true, groupMode: "nested" };
-    model.root = { ...model.root, keyword: "package", name: nameOf2(scope) ?? model.root.name };
+    model.root = { ...model.root, keyword: "package", name: nameOf3(scope) ?? model.root.name };
     if (nodes.length === 0 && frames.length === 0) {
       model.notes = ["No internal parts to interconnect in this package."];
     }
@@ -170766,7 +171710,7 @@ ${node.id}`;
       }
       return false;
     });
-    const scaffolds = kind === "stv" ? all.filter((n2) => (isStateDecl(n2) || isExhibitStateDecl(n2)) && !!nameOf2(n2) && // A REFERENCING `exhibit s;` is a claim on a state declared
+    const scaffolds = kind === "stv" ? all.filter((n2) => (isStateDecl(n2) || isExhibitStateDecl(n2)) && !!nameOf3(n2) && // A REFERENCING `exhibit s;` is a claim on a state declared
     // elsewhere (OMG p.116 shorthand), drawn as that state's «exhibit»
     // arrow — never a machine of its own (report 2026-08-03).
     !this.referencesBehavior(n2) && !naturalAnchors.includes(n2) && !hasNaturalDescendant(n2) && // A nested state is a member of the machine that already tiles.
@@ -170796,13 +171740,13 @@ ${node.id}`;
   // package-anchored single-view behaviour), not only nested container parts.
   hasOverviewContent(scope, kind, index2) {
     if (kind === "iv") {
-      return [...ast_utils_exports.streamAllContents(scope)].some((n2) => isPartDecl(n2) && n2.isDef !== true && nameOf2(n2) !== void 0);
+      return [...ast_utils_exports.streamAllContents(scope)].some((n2) => isPartDecl(n2) && n2.isDef !== true && nameOf3(n2) !== void 0);
     }
     if (this.collectOverviewAnchors(scope, kind, index2).length > 0)
       return true;
     if (kind === "gev")
       return this.hasGeometryObject(scope, index2);
-    return kind === "sv" && this.nestedUsages(scope, isPartDecl).some((n2) => nameOf2(n2) !== void 0);
+    return kind === "sv" && this.nestedUsages(scope, isPartDecl).some((n2) => nameOf3(n2) !== void 0);
   }
   // REQ-202 — only a real message/send interaction becomes a package tile;
   // nested part composition alone is not a sequence.
@@ -170816,8 +171760,8 @@ ${node.id}`;
   // webview can lay each tile out with its own view layout.
   buildTiledOverview(ctx, kind, groupMode, buildOne, emptyNote) {
     const scopeQ = qnameOf(ctx.anchor);
-    const collected = this.collectOverviewAnchors(ctx.anchor, kind, ctx.index).sort((a2, b) => (qnameOf(a2) || nameOf2(a2) || "").localeCompare(qnameOf(b) || nameOf2(b) || ""));
-    const sequenceScaffold = kind === "sv" && this.nestedUsages(ctx.anchor, isPartDecl).some((n2) => nameOf2(n2) !== void 0);
+    const collected = this.collectOverviewAnchors(ctx.anchor, kind, ctx.index).sort((a2, b) => (qnameOf(a2) || nameOf3(a2) || "").localeCompare(qnameOf(b) || nameOf3(b) || ""));
+    const sequenceScaffold = kind === "sv" && this.nestedUsages(ctx.anchor, isPartDecl).some((n2) => nameOf3(n2) !== void 0);
     const useScopeFallback = kind === "gev" ? this.hasPlacedGeometryObject(ctx.anchor, ctx.index) : sequenceScaffold;
     const anchors = collected.length > 0 ? collected : useScopeFallback ? [ctx.anchor] : [];
     const nodes = [];
@@ -170836,12 +171780,12 @@ ${node.id}`;
       if (this.diagramElementCount(subModel) === 0 && !(kind === "afv" && (isActionDecl(sub) || isCalcDecl(sub))) && !(kind === "stv" && (isStateDecl(sub) || isExhibitStateDecl(sub))))
         continue;
       const frameId = `t${tile}`;
-      const q = qnameOf(sub) || nameOf2(sub) || "";
-      const rel2 = scopeQ && q.startsWith(`${scopeQ}::`) ? q.slice(scopeQ.length + 2) : nameOf2(sub) ?? q;
+      const q = qnameOf(sub) || nameOf3(sub) || "";
+      const rel2 = scopeQ && q.startsWith(`${scopeQ}::`) ? q.slice(scopeQ.length + 2) : nameOf3(sub) ?? q;
       const tileMetaTag = kind === "afv" ? isPartDecl(sub) ? { afvPart: true } : (isActionDecl(sub) || isCalcDecl(sub)) && sub.isDef === true ? { behaviorDef: true } : void 0 : kind === "stv" && sub.isDef === true ? { behaviorDef: true } : void 0;
       const tileIdentity = {
-        declarationId: qnameOf(sub) || nameOf2(sub),
-        declarationName: nameOf2(sub),
+        declarationId: qnameOf(sub) || nameOf3(sub),
+        declarationName: nameOf3(sub),
         declarationSource: sourceOf2(sub, ctx.uri)
       };
       const anchorFrame = subModel.frames?.find((f) => f.meta?.anchorFrame === true);
@@ -170849,7 +171793,7 @@ ${node.id}`;
       frames.push({
         id: frameId,
         layoutKey: q || void 0,
-        label: rel2 || (nameOf2(sub) ?? "view"),
+        label: rel2 || (nameOf3(sub) ?? "view"),
         keyword: keywordFor(sub),
         // If a single-view builder wrapped its anchor in a semantic
         // boundary (for example STV `exhibit`), absorption replaces the
@@ -170881,7 +171825,7 @@ ${node.id}`;
     const model = this.model(kind, ctx.anchor, nodes, edges);
     model.frames = frames;
     model.meta = { overview: true, groupMode, tileMeta };
-    model.root = { ...model.root, keyword: "package", name: nameOf2(ctx.anchor) ?? model.root.name };
+    model.root = { ...model.root, keyword: "package", name: nameOf3(ctx.anchor) ?? model.root.name };
     if (frames.length === 0)
       model.notes = [emptyNote];
     return model;
@@ -171061,22 +172005,22 @@ ${node.id}`;
     let anon = 0;
     const anchorHostsFlow = isActionDecl(anchor) || isCalcDecl(anchor) || this.isCaseLike(anchor);
     const exprTextOf = (v) => (v?.$cstNode?.text ?? (typeof v === "string" ? v : "")).replace(/\s+/g, " ").trim();
-    const performPathOf = (m) => [nameOf2(m), ...m.chainSegs ?? []].filter((segment) => !!segment);
+    const performPathOf = (m) => [nameOf3(m), ...m.chainSegs ?? []].filter((segment) => !!segment);
     const performLabel = (m) => performPathOf(m).at(-1) ?? typeText(m) ?? "perform";
-    const localFlowName = (m) => m.$type === "PerformStmt" && this.isAnonymousBehaviorReference(m) ? void 0 : nameOf2(m);
+    const localFlowName = (m) => m.$type === "PerformStmt" && this.isAnonymousBehaviorReference(m) ? void 0 : nameOf3(m);
     const isPromotablePerform = (m) => m.$type === "PerformStmt" && this.isAnonymousBehaviorReference(m) && isActionDecl(this.declaringOwnerOf(m));
     const flowNodeInfo = (m) => {
       const mm = m;
       switch (m.$type) {
         // REQ-208 - Calculations share action occurrence docking.
         case "CalcDecl":
-          return { shape: "action", label: nameOf2(m) ?? "calc" };
+          return { shape: "action", label: nameOf3(m) ?? "calc" };
         case "ActionDecl": {
-          if (!nameOf2(m))
+          if (!nameOf3(m))
             return void 0;
           const inlineAccept = mm.inlineBody;
           if (inlineAccept?.$type === "AcceptNode") {
-            return { shape: "accept", label: nameOf2(m) };
+            return { shape: "accept", label: nameOf3(m) };
           }
           if (inlineAccept?.$type === "AssignNode") {
             const assign2 = inlineAccept;
@@ -171087,12 +172031,12 @@ ${node.id}`;
             };
           }
           if (inlineAccept?.$type === "TerminateNode") {
-            return { shape: "action", label: nameOf2(m) };
+            return { shape: "action", label: nameOf3(m) };
           }
           if (mm.sendKw === true) {
-            return { shape: "send", label: nameOf2(m) };
+            return { shape: "send", label: nameOf3(m) };
           }
-          return { shape: "action", label: nameOf2(m) };
+          return { shape: "action", label: nameOf3(m) };
         }
         // REQ-196 — a `perform` names the action it performs, which for a
         // feature chain (`perform action0.action1;`) is the LAST segment:
@@ -171101,13 +172045,13 @@ ${node.id}`;
         case "PerformStmt":
           return { shape: "action", label: performLabel(m) };
         case "MergeNode":
-          return { shape: "merge", label: nameOf2(m) ?? "" };
+          return { shape: "merge", label: nameOf3(m) ?? "" };
         case "DecideNode":
-          return { shape: "decision", label: nameOf2(m) ?? "" };
+          return { shape: "decision", label: nameOf3(m) ?? "" };
         case "JoinNode":
-          return { shape: "join", label: nameOf2(m) ?? "" };
+          return { shape: "join", label: nameOf3(m) ?? "" };
         case "ForkNode":
-          return { shape: "fork", label: nameOf2(m) ?? "" };
+          return { shape: "fork", label: nameOf3(m) ?? "" };
         case "TerminateNode":
           return {
             shape: "terminate",
@@ -171156,7 +172100,7 @@ ${node.id}`;
     const isLoopNode = (m) => m.$type === "WhileLoopNode" || m.$type === "LoopNode" || m.$type === "ForLoopNode";
     const isStructuredIf = (m) => m.$type === "IfActionNode" && !m.thenTarget;
     const inlineStructuredNodeOf = (m) => {
-      if (m.$type !== "ActionDecl" || !nameOf2(m))
+      if (m.$type !== "ActionDecl" || !nameOf3(m))
         return void 0;
       const inline = m.inlineBody;
       return inline && (isLoopNode(inline) || isStructuredIf(inline)) ? inline : void 0;
@@ -171183,8 +172127,8 @@ ${node.id}`;
         if (isFlowMember(node))
           out.push(node);
         const memberInline = node.inlineBody;
-        const foldedAcceptTrigger = node.$type === "ActionDecl" && !!nameOf2(node) && memberInline?.$type === "AcceptNode";
-        const foldedAssignment = node.$type === "ActionDecl" && !!nameOf2(node) && memberInline?.$type === "AssignNode";
+        const foldedAcceptTrigger = node.$type === "ActionDecl" && !!nameOf3(node) && memberInline?.$type === "AcceptNode";
+        const foldedAssignment = node.$type === "ActionDecl" && !!nameOf3(node) && memberInline?.$type === "AssignNode";
         const foldedStructuredAction = inlineStructuredNodeOf(node) === memberInline;
         if (memberInline && flowNodeInfo(memberInline) && !foldedAcceptTrigger && !foldedAssignment && !foldedStructuredAction)
           out.push(memberInline);
@@ -171225,7 +172169,7 @@ ${node.id}`;
       if (!rootName)
         return void 0;
       const wanted = rootSegments.join("::");
-      const declares = (candidate) => candidate !== statement && !this.referencesBehavior(candidate) && nameOf2(candidate) === rootName;
+      const declares = (candidate) => candidate !== statement && !this.referencesBehavior(candidate) && nameOf3(candidate) === rootName;
       for (let owner = statement.$container; owner; owner = owner.$container) {
         const local = membersOf(owner).find(declares);
         if (local && (rootSegments.length === 1 || qnameOf(local).endsWith(wanted)))
@@ -171247,7 +172191,7 @@ ${node.id}`;
           return [rootName, ...segments.slice(featureStart).map((segment) => segment.text)].join("::");
         }
       }
-      return qnameOf(target) || nameOf2(target) || segments.map((segment) => segment.text).join("::");
+      return qnameOf(target) || nameOf3(target) || segments.map((segment) => segment.text).join("::");
     };
     const performerOf = /* @__PURE__ */ new Map();
     const performerClaimsOf = /* @__PURE__ */ new Map();
@@ -171269,7 +172213,7 @@ ${node.id}`;
       if (!performers.includes(part))
         performers.push(part);
       performerOf.set(occurrence, performers);
-      const partId = qnameOf(part) || nameOf2(part) || "?";
+      const partId = qnameOf(part) || nameOf3(part) || "?";
       const byPart = performerClaimsOf.get(occurrence) ?? /* @__PURE__ */ new Map();
       const sources = byPart.get(partId) ?? [];
       const claimSource = sourceOf2(stmt, uri);
@@ -171341,7 +172285,7 @@ ${node.id}`;
       return [...byName.values()];
     };
     const registerPins = (owner, ownerId, pins, includeBare) => {
-      const ownerNames = new Set([nameOf2(owner), qnameOf(owner), ownerId].filter((value) => !!value));
+      const ownerNames = new Set([nameOf3(owner), qnameOf(owner), ownerId].filter((value) => !!value));
       const occurrenceSegments = normalizePinPath(ownerId).split(".").filter(Boolean);
       for (let start2 = 0; start2 < occurrenceSegments.length; start2++) {
         ownerNames.add(occurrenceSegments.slice(start2).join("."));
@@ -171364,20 +172308,20 @@ ${node.id}`;
     const scopeQName = qnameOf(this.packageScopeOf(anchor));
     const relativeName = (node) => {
       const q = qnameOf(node);
-      return scopeQName && q.startsWith(`${scopeQName}::`) ? q.slice(scopeQName.length + 2) : q || nameOf2(node) || "?";
+      return scopeQName && q.startsWith(`${scopeQName}::`) ? q.slice(scopeQName.length + 2) : q || nameOf3(node) || "?";
     };
     const referencePath = (node) => {
       const scope = this.packageScopeOf(anchor);
       const chain = [];
       for (let current2 = node; current2 && current2 !== scope && !isDocument(current2); current2 = current2.$container) {
-        if (nameOf2(current2))
+        if (nameOf3(current2))
           chain.unshift(current2);
       }
       if (chain.length === 0)
         return relativeName(node);
-      let text = nameOf2(chain[0]);
+      let text = nameOf3(chain[0]);
       for (let index3 = 1; index3 < chain.length; index3 += 1) {
-        text += memberSeparator(chain[index3 - 1]) + nameOf2(chain[index3]);
+        text += memberSeparator(chain[index3 - 1]) + nameOf3(chain[index3]);
       }
       return text;
     };
@@ -171389,8 +172333,8 @@ ${node.id}`;
         return {};
       return {
         performPath: edit.performPath,
-        localUsageId: qnameOf(edit.root) || nameOf2(edit.root),
-        localUsageName: nameOf2(edit.root),
+        localUsageId: qnameOf(edit.root) || nameOf3(edit.root),
+        localUsageName: nameOf3(edit.root),
         localUsageSource: sourceOf2(edit.root, uri),
         localUsagePath: edit.memberPath
       };
@@ -171493,7 +172437,7 @@ ${node.id}`;
       const frameCompartments = isActionDecl(holder) || isCalcDecl(holder) ? actionFeatureCompartments(holder) : withoutCompartments(this.compartmentsFor(holder, uri, index2), ...graphicalAfvTitles);
       frames.push({
         id: frameId,
-        label: nameOf2(holder) ?? lastSeg(frameId),
+        label: nameOf3(holder) ?? lastSeg(frameId),
         keyword: keywordFor(holder),
         parent: parentFrame,
         isDef: holder.isDef === true,
@@ -171514,7 +172458,7 @@ ${node.id}`;
       for (const m of flowMembersOf(holder))
         emitChild(m, frameId, executionContext, holderOccurrence);
       for (const cp of childParts) {
-        const childId = qnameOf(cp) || `${frameId}::${nameOf2(cp) ?? "?"}`;
+        const childId = qnameOf(cp) || `${frameId}::${nameOf3(cp) ?? "?"}`;
         renderContainer(cp, childId, frameId, depth + 1, next, false, executionContext, childId);
       }
     };
@@ -171580,7 +172524,7 @@ ${node.id}`;
         return;
       }
       const banner = loopBanner(loop);
-      const wrapperName = wrapper ? nameOf2(wrapper) : void 0;
+      const wrapperName = wrapper ? nameOf3(wrapper) : void 0;
       const loopId = occurrence;
       const body = loop.body;
       const pins = structuredPinsOf(wrapper, [body], loopId);
@@ -171638,7 +172582,7 @@ ${node.id}`;
         openFrames.delete(loop);
       }
       idByNode.set(loop, loopId);
-      registerStep(occurrence, loopId, [nameOf2(loop)]);
+      registerStep(occurrence, loopId, [nameOf3(loop)]);
       if (wrapper) {
         idByNode.set(wrapper, loopId);
         registerStep(occurrence, loopId, [wrapperName]);
@@ -171676,8 +172620,8 @@ ${node.id}`;
       registerStep(occurrence, id2, [declaredName3]);
       if (content !== action) {
         idByNode.set(content, id2);
-        if (isPartDecl(this.declaringOwnerOf(action)) && nameOf2(content)) {
-          addStepAlias(nameOf2(content), id2);
+        if (isPartDecl(this.declaringOwnerOf(action)) && nameOf3(content)) {
+          addStepAlias(nameOf3(content), id2);
         }
       }
       frameOfNode.set(action, id2);
@@ -171707,7 +172651,7 @@ ${node.id}`;
             declarationSource: sourceOf2(action, uri)
           } : {},
           // REQ-196 — the body a lane added here writes its `perform` against.
-          actionQName: qnameOf(content) || nameOf2(content),
+          actionQName: qnameOf(content) || nameOf3(content),
           ...occurrenceEditMeta(occurrence)
         }
       });
@@ -171724,8 +172668,8 @@ ${node.id}`;
         return;
       }
       const inf = node;
-      const declaredNode = wrapper ?? (nameOf2(node) ? node : void 0);
-      const wrapperName = declaredNode ? nameOf2(declaredNode) : void 0;
+      const declaredNode = wrapper ?? (nameOf3(node) ? node : void 0);
+      const wrapperName = declaredNode ? nameOf3(declaredNode) : void 0;
       const frameId = occurrence;
       const blocks = [inf.thenBody, inf.elseBody, inf.elseIf];
       const pins = structuredPinsOf(declaredNode, blocks, frameId);
@@ -171769,7 +172713,7 @@ ${node.id}`;
       recordLaneCandidate(frameId, true, parentFrameId, laneParts, occurrence);
       frameOfNode.set(node, frameId);
       idByNode.set(node, frameId);
-      registerStep(occurrence, frameId, [nameOf2(node)]);
+      registerStep(occurrence, frameId, [nameOf3(node)]);
       if (wrapper) {
         frameOfNode.set(wrapper, frameId);
         idByNode.set(wrapper, frameId);
@@ -171809,7 +172753,7 @@ ${node.id}`;
       }
       openFrames.delete(node);
     };
-    const anchorId = qnameOf(anchor) || nameOf2(anchor) || "__anchor__";
+    const anchorId = qnameOf(anchor) || nameOf3(anchor) || "__anchor__";
     renderContainer(anchor, anchorId, void 0, 0, /* @__PURE__ */ new Set(), true, void 0);
     const flowFrameFor = (context, occurrenceContext) => {
       if (occurrenceContext) {
@@ -172004,7 +172948,7 @@ ${node.id}`;
       }
     }
     const readActions = /* @__PURE__ */ new Set();
-    const bodyReadKey = (body, occurrence) => `${qnameOf(body) || nameOf2(body) || body.$type}\0${normalizeOccurrencePath(occurrence)}`;
+    const bodyReadKey = (body, occurrence) => `${qnameOf(body) || nameOf3(body) || body.$type}\0${normalizeOccurrencePath(occurrence)}`;
     const readDefinitionBody = (holder, holderOccurrence) => {
       if (holder.isDef === true)
         return;
@@ -172096,7 +173040,7 @@ ${node.id}`;
               from,
               to,
               kind,
-              label: this.flowPayloadText(fm) ?? typeText(m) ?? transferredFeature ?? nameOf2(m),
+              label: this.flowPayloadText(fm) ?? typeText(m) ?? transferredFeature ?? nameOf3(m),
               source: sourceOf2(m, uri)
             });
             registerDrawn(m);
@@ -172155,7 +173099,7 @@ ${node.id}`;
     if (anchorHostsFlow && anchorParts?.length) {
       recordLaneCandidate(anchorId, true, void 0, anchorParts, anchorId);
     }
-    const identity6 = (part) => qnameOf(part) || nameOf2(part) || "?";
+    const identity6 = (part) => qnameOf(part) || nameOf3(part) || "?";
     const projections = /* @__PURE__ */ new Map();
     const projectionFor = (part, ordinal) => {
       const id2 = identity6(part);
@@ -172229,7 +173173,7 @@ ${node.id}`;
         return countDelta || (leftProjection?.ordinal ?? 0) - (rightProjection?.ordinal ?? 0) || identity6(left).localeCompare(identity6(right));
       });
       const partIds = orderedParts.map(identity6);
-      const partNames = orderedParts.map((part) => nameOf2(part) ?? relativeName(part));
+      const partNames = orderedParts.map((part) => nameOf3(part) ?? relativeName(part));
       const partSources = orderedParts.map((part) => sourceOf2(part, uri));
       const memberIds = [...new Set(group.members.map((member) => member.id))];
       const overlayParent = group.owner;
@@ -172256,7 +173200,7 @@ ${node.id}`;
         // lane header, not the qualified
         // `owner::lane` path. Existing nested performer claims retain the
         // relative path that disambiguates same-named nested parts.
-        label: memberIds.length === 0 ? nameOf2(orderedParts[0]) ?? relativeName(orderedParts[0]) : relativeName(orderedParts[0]),
+        label: memberIds.length === 0 ? nameOf3(orderedParts[0]) ?? relativeName(orderedParts[0]) : relativeName(orderedParts[0]),
         keyword: "performer",
         parent: overlayParent,
         isDef: false,
@@ -172294,14 +173238,14 @@ ${node.id}`;
     for (const [memberId, performerIds] of memberPerformers) {
       const performerNames = [...performerIds].map((partId) => {
         const projection2 = projections.get(partId);
-        return projection2 ? nameOf2(projection2.part) ?? relativeName(projection2.part) : partId;
+        return projection2 ? nameOf3(projection2.part) ?? relativeName(projection2.part) : partId;
       });
       const performerMemberships = [...performerIds].map((partId) => {
         const projection2 = projections.get(partId);
         const claimSources = projection2?.members.filter((member) => member.id === memberId).flatMap((member) => performerClaimsOf.get(member.occurrence)?.get(partId) ?? []) ?? [];
         return {
           id: partId,
-          name: projection2 ? nameOf2(projection2.part) ?? relativeName(projection2.part) : partId,
+          name: projection2 ? nameOf3(projection2.part) ?? relativeName(projection2.part) : partId,
           partSource: projection2 ? sourceOf2(projection2.part, uri) : void 0,
           claimSources
         };
@@ -172331,7 +173275,7 @@ ${node.id}`;
     const sends = actionRecords.filter((r) => r.m.$type === "SendNode" || r.m.$type === "ActionDecl" && r.m.sendKw === true);
     const accepts = actionRecords.filter((r) => r.m.$type === "AcceptNode");
     const nodeIdOf = (m) => actionRecords.find((r) => r.m === m)?.id;
-    const semanticIdentity = (node) => node ? qnameOf(node) || nameOf2(node) : void 0;
+    const semanticIdentity = (node) => node ? qnameOf(node) || nameOf3(node) : void 0;
     const resolvedPropertyTarget = (node, property3) => this.featurePaths.resolvePropertyPath(node, property3).segments.at(-1)?.target;
     const payloadTypeIdentity = (send) => {
       const payload = send.payload;
@@ -172391,7 +173335,7 @@ ${node.id}`;
               return acceptVia === target;
             return a2.m === target || a2.m.$container === target;
           }
-          return !!a2.performer && (qnameOf(a2.performer) === targetText || nameOf2(a2.performer) === lastSeg(targetText));
+          return !!a2.performer && (qnameOf(a2.performer) === targetText || nameOf3(a2.performer) === lastSeg(targetText));
         });
       }
       const match = candidates.length === 1 ? candidates[0] : void 0;
@@ -172449,12 +173393,12 @@ ${node.id}`;
       const def = this.resolveType(holder, index2);
       return def && def !== holder && def.isDef === true ? def : void 0;
     };
-    const ownStates = (holder) => membersOf(holder).map((member) => this.thenActionMemberNode(member) ?? member).filter((member) => isStateDecl(member) && nameOf2(member) !== void 0);
+    const ownStates = (holder) => membersOf(holder).map((member) => this.thenActionMemberNode(member) ?? member).filter((member) => isStateDecl(member) && nameOf3(member) !== void 0);
     const nestedStates = (holder) => {
       const out = ownStates(holder).map((node) => ({ node, borrowed: false }));
       const def = definitionOf(holder);
       for (const inherited of def ? ownStates(def) : []) {
-        if (!out.some((m) => nameOf2(m.node) === nameOf2(inherited))) {
+        if (!out.some((m) => nameOf3(m.node) === nameOf3(inherited))) {
           out.push({ node: inherited, borrowed: true });
         }
       }
@@ -172464,11 +173408,11 @@ ${node.id}`;
     const nodes = [];
     const frames = [];
     const byName = /* @__PURE__ */ new Map();
-    const anchorFrameId = (isStateDecl(anchor) || isExhibitStateDecl(anchor)) && topStates.length > 0 ? qnameOf(anchor) || nameOf2(anchor) || "__state_anchor__" : void 0;
+    const anchorFrameId = (isStateDecl(anchor) || isExhibitStateDecl(anchor)) && topStates.length > 0 ? qnameOf(anchor) || nameOf3(anchor) || "__state_anchor__" : void 0;
     if (anchorFrameId) {
       frames.push({
         id: anchorFrameId,
-        label: nameOf2(anchor) ?? lastSeg(anchorFrameId),
+        label: nameOf3(anchor) ?? lastSeg(anchorFrameId),
         keyword: keywordFor(anchor),
         isDef: anchor.isDef === true,
         type: typeText(anchor),
@@ -172507,11 +173451,11 @@ ${node.id}`;
       return created;
     };
     const scopedId = (scope2, name) => `${scope2}::${name}`;
-    const machineScopeId = anchorFrameId ?? qnameOf(anchor) ?? nameOf2(anchor) ?? "__stv__";
+    const machineScopeId = anchorFrameId ?? qnameOf(anchor) ?? nameOf3(anchor) ?? "__stv__";
     const renderState = (s, parentFrame, depth, seen, scope2, borrowed) => {
-      const id2 = borrowed ? scopedId(scope2, nameOf2(s)) : qnameOf(s) || nameOf2(s);
-      byName.set(nameOf2(s), id2);
-      namesIn(parentFrame).set(nameOf2(s), id2);
+      const id2 = borrowed ? scopedId(scope2, nameOf3(s)) : qnameOf(s) || nameOf3(s);
+      byName.set(nameOf3(s), id2);
+      namesIn(parentFrame).set(nameOf3(s), id2);
       registerDrawn(s);
       drawnStates.push({ node: s, id: id2 });
       idByState.set(s, id2);
@@ -172522,7 +173466,7 @@ ${node.id}`;
       if (subStates.length) {
         frames.push({
           id: id2,
-          label: nameOf2(s),
+          label: nameOf3(s),
           keyword: keywordFor(s),
           parent: parentFrame,
           isDef: s.isDef === true,
@@ -172537,7 +173481,7 @@ ${node.id}`;
       } else {
         nodes.push({
           id: id2,
-          name: nameOf2(s),
+          name: nameOf3(s),
           keyword: keywordFor(s),
           isDef: s.isDef === true,
           shape: "state",
@@ -172555,11 +173499,11 @@ ${node.id}`;
     const controlNodeInfo = (m) => {
       switch (m.$type) {
         case "ActionDecl":
-          return m.isDef === true || !nameOf2(m) ? void 0 : { shape: "action", label: nameOf2(m) };
+          return m.isDef === true || !nameOf3(m) ? void 0 : { shape: "action", label: nameOf3(m) };
         // A `perform` names the action it performs, which for a feature
         // chain (`perform machine.selfTest;`) is the LAST segment.
         case "PerformStmt": {
-          const segments = [nameOf2(m), ...m.chainSegs ?? []].filter((segment) => !!segment);
+          const segments = [nameOf3(m), ...m.chainSegs ?? []].filter((segment) => !!segment);
           return { shape: "action", label: segments.at(-1) ?? typeText(m) ?? "perform" };
         }
         // User direction 2026-08-30: fork and join only. They express
@@ -172573,9 +173517,9 @@ ${node.id}`;
         // so no succession can reach it and it could only ever stand
         // alone. All three remain in the OMG 8.2.3.18 node set.
         case "JoinNode":
-          return { shape: "join", label: nameOf2(m) ?? "" };
+          return { shape: "join", label: nameOf3(m) ?? "" };
         case "ForkNode":
-          return { shape: "fork", label: nameOf2(m) ?? "" };
+          return { shape: "fork", label: nameOf3(m) ?? "" };
         default:
           return void 0;
       }
@@ -172596,7 +173540,7 @@ ${node.id}`;
         const info = controlNodeInfo(member);
         if (!info)
           continue;
-        const name = nameOf2(member);
+        const name = nameOf3(member);
         if (name && drawnHere.has(name))
           continue;
         const id2 = name ? borrowed ? scopedId(frameId, name) : qnameOf(member) || scopedId(frameId, name) : `${frameId}::__stv_${member.$type}_${anonymousNodes++}__`;
@@ -172736,7 +173680,7 @@ ${node.id}`;
       }
     }
     const anchorDefinition = definitionOf(anchor);
-    const firstStateId = designatedInitial(anchor, anchorFrameId) ?? (anchorDefinition ? designatedInitial(anchorDefinition, anchorFrameId) : void 0) ?? (topStates.length ? namesIn(anchorFrameId).get(nameOf2(topStates[0].node)) ?? byName.get(nameOf2(topStates[0].node)) : void 0);
+    const firstStateId = designatedInitial(anchor, anchorFrameId) ?? (anchorDefinition ? designatedInitial(anchorDefinition, anchorFrameId) : void 0) ?? (topStates.length ? namesIn(anchorFrameId).get(nameOf3(topStates[0].node)) ?? byName.get(nameOf3(topStates[0].node)) : void 0);
     if (firstStateId)
       link("__initial__", firstStateId, void 0, void 0);
     const compositeInitial = /* @__PURE__ */ new Map();
@@ -172780,7 +173724,7 @@ ${node.id}`;
     }
     const sequentialTransitions = (holder, initialId, frameId) => {
       let cursor;
-      const idOf = (member) => machineNodeIdIn(frameId, member) ?? (nameOf2(member) ? resolveEndpoint(nameOf2(member), void 0, frameId) : void 0) ?? idByState.get(member);
+      const idOf = (member) => machineNodeIdIn(frameId, member) ?? (nameOf3(member) ? resolveEndpoint(nameOf3(member), void 0, frameId) : void 0) ?? idByState.get(member);
       const endpoint = (path10) => resolveEndpoint(path10, initialId, frameId);
       for (const member of membersOf(holder)) {
         switch (member.$type) {
@@ -172903,10 +173847,10 @@ ${node.id}`;
       if (!targetNode && !targetFrame)
         continue;
       const primary = claims[0].part;
-      const partIds = claims.map(({ part }) => qnameOf(part) || nameOf2(part) || "?");
-      const partNames = claims.map(({ part }) => nameOf2(part) ?? lastSeg(qnameOf(part) || "?"));
+      const partIds = claims.map(({ part }) => qnameOf(part) || nameOf3(part) || "?");
+      const partNames = claims.map(({ part }) => nameOf3(part) ?? lastSeg(qnameOf(part) || "?"));
       const partSources = claims.map(({ part }) => sourceOf2(part, uri));
-      const frameId = `__stv_exhibitor_${exhibitBoundary++}__${qnameOf(primary) || nameOf2(primary) || "part"}`;
+      const frameId = `__stv_exhibitor_${exhibitBoundary++}__${qnameOf(primary) || nameOf3(primary) || "part"}`;
       const oldParent = targetNode?.frame ?? targetFrame?.parent;
       frames.push({
         id: frameId,
@@ -172922,13 +173866,13 @@ ${node.id}`;
           exhibitorPartNames: partNames,
           exhibitorPartSources: partSources,
           exhibitorClaims: claims.map(({ part, claim }) => ({
-            partId: qnameOf(part) || nameOf2(part) || "?",
-            partName: nameOf2(part) ?? lastSeg(qnameOf(part) || "?"),
+            partId: qnameOf(part) || nameOf3(part) || "?",
+            partName: nameOf3(part) ?? lastSeg(qnameOf(part) || "?"),
             source: sourceOf2(claim, uri),
             declaresState: !this.referencesBehavior(claim)
           })),
-          declarationId: qnameOf(primary) || nameOf2(primary),
-          declarationName: nameOf2(primary),
+          declarationId: qnameOf(primary) || nameOf3(primary),
+          declarationName: nameOf3(primary),
           declarationSource: sourceOf2(primary, uri),
           auxId: frameId
         }
@@ -173009,9 +173953,9 @@ ${node.id}`;
     const lifelineIds = /* @__PURE__ */ new Map();
     const byName = /* @__PURE__ */ new Map();
     for (const p of parts) {
-      const id2 = qnameOf(p) || nameOf2(p);
+      const id2 = qnameOf(p) || nameOf3(p);
       lifelineIds.set(p, id2);
-      byName.set(nameOf2(p), id2);
+      byName.set(nameOf3(p), id2);
     }
     const evKey = (lifeline, event) => `${lifeline}\0${event}`;
     const eventChains = /* @__PURE__ */ new Map();
@@ -173020,8 +173964,8 @@ ${node.id}`;
       const chain = [];
       for (const m of membersOf(p)) {
         const ev = m.$type === "EventDecl" ? m : m.$type === "ThenActionMember" ? m.event : void 0;
-        if (ev && ev.$type === "EventDecl" && nameOf2(ev))
-          chain.push(evKey(id2, nameOf2(ev)));
+        if (ev && ev.$type === "EventDecl" && nameOf3(ev))
+          chain.push(evKey(id2, nameOf3(ev)));
       }
       if (chain.length)
         eventChains.set(id2, chain);
@@ -173040,7 +173984,7 @@ ${node.id}`;
         const from = resolveLifeline(ends.source);
         const to = resolveLifeline(ends.target);
         if (from && to) {
-          const nm = nameOf2(m);
+          const nm = nameOf3(m);
           const t = this.flowPayloadText(m) ?? typeText(m);
           const label = nm && t ? `${nm} of ${t}` : nm ?? t;
           const reply = nm?.toLowerCase().startsWith("reply") ?? false;
@@ -173163,7 +174107,7 @@ ${node.id}`;
       const events = (eventChains.get(id2) ?? []).filter((k) => !rootHasMsg.has(find3(k))).map((k) => ({ name: k.split("\0")[1], slot: slotOf.get(find3(k)) ?? 0 }));
       nodes.push({
         id: id2,
-        name: nameOf2(p),
+        name: nameOf3(p),
         keyword: keywordFor(p),
         isDef: false,
         shape: "lifeline",
@@ -173246,7 +174190,7 @@ ${node.id}`;
     const scope = this.packageScopeOf(anchor);
     const scopeContents = [...ast_utils_exports.streamAllContents(scope)];
     let cases = scopeContents.filter(this.isCaseUsage);
-    let caseDefs = scopeContents.filter((n2) => this.isCaseLike(n2) && n2.isDef === true && nameOf2(n2));
+    let caseDefs = scopeContents.filter((n2) => this.isCaseLike(n2) && n2.isDef === true && nameOf3(n2));
     if (!isPackage(anchor) && !isDocument(anchor)) {
       const related = this.relatedNodes(anchor, ctx.index);
       cases = cases.filter((c) => related.has(c));
@@ -173268,11 +174212,11 @@ ${node.id}`;
     };
     const displayedCases = [.../* @__PURE__ */ new Set([...cases, ...caseDefs])];
     const nodes = [];
-    const scopeId = qnameOf(scope) || nameOf2(scope) || "__document__";
+    const scopeId = qnameOf(scope) || nameOf3(scope) || "__document__";
     const idOf = /* @__PURE__ */ new Map();
     const add = (n2, shape, extra) => {
       const { id: explicitId, ...rest } = extra ?? {};
-      const id2 = explicitId ?? (qnameOf(n2) || nameOf2(n2) || `n${nodes.length}`);
+      const id2 = explicitId ?? (qnameOf(n2) || nameOf3(n2) || `n${nodes.length}`);
       idOf.set(n2, id2);
       nodes.push({
         id: id2,
@@ -173392,7 +174336,7 @@ ${node.id}`;
         }
       }
     }
-    const denotesSubject = (s) => !!(nameOf2(s) || typeText(s) || subjectValuePath(s));
+    const denotesSubject = (s) => !!(nameOf3(s) || typeText(s) || subjectValuePath(s));
     for (const c of displayedCases) {
       const declared = declaredMembers(c).filter(isSubjectDecl);
       const s = declared.find(denotesSubject) ?? declared[0];
@@ -173408,7 +174352,7 @@ ${node.id}`;
       meta: { cvCase: true, ...subjectOfCase.has(c) ? { subject: subjectOfCase.get(c) } : {} }
     }));
     for (const d of caseDefs) {
-      if (idOf.has(d) || !(qnameOf(d) || nameOf2(d)))
+      if (idOf.has(d) || !(qnameOf(d) || nameOf3(d)))
         continue;
       add(d, "box", {
         compartments: this.compartmentsFor(d, uri, index2),
@@ -173475,7 +174419,7 @@ ${node.id}`;
       const typeSources = siblings.some((a2) => !actorTypeKey(a2)) ? [...siblings, ...this.inheritedTypesOf(c, index2).flatMap((t) => membersOf(t).filter(isActorDecl))] : siblings;
       for (const a2 of siblings) {
         const actorId = addActor(a2, typeSources);
-        const pair = `${actorId}\0${qnameOf(c) ?? nameOf2(c) ?? ""}`;
+        const pair = `${actorId}\0${qnameOf(c) ?? nameOf3(c) ?? ""}`;
         if (!actorCasePairs.has(pair)) {
           actorCasePairs.add(pair);
           actorOfCase.push([actorId, c]);
@@ -173486,16 +174430,16 @@ ${node.id}`;
     const usageByName = /* @__PURE__ */ new Map();
     const definitionByName = /* @__PURE__ */ new Map();
     for (const d of caseDefs) {
-      const dn = nameOf2(d);
+      const dn = nameOf3(d);
       if (dn && !definitionByName.has(dn))
         definitionByName.set(dn, d);
     }
     for (const c of cases) {
       const def = caseDefOf(c);
-      const dn = def ? nameOf2(def) : void 0;
+      const dn = def ? nameOf3(def) : void 0;
       if (dn && !usageByDefName.has(dn))
         usageByDefName.set(dn, c);
-      const un = nameOf2(c);
+      const un = nameOf3(c);
       if (un)
         usageByName.set(un, c);
     }
@@ -173576,19 +174520,19 @@ ${node.id}`;
     const { uri, index: index2 } = ctx;
     const scope = this.packageScopeOf(ctx.anchor);
     const all = [...ast_utils_exports.streamAllContents(scope)];
-    const reqs = all.filter((n2) => isRequirementDecl(n2) && nameOf2(n2));
+    const reqs = all.filter((n2) => isRequirementDecl(n2) && nameOf3(n2));
     const subjectKeyOf = (req) => {
       const subject = membersOf(req).find((m) => m.$type === "SubjectDecl");
-      return (subject ? typeText(subject) ?? nameOf2(subject) ?? "" : "") || "\uFFFF";
+      return (subject ? typeText(subject) ?? nameOf3(subject) ?? "" : "") || "\uFFFF";
     };
-    reqs.sort((a2, b) => subjectKeyOf(a2).localeCompare(subjectKeyOf(b)) || (nameOf2(a2) ?? "").localeCompare(nameOf2(b) ?? ""));
+    reqs.sort((a2, b) => subjectKeyOf(a2).localeCompare(subjectKeyOf(b)) || (nameOf3(a2) ?? "").localeCompare(nameOf3(b) ?? ""));
     const satisfies = all.filter((n2) => n2.$type === "SatisfyStmt");
     const verifies = all.filter((n2) => n2.$type === "VerifyStmt");
-    const reqAttrs = (req) => membersOf(req).filter((m) => isAttributeDecl(m) && m.isDef !== true && nameOf2(m));
+    const reqAttrs = (req) => membersOf(req).filter((m) => isAttributeDecl(m) && m.isDef !== true && nameOf3(m));
     const attrColumns = [];
     for (const req of reqs) {
       for (const a2 of reqAttrs(req)) {
-        const an = nameOf2(a2);
+        const an = nameOf3(a2);
         if (!attrColumns.includes(an))
           attrColumns.push(an);
       }
@@ -173599,14 +174543,14 @@ ${node.id}`;
       return t.length >= 2 && (t[0] === '"' && t.endsWith('"') || t[0] === "'" && t.endsWith("'")) ? t.slice(1, -1).trim() : t;
     };
     const reqIdOf = (req) => {
-      const idAttr = membersOf(req).find((m) => isAttributeDecl(m) && m.isDef !== true && (nameOf2(m) === "reqId" || (m.relationships ?? []).some((r) => (r.targets ?? []).some((t) => lastSeg(t) === "reqId"))));
+      const idAttr = membersOf(req).find((m) => isAttributeDecl(m) && m.isDef !== true && (nameOf3(m) === "reqId" || (m.relationships ?? []).some((r) => (r.targets ?? []).some((t) => lastSeg(t) === "reqId"))));
       const attrVal = idAttr ? stripQuotes2(attrValueText(idAttr)) : "";
       if (attrVal)
         return attrVal;
       const sn = req.shortName?.name;
       return sn ? stripQuotes2(sn) : "";
     };
-    const rowIdOf = (req) => qnameOf(req) || nameOf2(req);
+    const rowIdOf = (req) => qnameOf(req) || nameOf3(req);
     const reqSet = new Set(reqs);
     const parentReqOf = (req) => {
       let cur = req.$container;
@@ -173640,7 +174584,7 @@ ${node.id}`;
     for (const root4 of roots)
       visit(root4, 0, void 0);
     const rows = ordered.map(({ req, depth, parentId }) => {
-      const name = nameOf2(req);
+      const name = nameOf3(req);
       const qname = qnameOf(req) || name;
       const docMember = membersOf(req).find((m) => m.$type === "DocCommentMember");
       const docText = docMember ? docCommentBody(docMember) ?? "" : "";
@@ -173651,12 +174595,12 @@ ${node.id}`;
       const reqSatisfies = satisfies.filter((s) => pathMatchesQName(String(s.target ?? ""), qname));
       const reqVerifies = verifies.filter((v) => pathMatchesQName(String(v.target ?? ""), qname));
       const satPills = reqSatisfies.map((s) => ({
-        text: bindingName(s.by) ?? nameOf2(this.enclosingUsage(s) ?? s) ?? "?",
+        text: bindingName(s.by) ?? nameOf3(this.enclosingUsage(s) ?? s) ?? "?",
         kind: "satisfy",
         source: sourceOf2(s, uri)
       }));
       const verPills = reqVerifies.map((v) => ({
-        text: nameOf2(this.enclosingCase(v) ?? v) ?? "?",
+        text: nameOf3(this.enclosingCase(v) ?? v) ?? "?",
         kind: "verify",
         source: sourceOf2(v, uri)
       }));
@@ -173672,7 +174616,7 @@ ${node.id}`;
       }
       const ownAttrs = reqAttrs(req);
       const attrCells = attrColumns.map((an) => {
-        const a2 = ownAttrs.find((x) => nameOf2(x) === an);
+        const a2 = ownAttrs.find((x) => nameOf3(x) === an);
         const v = a2 ? attrValueText(a2) : "";
         return { text: v, accent: "yellow", edit: { kind: "attribute", name: an, value: v } };
       });
@@ -173712,10 +174656,10 @@ ${node.id}`;
   buildTabularGrid(ctx) {
     const { uri } = ctx;
     const scope = this.packageScopeOf(ctx.anchor);
-    const elems = [...ast_utils_exports.streamAllContents(scope)].filter((n2) => isDefinitionKind(n2) && nameOf2(n2));
-    elems.sort((a2, b) => keywordFor(a2).localeCompare(keywordFor(b)) || (nameOf2(a2) ?? "").localeCompare(nameOf2(b) ?? ""));
+    const elems = [...ast_utils_exports.streamAllContents(scope)].filter((n2) => isDefinitionKind(n2) && nameOf3(n2));
+    elems.sort((a2, b) => keywordFor(a2).localeCompare(keywordFor(b)) || (nameOf3(a2) ?? "").localeCompare(nameOf3(b) ?? ""));
     const rows = elems.map((n2) => {
-      const name = nameOf2(n2);
+      const name = nameOf3(n2);
       const usageFields = n2.isDef !== true;
       const docMember = membersOf(n2).find((m) => m.$type === "DocCommentMember");
       const docText = docMember ? docCommentBody(docMember) ?? "" : "";
@@ -173743,12 +174687,12 @@ ${node.id}`;
     const scope = this.packageScopeOf(ctx.anchor);
     const valued = [...ast_utils_exports.streamAllContents(scope)].filter((n2) => {
       const vn = n2;
-      return nameOf2(n2) && vn.isDef !== true && (isAttributeDecl(n2) || vn.value !== void 0 || vn.default !== void 0);
+      return nameOf3(n2) && vn.isDef !== true && (isAttributeDecl(n2) || vn.value !== void 0 || vn.default !== void 0);
     });
     const ownerName = (n2) => {
       for (let c = n2.$container; c; c = c.$container)
-        if (nameOf2(c))
-          return nameOf2(c);
+        if (nameOf3(c))
+          return nameOf3(c);
       return "";
     };
     const valueText = (n2) => {
@@ -173756,7 +174700,7 @@ ${node.id}`;
       return (nn.value?.$cstNode?.text ?? nn.default?.value?.$cstNode?.text ?? "").replace(/\s+/g, " ").trim();
     };
     const rows = valued.map((n2) => {
-      const name = nameOf2(n2);
+      const name = nameOf3(n2);
       const cells = [
         { text: name, accent: "violet", edit: { kind: "name", value: name } },
         { text: typeText(n2) ?? "", edit: { kind: "type", value: typeText(n2) ?? "" } },
@@ -173793,7 +174737,7 @@ ${node.id}`;
           return;
         const owner = this.enclosingUsage(m) ?? m.$container;
         const bound = bindingName(mn.by);
-        push2(bound ?? (owner ? qnameOf(owner) || nameOf2(owner) : void 0), mn.target, m);
+        push2(bound ?? (owner ? qnameOf(owner) || nameOf3(owner) : void 0), mn.target, m);
         return;
       }
       case "flow": {
@@ -173868,7 +174812,7 @@ ${node.id}`;
     const bySimple = /* @__PURE__ */ new Map();
     const visit = (m) => {
       if (m.$type !== "ImportSeg") {
-        const name = nameOf2(m);
+        const name = nameOf3(m);
         const qname = name ? qnameOf(m) : "";
         if (name && qname) {
           byQName.set(qname, m);
@@ -173914,7 +174858,7 @@ ${node.id}`;
       const elem = byQName.get(f);
       return {
         id: f,
-        name: elem ? nameOf2(elem) : void 0,
+        name: elem ? nameOf3(elem) : void 0,
         keyword: elem ? keywordFor(elem) : void 0,
         cells,
         source: src ? sourceOf2(src, uri) : void 0
@@ -173939,7 +174883,7 @@ ${node.id}`;
       if (depth > 12)
         return;
       for (const m of membersOf(node)) {
-        const nm = nameOf2(m);
+        const nm = nameOf3(m);
         if (!nm) {
           visit(m, parentId, depth + 1);
           continue;
@@ -174091,7 +175035,7 @@ ${node.id}`;
   // with every unpositioned part in the tree.
   collectGeometry(anchor, index2) {
     const out = [];
-    const base = qnameOf(anchor) || nameOf2(anchor) || "";
+    const base = qnameOf(anchor) || nameOf3(anchor) || "";
     const frames = /* @__PURE__ */ new Map();
     const anchorFrame = this.ownFrameOf(anchor, index2);
     if (anchorFrame)
@@ -174107,7 +175051,7 @@ ${node.id}`;
           continue;
         if (!isPartDecl(child) && !isItemDecl(child))
           continue;
-        const name = nameOf2(child);
+        const name = nameOf3(child);
         if (!name)
           continue;
         const local = this.localPlacementOf(child, index2);
@@ -174572,7 +175516,7 @@ ${node.id}`;
     let def = this.resolveType(node, index2);
     let guard = 0;
     while (def && guard++ < 12) {
-      const dn = nameOf2(def);
+      const dn = nameOf3(def);
       if (dn) {
         const k = _SysmlDiagramModelProvider.SHAPE_TYPES[dn.toLowerCase()];
         if (k)
@@ -174649,7 +175593,7 @@ ${node.id}`;
   // Whether an attribute member's effective names (its own name plus any
   // `:>>`/`:>`/redefines/subsets target) intersect the wanted set.
   attrMatches(m, want) {
-    const nm = nameOf2(m);
+    const nm = nameOf3(m);
     if (nm && want.has(nm.toLowerCase()))
       return true;
     const short = m.shortName?.name;
@@ -174679,8 +175623,8 @@ ${node.id}`;
     return {
       kind,
       root: {
-        id: qnameOf(anchor) || nameOf2(anchor) || "",
-        name: nameOf2(anchor) ?? (isPackage(anchor) ? "package" : ""),
+        id: qnameOf(anchor) || nameOf3(anchor) || "",
+        name: nameOf3(anchor) ?? (isPackage(anchor) ? "package" : ""),
         qname: qnameOf(anchor),
         // REQ-173 — the frame header states the ANCHORING ELEMENT's
         // keyword. A view opened on a package (a package overview, a
@@ -174787,7 +175731,7 @@ ${node.id}`;
   ownerDecl(node) {
     let cur = node;
     while (cur) {
-      if (nameOf2(cur) && (isDefinitionKind(cur) || isPackage(cur)))
+      if (nameOf3(cur) && (isDefinitionKind(cur) || isPackage(cur)))
         return cur;
       cur = cur.$container;
     }
@@ -174942,7 +175886,7 @@ ${node.id}`;
   enclosingLifeline(node, byName) {
     let cur = node.$container;
     while (cur) {
-      const nm = nameOf2(cur);
+      const nm = nameOf3(cur);
       if (nm && byName.has(nm))
         return byName.get(nm);
       cur = cur.$container;
@@ -175015,12 +175959,12 @@ ${node.id}`;
         // projection origin to choose a direct edit or a usage-local
         // `port :>> name { ... }` materialization.
         meta: {
-          declarationId: nameOf2(portNode) ? qnameOf(portNode) || portId : portId,
+          declarationId: nameOf3(portNode) ? qnameOf(portNode) || portId : portId,
           declarationName: pn,
           inheritedFromType,
-          localDeclaration: !inheritedFromType && !!nameOf2(portNode) && !!localUsage && isAstDescendantOrSelf(portNode, localUsage),
+          localDeclaration: !inheritedFromType && !!nameOf3(portNode) && !!localUsage && isAstDescendantOrSelf(portNode, localUsage),
           definitionId: portTypeDef ? qnameOf(portTypeDef) : void 0,
-          definitionName: portTypeDef ? nameOf2(portTypeDef) : void 0,
+          definitionName: portTypeDef ? nameOf3(portTypeDef) : void 0,
           definitionSource: portTypeDef ? sourceOf2(portTypeDef, uri) : void 0,
           ...(() => {
             const syncDeclaration = this.synchronizationDeclarationOf(portNode, index2);
@@ -175149,11 +176093,11 @@ ${node.id}`;
     const segs = sourcePath.split(".");
     if (segs.length < 2)
       return void 0;
-    const part = parts.find((p) => nameOf2(p) === segs[0]);
+    const part = parts.find((p) => nameOf3(p) === segs[0]);
     if (!part)
       return void 0;
     const typeDef = this.resolveType(part, index2);
-    const portNode = typeDef ? membersOf(typeDef).find((m) => isPortDecl(m) && nameOf2(m) === segs[segs.length - 1]) : void 0;
+    const portNode = typeDef ? membersOf(typeDef).find((m) => isPortDecl(m) && nameOf3(m) === segs[segs.length - 1]) : void 0;
     const portTypeDef = portNode ? this.resolveType(portNode, index2) : void 0;
     if (!portTypeDef)
       return void 0;
@@ -175177,11 +176121,11 @@ ${node.id}`;
     const dir = directionOf(m);
     const conj = isConjugated(m) ? "~" : "";
     const t = typeText(m) ?? this.effectiveEnumerationTypeText(m);
-    return `${dir ? `${dir} ` : ""}${derived}${nameOf2(m) ?? ""}${t ? ` : ${conj}${t}` : ""}`.trim();
+    return `${dir ? `${dir} ` : ""}${derived}${nameOf3(m) ?? ""}${t ? ` : ${conj}${t}` : ""}`.trim();
   }
   effectiveEnumerationTypeText(node) {
     const type = this.effectiveEnumerationType(node);
-    return type ? nameOf2(type) : void 0;
+    return type ? nameOf3(type) : void 0;
   }
   effectiveEnumerationType(node) {
     if (!isEnumerationUsage(node))
@@ -175222,7 +176166,7 @@ ${node.id}`;
     const isOrdinaryMember = (m) => directionOf(m) === void 0 && isNonVariantMember(m);
     const inherited = includeInherited ? this.inheritedItems(node, index2, uri) : [];
     const inheritedRows = (predicate, text = (member) => this.featureText(member)) => inherited.filter(({ member }) => predicate(member)).map(({ member, source }) => ({ text: `^${text(member)}`, source }));
-    const usages = (guard) => members.filter((m) => guard(m) && m.isDef !== true && nameOf2(m) && isOrdinaryMember(m));
+    const usages = (guard) => members.filter((m) => guard(m) && m.isDef !== true && nameOf3(m) && isOrdinaryMember(m));
     const exprText4 = (m) => (m.body?.$cstNode?.text ?? "").replace(/\s+/g, " ").trim();
     const statementText = (m) => (m.$cstNode?.text ?? this.featureText(m)).replace(/\s+/g, " ").replace(/;$/, "").trim();
     const canonicalFeatureText = (m) => m.$type === "FeatureShorthand" || m.$type === "FeatureRedefinitionShorthand" ? statementText(m) : this.featureText(m);
@@ -175272,7 +176216,7 @@ ${node.id}`;
     const undirected = (guard) => usages(guard);
     add("items", undirected(isItemDecl).filter(notPortion).map((m) => item(m)));
     add("occurrences", undirected(isOccurrenceDecl).filter(notPortion).map((m) => item(m)));
-    add("occurrences", members.map((m) => this.thenActionMemberNode(m) ?? m).filter(isNonVariantMember).filter((m) => isEventDecl(m) && m.isOccurrence === true && nameOf2(m)).map((m) => item(m)));
+    add("occurrences", members.map((m) => this.thenActionMemberNode(m) ?? m).filter(isNonVariantMember).filter((m) => isEventDecl(m) && m.isOccurrence === true && nameOf3(m)).map((m) => item(m)));
     add("calcs", undirected(isCalcDecl).map((m) => item(m)));
     add("constraints", undirected(isConstraintDecl).map((m) => item(m)));
     add("assume constraints", members.filter((m) => m.$type === "AssumeConstraintStmt").map((m) => item(m, exprText4(m) || "assume constraint")));
@@ -175281,7 +176225,7 @@ ${node.id}`;
     add("stakeholders", members.filter(isStakeholderDecl).filter(isNonVariantMember).map((m) => item(m)));
     add("frames", members.filter((m) => m.$type === "FrameMember").map((m) => item(m, this.refText(m.target) ?? "concern")));
     add("include use cases", members.filter((m) => m.$type === "IncludeStmt").map((m) => item(m, this.refText(m.target) ?? "")));
-    add("objective", members.filter(isObjectiveDecl).filter(isNonVariantMember).map((m) => item(m, nameOf2(m) ?? "objective")));
+    add("objective", members.filter(isObjectiveDecl).filter(isNonVariantMember).map((m) => item(m, nameOf3(m) ?? "objective")));
     add("verifies", members.filter((m) => m.$type === "VerifyStmt").map((m) => item(m, String(m.target ?? ""))));
     add("verification methods", members.filter((m) => isMetadataDecl(m) && (typeText(m) ?? "").includes("VerificationMethod")).map((m) => item(m, typeText(m) ?? "method")));
     const behavioralParameterOwner = ["AssertConstraintStmt", "AssumeConstraintStmt", "RequireConstraintStmt"].includes(node.$type) || isActionDecl(node) || isCalcDecl(node) || isConstraintDecl(node) || isCaseDecl(node) || isAnalysisCaseDecl(node) || isVerificationCaseDecl(node) || isUseCaseDecl(node);
@@ -175300,12 +176244,12 @@ ${node.id}`;
     })();
     const directedTitle = behavioralParameterOwner || enclosingBehavioralParameterOwner ? "parameters" : "directed features";
     add(directedTitle, [
-      ...members.filter((m) => directionOf(m) !== void 0 && nameOf2(m)).filter((m) => !isVariantMember(m) && !isVariantConfigMember(m)).map((m) => item(m, canonicalFeatureText(m))),
+      ...members.filter((m) => directionOf(m) !== void 0 && nameOf3(m)).filter((m) => !isVariantMember(m) && !isVariantConfigMember(m)).map((m) => item(m, canonicalFeatureText(m))),
       ...inheritedRows((member) => directionOf(member) !== void 0 && isNonVariantMember(member))
     ]);
     const calculationResult = isCalcDecl(node) ? effectiveCalculationResult(node, (name) => index2?.get(name)) : void 0;
     const results = calculationResult?.parameter ? [calculationResult.parameter] : members.filter((m) => m.$type === "ReturnDecl");
-    add("result", results.map((m) => item(m, `${calculationResult?.inherited ? "^" : ""}return${nameOf2(m) ? ` ${nameOf2(m)}` : ""}${typeText(m) ? ` : ${typeText(m)}` : ""}${valueTextOf(m) ? ` = ${valueTextOf(m)}` : ""}`)));
+    add("result", results.map((m) => item(m, `${calculationResult?.inherited ? "^" : ""}return${nameOf3(m) ? ` ${nameOf3(m)}` : ""}${typeText(m) ? ` : ${typeText(m)}` : ""}${valueTextOf(m) ? ` = ${valueTextOf(m)}` : ""}`)));
     if (calculationResult?.expression)
       add("expression", [{
         text: calculationResult.expression.$cstNode?.text ?? "",
@@ -175316,7 +176260,7 @@ ${node.id}`;
     }
     const enumValueMembers = isEnumDecl(node) ? members.filter(isOwnedEnumerationValue) : members.filter((m) => isNonVariantMember(m) && m.$type === "EnumValueDecl" && !m.typing);
     add("enums", enumValueMembers.map((m) => {
-      const nm = nameOf2(m);
+      const nm = nameOf3(m);
       if (nm)
         return item(m, nm);
       const val = (m.value?.$cstNode?.text ?? "").replace(/\s+/g, " ").trim();
@@ -175335,17 +176279,17 @@ ${node.id}`;
       DoAction: "during",
       ExitAction: "exit"
     };
-    const stateActionText = (m) => nameOf2(m) ?? (m.$cstNode?.text ?? "").replace(/\s+/g, " ").replace(/;$/, "").replace(/^(entry|do|exit)\s+(action\s+)?/, "").trim();
+    const stateActionText = (m) => nameOf3(m) ?? (m.$cstNode?.text ?? "").replace(/\s+/g, " ").replace(/;$/, "").replace(/^(entry|do|exit)\s+(action\s+)?/, "").trim();
     for (const title of ["entry", "during", "exit"]) {
       add(title, members.filter((m, at) => stateActionTitle[m.$type] === title && !isInitialStateMarker(m, at)).map((m) => item(m, stateActionText(m))).filter((row) => !!row.text));
     }
     add("state transition", members.filter((m) => m.$type === "TransitionDecl").map((m) => item(m, `${m.from ?? ""} \u2192 ${m.to ?? ""}`)));
     const successionText = (m) => (m.$cstNode?.text ?? "").replace(/\s+/g, " ").replace(/;$/, "").trim();
     add("successions", members.filter((m) => m.$type === "FirstThenChain" || m.$type === "SuccessionStmt" || m.$type === "ThenActionMember" && typeof m.target === "string" || m.$type === "ElseSuccessionMember" || (m.$type === "AcceptNode" || m.$type === "IfActionNode") && typeof m.thenTarget === "string").map((m) => item(m, successionText(m))).filter((row) => !!row.text));
-    add("assert constraints", members.filter((m) => m.$type === "AssertConstraintStmt").map((m) => item(m, exprText4(m) || nameOf2(m) || "assert constraint")));
+    add("assert constraints", members.filter((m) => m.$type === "AssertConstraintStmt").map((m) => item(m, exprText4(m) || nameOf3(m) || "assert constraint")));
     add("invariants", members.filter((m) => m.$type === "InvShorthand").map((m) => {
       const inv = m;
-      const head2 = `inv${inv.isNegated ? " false" : ""}${nameOf2(m) ? ` ${nameOf2(m)}` : ""}`;
+      const head2 = `inv${inv.isNegated ? " false" : ""}${nameOf3(m) ? ` ${nameOf3(m)}` : ""}`;
       const expr = exprText4(m);
       return item(m, `${head2} { ${expr} }`.replace(/\s+/g, " ").trim());
     }));
@@ -175355,7 +176299,7 @@ ${node.id}`;
       if (this.isAnonymousBehaviorReference(m))
         return referenced || this.featureText(m);
       const declared = this.featureText(m);
-      return referenced && referenced !== nameOf2(m) ? `${declared} references ${referenced}` : declared;
+      return referenced && referenced !== nameOf3(m) ? `${declared} references ${referenced}` : declared;
     };
     add("perform actions", members.filter((m) => m.$type === "PerformStmt").filter(isNonVariantMember).map((m) => item(m, performRowText(m))));
     if (isActionFlowStep(node)) {
@@ -175363,7 +176307,7 @@ ${node.id}`;
       const performerName = (part) => {
         const qualified = qnameOf(part);
         if (!qualified)
-          return nameOf2(part) ?? "?";
+          return nameOf3(part) ?? "?";
         return scope && qualified.startsWith(`${scope}::`) ? qualified.slice(scope.length + 2) : qualified;
       };
       const claims = this.performClaimsByTarget(this.documentRootOf(node), index2).get(node) ?? [];
@@ -175401,10 +176345,10 @@ ${node.id}`;
     ];
     add("metadata", metaBadges.map((text) => ({ text })));
     add("variants", [
-      ...members.filter((m) => isVariantMember(m) && nameOf2(m)).map((m) => item(m)),
-      ...inheritedRows((member) => isVariantMember(member) && !!nameOf2(member))
+      ...members.filter((m) => isVariantMember(m) && nameOf3(m)).map((m) => item(m)),
+      ...inheritedRows((member) => isVariantMember(member) && !!nameOf3(member))
     ]);
-    const variantElementText = (member) => `${nameOf2(member) ?? ""} = all ${(member.value?.$cstNode?.text ?? "").trim()}`.trim();
+    const variantElementText = (member) => `${nameOf3(member) ?? ""} = all ${(member.value?.$cstNode?.text ?? "").trim()}`.trim();
     add("variant element usages", [
       ...members.filter(isVariantConfigMember).map((m) => item(m, variantElementText(m))),
       ...inheritedRows(isVariantConfigMember, variantElementText)
@@ -175423,10 +176367,10 @@ ${node.id}`;
     const n2 = node;
     const type = typeText(node);
     const mult = this.multText(node);
-    const name = nameOf2(node) ?? ANONYMOUS_INTERFACE_NAME;
+    const name = nameOf3(node) ?? ANONYMOUS_INTERFACE_NAME;
     const head2 = `${name}${type ? ` : ${type}` : ""}${mult ? ` ${mult}` : ""}`;
     const clause = n2.connect;
-    const ends = clause?.ends?.length ? `connect (${clause.ends.map((end) => this.connectorEndPath(end) ?? "?").join(", ")})` : clause ? `connect ${this.connectorEndPath(clause.source) ?? "?"} to ${this.connectorEndPath(clause.target) ?? "?"}` : n2.target !== void 0 ? `${shorthandSourcePath(node) ?? [nameOf2(node) ?? "", ...n2.srcSegs ?? []].filter(Boolean).join(".")} to ${this.featurePath(n2.target) ?? "?"}` : void 0;
+    const ends = clause?.ends?.length ? `connect (${clause.ends.map((end) => this.connectorEndPath(end) ?? "?").join(", ")})` : clause ? `connect ${this.connectorEndPath(clause.source) ?? "?"} to ${this.connectorEndPath(clause.target) ?? "?"}` : n2.target !== void 0 ? `${shorthandSourcePath(node) ?? [nameOf3(node) ?? "", ...n2.srcSegs ?? []].filter(Boolean).join(".")} to ${this.featurePath(n2.target) ?? "?"}` : void 0;
     if (ends && !clause)
       return ends;
     return [head2, ends].filter(Boolean).join(" ");
@@ -176267,8 +177211,8 @@ function outlineGroupForType(astType) {
 }
 
 // ../language-server/out/src/services/document-symbol-provider.js
-var SPECIALIZATION_KINDS5 = /* @__PURE__ */ new Set([":>", "specializes"]);
-var REDEFINITION_KINDS3 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var SPECIALIZATION_KINDS7 = /* @__PURE__ */ new Set([":>", "specializes"]);
+var REDEFINITION_KINDS4 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var INHERITABLE_FEATURE_TYPES = /* @__PURE__ */ new Set([
   "ActionDecl",
   "AttributeDecl",
@@ -176339,7 +177283,7 @@ function specializationTargets2(node) {
   const n2 = node;
   const out = [];
   for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
-    if (rel2.kind && SPECIALIZATION_KINDS5.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS7.has(rel2.kind))
       out.push(...rel2.targets ?? []);
   }
   return out;
@@ -176348,7 +177292,7 @@ function redefinitionTargets(node) {
   const n2 = node;
   const out = [];
   for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
-    if (rel2.kind && REDEFINITION_KINDS3.has(rel2.kind))
+    if (rel2.kind && REDEFINITION_KINDS4.has(rel2.kind))
       out.push(...rel2.targets ?? []);
   }
   return out;
@@ -177851,6 +178795,29 @@ var DIAGNOSTIC_MESSAGES = {
   // states what the definition may annotate; every explicit `about` target and
   // the element an untargeted usage sits on bind that same feature.
   SSM055_METADATA_TARGET_NOT_APPLICABLE: (target, targetKind, type, allowed) => `'${target}' is a '${targetKind}', but '${type}' annotates ${allowed}. Annotate an element of one of those kinds, or widen the definition's 'annotatedElement'.`,
+  // issue #169 - a metadata definition that specializes 'SemanticMetadata'
+  // says what the elements it annotates ARE (OMG SysML v2 Part 1 §7.27.4), and
+  // 'baseType' is where it says it. Without a value it says nothing, and every
+  // element tagged with it keeps the empty meaning the keyword was meant to fill.
+  SSM056_SEMANTIC_BASE_TYPE_MISSING: (type) => `'${type}' specializes 'SemanticMetadata' but binds no 'baseType'. Bind one (for example ':>> baseType = parts meta SysML::PartUsage;'), or drop the 'SemanticMetadata' supertype.`,
+  // issue #169 - the base type is a written path like any other, and one that
+  // reaches nothing leaves every tagged element with no supertype at all.
+  SSM057_SEMANTIC_BASE_TYPE_UNRESOLVED: (type, written) => `The 'baseType' of '${type}' names '${written}', which resolves to nothing. A semantic metadata base type must name a type this workspace can read.`,
+  // issue #169 - 'SemanticMetadata::baseType' is declared 'Type[1]', so the
+  // value has to BE a type. A package or a relationship is not one, and no
+  // specialization can be made to it.
+  SSM058_SEMANTIC_BASE_TYPE_NOT_A_TYPE: (type, written, kind) => `The 'baseType' of '${type}' names '${written}', which is a '${kind}'. A semantic metadata base type must be a definition or a usage.`,
+  // issue #169 - 'baseType' is single-valued, so a definition and a supertype
+  // that each bind a different one state a contradiction: which one a tagged
+  // element specializes would depend on which is read first.
+  SSM059_SEMANTIC_BASE_TYPE_CONFLICT: (type, first2, second) => `'${type}' states two base types ('${first2}' and '${second}'). 'SemanticMetadata::baseType' holds one type, so redefine it once in the most specific definition.`,
+  // issue #169 - 'SemanticMetadata' redefines 'annotatedElement : Type[1]', so
+  // a semantic tag on a package or an import states a specialization that
+  // cannot exist.
+  SSM060_SEMANTIC_TARGET_NOT_A_TYPE: (type, target, kind) => `'${type}' is semantic metadata, so it annotates a type. '${target}' is a '${kind}'. Tag a definition or a usage, or use a metadata definition that does not specialize 'SemanticMetadata'.`,
+  // issue #169 - the implied specialization is a real edge, so it obeys the
+  // same rule every written one does: a type cannot specialize itself.
+  SSM061_SEMANTIC_BASE_TYPE_CYCLIC: (target, written) => `The implied specialization of '${target}' reaches '${written}', which specializes '${target}' again. Point the 'baseType' at a type outside this chain.`,
   // REQ-392 — a `sysml-format` comment the formatter cannot act on. Advisory:
   // the directive is inert, and saying so beats leaving the author to wonder
   // why their layout was reformatted anyway.
@@ -178061,6 +179028,13 @@ var IMPLICIT_SPECIALIZATION_MESSAGES = {
   subsets: "implicitly subsets",
   source: "  Source: the standard library, through the declaration keyword (OMG SysML v2 Part 1 section 7.6.8)."
 };
+var SEMANTIC_METADATA_MESSAGES = {
+  specializes: "implicitly specializes",
+  definedBy: "is implicitly defined by",
+  subsets: "implicitly subsets",
+  source: (tag) => `  Source: the '${tag}' semantic metadata, through its 'baseType' (OMG SysML v2 Part 1 section 7.27.4).`,
+  effectiveKind: (keyword, tag) => `*Effective kind:* \`${keyword}\`, from the '${tag}' semantic metadata.`
+};
 
 // ../language-server/out/src/services/hover-provider.js
 var MAX_HOVER_LINES = 30;
@@ -178924,6 +179898,11 @@ var SysmlHoverProvider = class {
   linker;
   /** REQ-411 — issue #161: the shared implicit-specialization model. */
   implicit;
+  /** issue #169 - the written paths a `baseType` is read through. */
+  paths;
+  /** issue #169 - one semantic-metadata model per parsed document root. */
+  semanticModels = /* @__PURE__ */ new WeakMap();
+  nameLookup;
   constructor(services) {
     this.references = services.references.References;
     this.astNodeLocator = services.workspace.AstNodeLocator;
@@ -178931,10 +179910,43 @@ var SysmlHoverProvider = class {
     this.indexManager = services.shared.workspace.IndexManager;
     this.linker = services.references.Linker;
     this.implicit = implicitSpecializationsFor(services.shared);
+    this.nameLookup = nameLookupFor(services.shared);
     const paths = new FeaturePathResolver(services);
+    this.paths = paths;
     this.featureProperties = featurePropertyResolver(paths);
     this.enumerations = enumerationResolver(paths);
   }
+  /**
+   * issue #169 - the semantic-metadata annotations of the document `node` is
+   * in, built once per parsed root.
+   *
+   * A card is drawn one element at a time, so building the model per hover
+   * would walk every keyword definition in the file for every tooltip. Keying
+   * on the ROOT rather than the URI is what makes a rebuild produce a fresh
+   * model: a new parse makes a new root, and the previous generation's
+   * annotations are then unreachable.
+   */
+  semanticModelFor(node) {
+    const root4 = ast_utils_exports.findRootNode(node);
+    if (!root4)
+      return void 0;
+    const cached = this.semanticModels.get(root4);
+    if (cached)
+      return cached;
+    const lookup = this.nameLookup;
+    if (!lookup)
+      return void 0;
+    const model = new SemanticMetadataModel(metadataNameResolver({
+      visibleCandidates: (from, name) => this.paths.resolveVisibleNameCandidates(from, name),
+      descriptionsFor: (name) => lookup.descriptions(name),
+      nodeFor: (description) => description.node ?? this.linker.resolveIndexedNode?.(description)
+    }), (usage, _text, occurrence) => {
+      const candidates = this.paths.resolvePropertyPathCandidates(usage, "targets", occurrence);
+      return candidates.length === 1 ? candidates[0] : void 0;
+    }).build(root4);
+    this.semanticModels.set(root4, model);
+    return model;
+  }
   // REQ-246, REQ-334, REQ-335, REQ-336, REQ-342, REQ-343 — Route hover requests to markdown tooltip builders
   async getHoverContent(document2, params) {
     const rootCst = document2.parseResult?.value?.$cstNode;
@@ -179077,7 +180089,8 @@ var SysmlHoverProvider = class {
     const rels = allRelationships2(named2);
     const implied = this.implicit?.baseOf(node);
     const impliedBase = implied && this.implicit?.descriptionOf(implied) ? implied : void 0;
-    if (rels.length === 0 && !impliedBase)
+    const semantic = this.semanticMetadataLines(node);
+    if (rels.length === 0 && !impliedBase && semantic.length === 0)
       return void 0;
     const sourceKind = kindLabel(node);
     const sourceName = identificationLabel(named2) ?? "(anonymous)";
@@ -179103,9 +180116,42 @@ var SysmlHoverProvider = class {
       const phrase = impliedBase.isUsage ? IMPLICIT_SPECIALIZATION_MESSAGES.subsets : IMPLICIT_SPECIALIZATION_MESSAGES.specializes;
       lines.push(`- ${sourceKind} \`${sourceName}\` ${phrase} \`${impliedBase.qualified}\``, IMPLICIT_SPECIALIZATION_MESSAGES.source);
     }
+    lines.push(...semantic);
     return lines.length > 0 ? `*Relationships:*
 ${lines.join("\n")}` : void 0;
   }
+  /**
+   * issue #169 - the lines a semantic-metadata tag adds to a card: one per
+   * edge it creates, and the effective kind a keywordless declaration gains.
+   *
+   * The edge is named with the tag rather than with the base alone, because
+   * the tag is the only thing a reader sees at the declaration: `#subsystem`
+   * says nothing about `subsystems` until the card says it does.
+   */
+  // REQ-420 — SemanticMetadata and user-defined keyword specialization
+  semanticMetadataLines(node) {
+    const model = this.semanticModelFor(node);
+    if (!model)
+      return [];
+    const annotations = model.annotationsOf(node);
+    if (annotations.length === 0)
+      return [];
+    const sourceKind = kindLabel(node);
+    const sourceName = identificationLabel(node) ?? "(anonymous)";
+    const lines = [];
+    for (const annotation of model.edgesOf(node)) {
+      const tag = metadataTypeNamesOf(annotation.usage)[0] ?? "semantic metadata";
+      const target = annotation.base?.node ? identificationLabel(annotation.base.node) ?? annotation.base.binding.written : annotation.base?.binding.written ?? "";
+      const phrase = annotation.edge?.metaclass === "Specialization" ? SEMANTIC_METADATA_MESSAGES.specializes : annotation.edge?.metaclass === "FeatureTyping" ? SEMANTIC_METADATA_MESSAGES.definedBy : SEMANTIC_METADATA_MESSAGES.subsets;
+      lines.push(`- ${sourceKind} \`${sourceName}\` ${phrase} \`${target}\``, SEMANTIC_METADATA_MESSAGES.source(tag));
+    }
+    const kind = effectiveKindOf(node, annotations);
+    if (kind) {
+      const tag = metadataTypeNamesOf(kind.from.usage)[0] ?? "semantic metadata";
+      lines.push(SEMANTIC_METADATA_MESSAGES.effectiveKind(effectiveKeywordOf(kind), tag));
+    }
+    return lines;
+  }
   /**
    * REQ-394 — Resolve a supertype for the documentation walk without pulling a
    * document into the workspace.
@@ -180514,7 +181560,7 @@ var import_vscode_languageserver16 = __toESM(require_main4(), 1);
 
 // ../language-server/out/src/services/metadata-filter.js
 var INCONCLUSIVE2 = { kind: "inconclusive" };
-var SPECIALIZATION_KINDS6 = /* @__PURE__ */ new Set([":>", "specializes", ":>>", "redefines", "subsets"]);
+var SPECIALIZATION_KINDS8 = /* @__PURE__ */ new Set([":>", "specializes", ":>>", "redefines", "subsets"]);
 var MAX_SPECIALIZATION_DEPTH = 32;
 var MAX_VALUE_DEPTH = 16;
 function evaluateFilterCondition(condition, element, options) {
@@ -180617,7 +181663,7 @@ function declaresFeature2(node, name) {
   if (node.name === name)
     return true;
   for (const rel2 of [...node.preRelationships ?? [], ...node.relationships ?? []]) {
-    if (rel2.kind && SPECIALIZATION_KINDS6.has(rel2.kind) && (rel2.targets ?? []).includes(name))
+    if (rel2.kind && SPECIALIZATION_KINDS8.has(rel2.kind) && (rel2.targets ?? []).includes(name))
       return true;
   }
   return false;
@@ -180739,7 +181785,7 @@ function specializes(node, type, ctx, depth = 0, seen = /* @__PURE__ */ new Set(
 function metaclassMatches(type, ctx) {
   if (!ctx.element)
     return false;
-  const metaclass = metaclassNameOf(ctx.element);
+  const metaclass = effectiveMetaclassNameOf(ctx.element, ctx);
   const written = type.$refText;
   if (!written)
     return false;
@@ -180748,6 +181794,34 @@ function metaclassMatches(type, ctx) {
   const definition = ctx.options.resolveName?.(`SysML::${metaclass}`) ?? ctx.options.resolveName?.(metaclass);
   return specializes(definition, type, ctx);
 }
+function effectiveMetaclassNameOf(node, ctx) {
+  if (!isKeywordlessDeclaration(node))
+    return metaclassNameOf(node);
+  const resolve8 = (name) => ctx.options.resolveName?.(name);
+  const annotations = [];
+  for (const usage of metadataUsagesAnnotating(node)) {
+    const type = metadataTypeNodeOf(usage, resolve8);
+    if (!type || !semanticMetadataVerdictOf(type, resolve8).isSemantic)
+      continue;
+    const reading = baseTypeBindingsOf(type, resolve8);
+    const binding = reading.bindings[0];
+    if (!binding)
+      continue;
+    annotations.push({
+      usage,
+      type,
+      annotated: node,
+      complete: reading.complete,
+      bindings: reading.bindings,
+      base: resolveSemanticBase(binding, resolve8)
+    });
+  }
+  const kind = effectiveKindOf(node, annotations);
+  if (!kind)
+    return metaclassNameOf(node);
+  const stem = kind.declType.endsWith("Decl") ? kind.declType.slice(0, -"Decl".length) : kind.declType;
+  return `${stem}${kind.isDef ? "Definition" : "Usage"}`;
+}
 function metaclassNameOf(node) {
   if (isPackage(node))
     return "Package";
@@ -180787,7 +181861,7 @@ function nameScope(ctx, depth = 0) {
 function specializationTargets3(node) {
   const targets = [];
   for (const rel2 of [...node.preRelationships ?? [], ...node.relationships ?? []]) {
-    if (rel2.kind && SPECIALIZATION_KINDS6.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS8.has(rel2.kind))
       targets.push(...rel2.targets ?? []);
   }
   return targets;
@@ -181041,7 +182115,7 @@ function selectMemberships(path10, form, globalDescriptions) {
   const index2 = GlobalDescriptionIndex.from(globalDescriptions);
   const entries = [];
   if (form.includesSelf) {
-    const simple = simpleNameOf2(path10);
+    const simple = simpleNameOf3(path10);
     const self2 = index2.named(path10).find((desc) => form.importAll || !isPrivateDescription(desc));
     if (self2)
       entries.push({ name: simple, targetName: self2.name, description: self2 });
@@ -181060,7 +182134,7 @@ function selectMemberships(path10, form, globalDescriptions) {
   }
   return entries;
 }
-function simpleNameOf2(path10) {
+function simpleNameOf3(path10) {
   return path10.includes("::") ? path10.slice(path10.lastIndexOf("::") + 2) : path10;
 }
 function isOwnedMembership(desc) {
@@ -181483,332 +182557,6 @@ function compositionProblemsOf(node, resolve8) {
   return problems;
 }
 
-// ../language-server/out/src/services/metadata-semantics.js
-var MAX_DEPTH = 32;
-var SPECIALIZATION_KINDS7 = /* @__PURE__ */ new Set([
-  ":>",
-  "specializes",
-  ":>>",
-  "redefines",
-  "subsets"
-]);
-var REDEFINITION_KINDS4 = /* @__PURE__ */ new Set([":>>", "redefines"]);
-var STRUCTURAL_FEATURE_NAMES = /* @__PURE__ */ new Set(["self", "annotatedElement"]);
-var ANNOTATED_ELEMENT = "annotatedElement";
-function isMetadataUsage(node) {
-  if (node.$type === "MetadataAnnotation")
-    return true;
-  return node.$type === "MetadataDecl" && node.isDef !== true;
-}
-function isMetadataPrefixTag(node) {
-  return node.$type === "PrefixMetadataTag";
-}
-function metadataTypeNamesOf(node) {
-  const usage = node;
-  const names = [];
-  const add = (text) => {
-    const trimmed = text?.trim();
-    if (trimmed)
-      names.push(trimmed);
-  };
-  add((usage.type ?? usage.typing?.type)?.$refText);
-  for (const more of usage.typing?.moreTypes ?? [])
-    add(more.$refText);
-  for (const typing of usage.moreTypings ?? []) {
-    add(typing.type?.$refText);
-    for (const more of typing.moreTypes ?? [])
-      add(more.$refText);
-  }
-  return names;
-}
-function metadataTypeNodeOf(node, resolve8) {
-  const usage = node;
-  const reference = usage.type ?? usage.typing?.type;
-  if (reference?.ref)
-    return reference.ref;
-  const written = reference?.$refText?.trim();
-  return written ? resolve8(written, node) : void 0;
-}
-function metadataBindingsOf(node) {
-  const bindings = [];
-  for (const member of node.members ?? []) {
-    if (NON_BINDING_MEMBER_TYPES.has(member.$type))
-      continue;
-    const redefined = redefinedNameOf2(member);
-    if (redefined) {
-      bindings.push({ name: redefined, form: "redefinition", node: member, value: member.value });
-      continue;
-    }
-    if (member.name) {
-      bindings.push({ name: member.name, form: "shorthand", node: member, value: member.value });
-    }
-  }
-  return bindings;
-}
-var NON_BINDING_MEMBER_TYPES = /* @__PURE__ */ new Set([
-  "DocCommentMember",
-  "CommentStmt",
-  "RepStmt",
-  "MetadataAnnotation",
-  "PrefixMetadataMember",
-  "Import",
-  "AliasDecl",
-  "FilterMember"
-]);
-function redefinedNameOf2(member) {
-  for (const relationship of [...member.preRelationships ?? [], ...member.relationships ?? []]) {
-    if (!relationship.kind || !REDEFINITION_KINDS4.has(relationship.kind))
-      continue;
-    const target = (relationship.targets ?? [])[0];
-    const simple = target?.split(/::|\./u).pop()?.trim();
-    if (simple)
-      return simple;
-  }
-  return void 0;
-}
-function metadataFeaturesOf(type, resolve8, implicitBaseNames = () => []) {
-  const features = /* @__PURE__ */ new Map();
-  const inherited = new Set(STRUCTURAL_FEATURE_NAMES);
-  const seen = /* @__PURE__ */ new Set();
-  let complete = true;
-  const collectNames = (owner, depth, visited) => {
-    if (!owner || depth > MAX_DEPTH || visited.has(owner))
-      return;
-    visited.add(owner);
-    for (const member of owner.members ?? []) {
-      const name = member.name ?? redefinedNameOf2(member);
-      if (name)
-        inherited.add(name);
-    }
-    for (const supertype of specializationTargetsOf2(owner)) {
-      collectNames(resolve8(supertype, owner), depth + 1, visited);
-    }
-  };
-  const walk = (owner, depth) => {
-    if (!owner || depth > MAX_DEPTH || seen.has(owner)) {
-      if (!owner)
-        complete = false;
-      return;
-    }
-    seen.add(owner);
-    for (const base of implicitBaseNames(owner)) {
-      collectNames(resolve8(base, owner), 0, /* @__PURE__ */ new Set());
-    }
-    for (const member of owner.members ?? []) {
-      if (!isFeatureMember(member))
-        continue;
-      const name = member.name ?? redefinedNameOf2(member);
-      if (!name)
-        continue;
-      const known2 = features.get(name);
-      if (known2) {
-        if (suppliedValueOf(member) !== void 0) {
-          known2.hasDefault = true;
-          known2.required = false;
-        }
-        continue;
-      }
-      features.set(name, {
-        name,
-        node: member,
-        typeName: writtenTypeNameOf(member),
-        hasDefault: suppliedValueOf(member) !== void 0,
-        required: isRequiredFeature(member)
-      });
-    }
-    for (const supertype of specializationTargetsOf2(owner)) {
-      const resolved = resolve8(supertype, owner);
-      if (!resolved) {
-        complete = false;
-        continue;
-      }
-      walk(resolved, depth + 1);
-    }
-  };
-  if (!type)
-    return { features: [], inherited, complete: false };
-  walk(type, 0);
-  return { features: [...features.values()], inherited, complete };
-}
-function isFeatureMember(member) {
-  if (NON_BINDING_MEMBER_TYPES.has(member.$type))
-    return false;
-  if (member.$type === "MetadataDecl" && member.isDef === true)
-    return false;
-  return member.name !== void 0 || redefinedNameOf2(member) !== void 0;
-}
-function writtenTypeNameOf(member) {
-  const written = member.typing?.type?.$refText?.trim();
-  return written && written.length > 0 ? written : void 0;
-}
-function suppliedValueOf(member) {
-  return member.value ?? member.default?.value;
-}
-function isRequiredFeature(member) {
-  if (suppliedValueOf(member) !== void 0)
-    return false;
-  if ((member.modifiers ?? []).includes("abstract"))
-    return false;
-  if (STRUCTURAL_FEATURE_NAMES.has(member.name ?? ""))
-    return false;
-  if (STRUCTURAL_FEATURE_NAMES.has(redefinedNameOf2(member) ?? ""))
-    return false;
-  const lower2 = member.multiplicity?.lower;
-  if (!lower2)
-    return true;
-  if (lower2.star === true)
-    return false;
-  if (lower2.intVal === void 0)
-    return false;
-  return lower2.intVal >= 1;
-}
-function annotatedElementRestrictionsOf(type, resolve8) {
-  const restrictions = [];
-  const seen = /* @__PURE__ */ new Set();
-  const walk = (owner, depth) => {
-    if (!owner || depth > MAX_DEPTH || seen.has(owner))
-      return;
-    seen.add(owner);
-    for (const member of owner.members ?? []) {
-      const binds = member.name === ANNOTATED_ELEMENT || redefinedNameOf2(member) === ANNOTATED_ELEMENT || subsetTargetsOf(member).includes(ANNOTATED_ELEMENT);
-      if (!binds)
-        continue;
-      const typeName = writtenTypeNameOf(member);
-      if (typeName) {
-        restrictions.push({ typeName, node: member, owner, resolvedType: resolve8(typeName, member) });
-      }
-    }
-    for (const supertype of specializationTargetsOf2(owner))
-      walk(resolve8(supertype, owner), depth + 1);
-  };
-  walk(type, 0);
-  return restrictions;
-}
-function subsetTargetsOf(member) {
-  const targets = [];
-  for (const relationship of [...member.preRelationships ?? [], ...member.relationships ?? []]) {
-    if (relationship.kind !== ":>" && relationship.kind !== "subsets")
-      continue;
-    for (const target of relationship.targets ?? []) {
-      const simple = target.split(/::|\./u).pop()?.trim();
-      if (simple)
-        targets.push(simple);
-    }
-  }
-  return targets;
-}
-function metadataTargetsOf(node, resolve8) {
-  const usage = node;
-  const written = usage.targets ?? [];
-  if (written.length > 0) {
-    return written.map((text, occurrence) => ({
-      text: text.trim(),
-      node: resolve8(text.trim(), occurrence),
-      explicit: true
-    }));
-  }
-  const owner = annotatedOwnerOf(node);
-  if (!owner)
-    return [];
-  return [{ text: owner.name ?? owner.$type, node: owner, explicit: false }];
-}
-function annotatedOwnerOf(node) {
-  const container = node.$container;
-  if (container?.$type === "PrefixMetadataMember") {
-    return container.element;
-  }
-  if (!container)
-    return void 0;
-  if (!NON_ANNOTATED_CONTAINERS.has(container.$type))
-    return container;
-  if (node.$type !== "MetadataAnnotation")
-    return void 0;
-  return followingDeclarationOf(node, container);
-}
-function followingDeclarationOf(node, container) {
-  const members = container.members ?? container.elements ?? [];
-  const index2 = members.indexOf(node);
-  if (index2 < 0)
-    return void 0;
-  for (let next = index2 + 1; next < members.length; next += 1) {
-    const candidate = members[next];
-    if (candidate.$type === "MetadataAnnotation")
-      continue;
-    return candidate;
-  }
-  return void 0;
-}
-var NON_ANNOTATED_CONTAINERS = /* @__PURE__ */ new Set(["Document", "Package", "NamespaceDecl"]);
-function valueEvaluability(value, resolve8) {
-  if (!value)
-    return "unknown";
-  let verdict = "model-level";
-  for (const node of [value, ...ast_utils_exports.streamAllContents(value)]) {
-    if (node.$type !== "PathExpr")
-      continue;
-    const written = pathTextOf(node);
-    if (!written)
-      return "unknown";
-    const segments = written.split(/::|\./u).map((segment) => segment.trim()).filter(Boolean);
-    const root4 = segments.length > 0 ? resolve8(segments[0], node) : void 0;
-    if (root4 && isOccurrenceUsage(root4))
-      return "instance-level";
-    if (segments.length > 1) {
-      if (!root4)
-        return "unknown";
-      continue;
-    }
-    const target = resolve8(written, node);
-    if (!target)
-      return "unknown";
-    if (referentEvaluability(target) === "unknown")
-      verdict = "unknown";
-  }
-  return verdict;
-}
-function pathTextOf(node) {
-  const text = node.$cstNode?.text?.trim();
-  return text && text.length > 0 ? text : void 0;
-}
-function referentEvaluability(target) {
-  if (isOwnedEnumerationValue(target))
-    return "model-level";
-  const node = target;
-  if (node.isDef === true)
-    return "model-level";
-  if (node.value !== void 0)
-    return "model-level";
-  return isOccurrenceUsage(node) ? "instance-level" : "unknown";
-}
-function isOccurrenceUsage(node) {
-  return node.isDef !== true && OCCURRENCE_USAGE_TYPES.has(node.$type);
-}
-var OCCURRENCE_USAGE_TYPES = /* @__PURE__ */ new Set([
-  "PartDecl",
-  "ItemDecl",
-  "PortDecl",
-  "ActionDecl",
-  "StateDecl",
-  "OccurrenceDecl",
-  "ConnectionDecl",
-  "InterfaceDecl",
-  "AllocationDecl",
-  "EventDecl"
-]);
-function specializationTargetsOf2(node) {
-  const owner = node;
-  const targets = [];
-  for (const relationship of [...owner.preRelationships ?? [], ...owner.relationships ?? []]) {
-    if (relationship.kind && SPECIALIZATION_KINDS7.has(relationship.kind)) {
-      targets.push(...relationship.targets ?? []);
-    }
-  }
-  const typed = owner.typing?.type?.$refText;
-  if (typed)
-    targets.push(typed);
-  return targets.map((target) => target.trim()).filter((target) => target.length > 0);
-}
-
 // ../language-server/out/src/services/validator.js
 var REDEFINITION_KINDS5 = /* @__PURE__ */ new Set([
   ":>>",
@@ -181904,7 +182652,7 @@ function maskNonCode(text) {
   }
   return out.join("");
 }
-var SPECIALIZATION_KINDS8 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS9 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 var CONSTRAINT_SIDE_EFFECT_TYPES = /* @__PURE__ */ new Set([
   "AssignNode",
   "SendNode",
@@ -182094,6 +182842,10 @@ var SysmlValidator = class _SysmlValidator {
   // declaration without pulling its document into `LangiumDocuments`, so the
   // metadata resolver goes through it rather than a second loader.
   linker;
+  // issue #169 - one semantic-metadata model per parsed document root. Keyed
+  // on the root rather than the URI, so a rebuild (which makes a new root)
+  // cannot be answered from the previous generation's annotations.
+  semanticModels = /* @__PURE__ */ new WeakMap();
   constructor(services) {
     this.serviceRegistry = services.shared.ServiceRegistry;
     this.linker = services.references.Linker;
@@ -183557,7 +184309,7 @@ ${baseIndent}}`;
           accept(severity("SYN019", "error"), DIAGNOSTIC_MESSAGES.SYN019_ABSTRACT_VARIATION, { node: child, code: "SYN019" });
         }
         for (const relation of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
-          if (!relation.kind || !SPECIALIZATION_KINDS8.has(relation.kind))
+          if (!relation.kind || !SPECIALIZATION_KINDS9.has(relation.kind))
             continue;
           for (let index2 = 0; index2 < (relation.targets?.length ?? 0); index2 += 1) {
             const resolution = this.featurePaths.resolvePropertyPath(relation, "targets", index2);
@@ -183917,6 +184669,7 @@ ${baseIndent}}`;
     const satisfyStmts = [];
     const includeStmts = [];
     const metadataUsages = [];
+    const metadataDefinitions = [];
     const aliasMap = /* @__PURE__ */ new Map();
     for (const child of ast_utils_exports.streamAllContents(node)) {
       if (isImport(child)) {
@@ -183944,6 +184697,8 @@ ${baseIndent}}`;
         includeStmts.push(child);
       if (isMetadataUsage(child) || isMetadataPrefixTag(child))
         metadataUsages.push(child);
+      if (isMetadataDefinition(child))
+        metadataDefinitions.push(child);
     }
     this.checkAmbiguousReferences(node, imports, index2, accept);
     this.checkPrivateImports(imports, index2, accept);
@@ -183979,7 +184734,7 @@ ${baseIndent}}`;
       this.checkInverseOfTargets(decl, index2, accept);
       this.checkTypeComposition(decl, index2, accept);
     }
-    this.checkTypeConformance(decls, satisfyStmts, includeStmts, metadataUsages, index2, accept);
+    this.checkTypeConformance(node, decls, satisfyStmts, includeStmts, metadataUsages, metadataDefinitions, index2, accept);
   }
   // ══════════════════════════════════════════════════════════════════════
   // REQ-390 — SSM017-SSM021: whole-model type conformance (issue #104)
@@ -183989,7 +184744,7 @@ ${baseIndent}}`;
   // the walk, so a type rooted in the unparsed standard library yields
   // `unknown` and no diagnostic. That is what keeps the OMG corpus clean while
   // still catching the workspace-local mistakes these codes exist for.
-  checkTypeConformance(decls, satisfyStmts, includeStmts, metadataUsages, index2, accept) {
+  checkTypeConformance(root4, decls, satisfyStmts, includeStmts, metadataUsages, metadataDefinitions, index2, accept) {
     const model = new ConformanceModel((name) => this.resolveUnique(name, index2), (node) => this.implicit?.closureOf(node) ?? { names: /* @__PURE__ */ new Set(), complete: true });
     for (const decl of decls) {
       this.checkRedefinitionTypeConformance(decl, model, index2, accept);
@@ -184013,6 +184768,94 @@ ${baseIndent}}`;
       this.checkIncludeBindings(stmt, model, index2, accept);
     if (metadataUsages.length > 0)
       this.checkMetadataUsages(metadataUsages, index2, accept);
+    if (metadataDefinitions.length > 0 || metadataUsages.length > 0) {
+      this.checkSemanticMetadata(root4, metadataDefinitions, index2, accept);
+    }
+  }
+  // ══════════════════════════════════════════════════════════════════════
+  // REQ-420 - SSM056-SSM061: SemanticMetadata and user-defined keywords
+  // (issue #169)
+  // ══════════════════════════════════════════════════════════════════════
+  /**
+   * REQ-420 - OMG SysML v2 Part 1 §7.27.4. A metadata definition that
+   * specializes `SemanticMetadata` gives every element it annotates a base
+   * type, and the tag becomes a user-defined keyword: `#subsystem engine;` IS
+   * `part engine :> subsystems;`.
+   *
+   * Two groups of check, judged where each belongs. SSM056-SSM059 are about
+   * the DEFINITION - it states no base type, one that cannot be read, one that
+   * is not a type, or two that contradict each other - and are reported on the
+   * definition, once, however many elements it tags. SSM060 and SSM061 are
+   * about one ANNOTATION and are reported on it.
+   *
+   * Every one of them is three-valued like the rest of the family: a hierarchy
+   * this workspace could not walk whole reports nothing, because the supertype
+   * it could not read is exactly where the missing binding would have been.
+   */
+  // REQ-420 — SemanticMetadata and user-defined keyword specialization
+  checkSemanticMetadata(root4, definitions, index2, accept) {
+    const resolve8 = (name, from) => this.resolveMetadataName(name, index2, from);
+    for (const definition of definitions) {
+      const verdict = semanticMetadataVerdictOf(definition, resolve8);
+      if (!verdict.isSemantic || !verdict.complete)
+        continue;
+      const optional2 = statesOwnBaseTypeOptionally(definition);
+      const reading = baseTypeBindingsOf(definition, resolve8);
+      if (!reading.complete)
+        continue;
+      const name = definition.name ?? "this metadata definition";
+      const [first2, second] = reading.bindings;
+      if (!first2) {
+        if (optional2)
+          continue;
+        accept(severity("SSM056", "error"), DIAGNOSTIC_MESSAGES.SSM056_SEMANTIC_BASE_TYPE_MISSING(name), { node: definition, code: "SSM056" });
+        continue;
+      }
+      if (second && second.owner === first2.owner && second.written !== first2.written) {
+        accept(severity("SSM059", "error"), DIAGNOSTIC_MESSAGES.SSM059_SEMANTIC_BASE_TYPE_CONFLICT(name, first2.written, second.written), { node: first2.node, code: "SSM059" });
+      }
+      const base = resolveSemanticBase(first2, resolve8);
+      if (base.unresolved && !/::|\./u.test(first2.written)) {
+        accept(severity("SSM057", "error"), DIAGNOSTIC_MESSAGES.SSM057_SEMANTIC_BASE_TYPE_UNRESOLVED(name, first2.written), { node: first2.node, code: "SSM057" });
+      } else if (base.form === "not-a-type" && base.node) {
+        accept(severity("SSM058", "error"), DIAGNOSTIC_MESSAGES.SSM058_SEMANTIC_BASE_TYPE_NOT_A_TYPE(name, first2.written, metaclassNameOf(base.node)), { node: first2.node, code: "SSM058" });
+      }
+    }
+    const model = this.semanticMetadataModel(root4, index2);
+    for (const element of model.annotatedElements()) {
+      for (const annotation of model.annotationsOf(element)) {
+        if (!annotation.complete || !annotation.base || annotation.base.unresolved)
+          continue;
+        const typeName = metadataTypeNamesOf(annotation.usage)[0] ?? "this metadata definition";
+        const targetName = element.name ?? metaclassNameOf(element);
+        if (semanticFormOf(element) === "not-a-type") {
+          accept(severity("SSM060", "error"), DIAGNOSTIC_MESSAGES.SSM060_SEMANTIC_TARGET_NOT_A_TYPE(typeName, targetName, metaclassNameOf(element)), { node: annotation.usage, code: "SSM060" });
+          continue;
+        }
+        if (annotation.edge && model.isCyclicBase(element, annotation.base)) {
+          accept(severity("SSM061", "error"), DIAGNOSTIC_MESSAGES.SSM061_SEMANTIC_BASE_TYPE_CYCLIC(targetName, annotation.base.binding.written), { node: annotation.usage, code: "SSM061" });
+        }
+      }
+    }
+  }
+  /**
+   * REQ-420 - the document's semantic-metadata model, built once.
+   *
+   * Reading one annotation walks its definition's whole supertype hierarchy,
+   * so a file that tags fifty parts with one keyword must not walk it fifty
+   * times. The `about` targets go through the resolver that owns written paths
+   * and knows the scope each usage sits in, exactly as `SSM055` reads them.
+   */
+  semanticMetadataModel(root4, index2) {
+    const cached = this.semanticModels.get(root4);
+    if (cached)
+      return cached;
+    const model = new SemanticMetadataModel((name, from) => this.resolveMetadataName(name, index2, from), (usage, _text, occurrence) => {
+      const candidates = this.featurePaths.resolvePropertyPathCandidates(usage, "targets", occurrence);
+      return candidates.length === 1 ? candidates[0] : void 0;
+    }).build(root4);
+    this.semanticModels.set(root4, model);
+    return model;
   }
   // ══════════════════════════════════════════════════════════════════════
   // REQ-419 - SSM049-SSM055: metadata bindings and applicability (issue #168)
@@ -185774,7 +186617,7 @@ function specializationTargets4(node) {
     ...node.relationships ?? []
   ];
   for (const rel2 of rels) {
-    if (rel2.kind && SPECIALIZATION_KINDS8.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS9.has(rel2.kind))
       out.push(...rel2.targets);
   }
   return out;
@@ -186559,12 +187402,12 @@ function importSignature(imp) {
   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_KINDS9 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS10 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 function specializationTargets5(node) {
   const n2 = node;
   const out = [];
   for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
-    if (rel2.kind && SPECIALIZATION_KINDS9.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS10.has(rel2.kind))
       out.push(...rel2.targets ?? []);
   }
   return out;
@@ -186854,12 +187697,12 @@ function directImportEntries(imp, descriptions) {
   }
   return applyFilters(imp, selectMemberships(path10, form, descriptions), options);
 }
-var SPECIALIZATION_KINDS10 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS11 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 function specializationTargets6(node) {
   const value = node;
   const targets = [];
   for (const relationship of [...value.preRelationships ?? [], ...value.relationships ?? []]) {
-    if (relationship.kind && SPECIALIZATION_KINDS10.has(relationship.kind)) {
+    if (relationship.kind && SPECIALIZATION_KINDS11.has(relationship.kind)) {
       targets.push(...relationship.targets ?? []);
     }
   }
@@ -188703,7 +189546,7 @@ var CallableResolver = class {
    * candidate only when it is the ONLY element with that name.
    */
   candidates(name) {
-    const simple = simpleNameOf(name);
+    const simple = simpleNameOf2(name);
     return (this.lookup?.descriptions(simple) ?? []).filter((description) => CALLABLE_TYPES.has(description.type));
   }
   /**
@@ -188719,7 +189562,7 @@ var CallableResolver = class {
     const root4 = document2.parseResult?.value;
     if (!root4)
       return void 0;
-    return collectCallables([root4, ...ast_utils_exports.streamAllContents(root4).toArray()]).get(unquoteName(simpleNameOf(name)));
+    return collectCallables([root4, ...ast_utils_exports.streamAllContents(root4).toArray()]).get(unquoteName(simpleNameOf2(name)));
   }
   /**
    * SYNCHRONOUS resolution: a qualified spelling the index holds verbatim,
@@ -188735,7 +189578,7 @@ var CallableResolver = class {
       if (node)
         return node;
     }
-    const found = local ? local(unquoteName(simpleNameOf(name))) : this.findLocal(document2, name);
+    const found = local ? local(unquoteName(simpleNameOf2(name))) : this.findLocal(document2, name);
     if (found)
       return found;
     const candidate = this.uniqueCandidate(name);
@@ -213550,7 +214393,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.42.0" : "dev";
+var VERSION2 = true ? "0.43.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;