sysml-diagram 0.41.0 → 0.42.0

package/out/main.js

@@ -177829,6 +177829,28 @@ var DIAGNOSTIC_MESSAGES = {
   // include binds one of the included use case's actor parameters.
   SSM047_INCLUDE_SUBJECT_TYPE: (included, includedType, containerType) => `Included use case '${included}' has a subject of type '${includedType}', which does not conform to the including case's subject of type '${containerType}'. An included use case is investigated on the same subject.`,
   SSM048_INCLUDE_ACTOR_BINDING: (actor, included, known2) => `'${actor}' is not an actor parameter of the included use case '${included}'. It declares ${known2}.`,
+  // issue #168 - a metadata usage annotates an element with ONE metadata
+  // definition or metaclass (OMG SysML v2 Part 1 §7.27.1). A second type has
+  // no place to put its own feature values, so the body becomes unreadable.
+  SSM049_METADATA_MULTIPLE_TYPES: (first2, second) => `A metadata usage names more than one type ('${first2}' and '${second}'). A metadata usage applies exactly one metadata definition or metaclass, so keep one and write the other as a second annotation.`,
+  // issue #168 - a feature the metadata definition declares without a
+  // multiplicity is required, and nothing else can supply its value: the
+  // annotation IS the place the model states it.
+  SSM050_METADATA_BINDING_MISSING: (type, features) => `This '${type}' annotation binds no value for ${features}. A metadata feature with no multiplicity is required, so give it a value in the body or declare it '[0..1]' on the definition.`,
+  // issue #168 - two members that name one feature state two values for it.
+  SSM051_METADATA_BINDING_DUPLICATE: (feature, type) => `'${feature}' is bound twice in this '${type}' annotation. A metadata feature takes one value, so remove one of the two members.`,
+  // issue #168 - a body member with no `ref` and no `:>>` redefines the
+  // same-named feature of the metadata type (§7.27.2), so a name the type does
+  // not declare redefines nothing and its value is never read.
+  SSM052_METADATA_FEATURE_UNKNOWN: (feature, type, known2) => `'${feature}' is not a feature of the metadata definition '${type}'. It declares ${known2}.`,
+  // issue #168 - metadata is part of the model's own syntax, so its values
+  // have to be readable without instances.
+  SSM053_METADATA_VALUE_NOT_MODEL_LEVEL: (feature, written) => `The value bound to '${feature}' reads '${written}', which exists only once the model is instantiated. A metadata value must be readable from the model alone, so use a literal, an enumeration value, or a feature that carries one.`,
+  SSM054_METADATA_VALUE_TYPE: (feature, valueType, featureType) => `'${feature}' is typed '${featureType}', but the value bound to it is a '${valueType}'. Bind a value of the feature's own type.`,
+  // issue #168 - `metadata def Classified { ref :>> annotatedElement : SysML::Usage; }`
+  // 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'.`,
   // 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.
@@ -181461,8 +181483,334 @@ 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_KINDS4 = /* @__PURE__ */ new Set([
+var REDEFINITION_KINDS5 = /* @__PURE__ */ new Set([
   ":>>",
   "redefines",
   ":>",
@@ -181556,7 +181904,7 @@ function maskNonCode(text) {
   }
   return out.join("");
 }
-var SPECIALIZATION_KINDS7 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS8 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 var CONSTRAINT_SIDE_EFFECT_TYPES = /* @__PURE__ */ new Set([
   "AssignNode",
   "SendNode",
@@ -181685,6 +182033,18 @@ function owningTypeOf(node) {
     return void 0;
   return NAMESPACE_ONLY_TYPES.has(owner.$type) ? void 0 : owner;
 }
+var MAX_LISTED_FEATURES = 8;
+function quotedList(names) {
+  return names.map((name) => `'${name}'`).join(", ");
+}
+function knownFeatureList(features) {
+  const names = features.map((feature) => feature.name);
+  if (names.length === 0)
+    return "no features";
+  if (names.length <= MAX_LISTED_FEATURES)
+    return quotedList(names);
+  return `${quotedList(names.slice(0, MAX_LISTED_FEATURES))} and ${names.length - MAX_LISTED_FEATURES} more`;
+}
 function declLabel(node, kind) {
   const name = node.name;
   return name ? `'${name}'` : `this '${kind}'`;
@@ -181727,8 +182087,16 @@ var SysmlValidator = class _SysmlValidator {
   // linker's own lazy single-file load rather than pulling the library into
   // the workspace; the model memoizes each chain for the whole session.
   implicit;
+  // REQ-419 - issue #168: the metadata checks read the SHIPPED metadata model
+  // - `Metaobjects::Metaobject::annotatedElement` and the `SysML.sysml`
+  // metaclass hierarchy - which the workspace never parses. The linker's own
+  // lazy single-file load is the one path that reads an indexed library
+  // declaration without pulling its document into `LangiumDocuments`, so the
+  // metadata resolver goes through it rather than a second loader.
+  linker;
   constructor(services) {
     this.serviceRegistry = services.shared.ServiceRegistry;
+    this.linker = services.references.Linker;
     this.indexManager = services.shared.workspace.IndexManager;
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
     this.astNodeLocator = services.workspace.AstNodeLocator;
@@ -181798,7 +182166,7 @@ var SysmlValidator = class _SysmlValidator {
   // inventory completely. A later segment depends on the KerML semantic model
   // this resolver does not evaluate.
   checkRelationshipTargets(node, accept) {
-    if (!node.kind || !REDEFINITION_KINDS4.has(node.kind))
+    if (!node.kind || !REDEFINITION_KINDS5.has(node.kind))
       return;
     for (let ordinal = 0; ordinal < node.targets.length; ordinal += 1) {
       const resolution = this.featurePaths.resolvePropertyPath(node, "targets", ordinal);
@@ -183189,7 +183557,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_KINDS7.has(relation.kind))
+          if (!relation.kind || !SPECIALIZATION_KINDS8.has(relation.kind))
             continue;
           for (let index2 = 0; index2 < (relation.targets?.length ?? 0); index2 += 1) {
             const resolution = this.featurePaths.resolvePropertyPath(relation, "targets", index2);
@@ -183548,6 +183916,7 @@ ${baseIndent}}`;
     const verifyStmts = [];
     const satisfyStmts = [];
     const includeStmts = [];
+    const metadataUsages = [];
     const aliasMap = /* @__PURE__ */ new Map();
     for (const child of ast_utils_exports.streamAllContents(node)) {
       if (isImport(child)) {
@@ -183573,6 +183942,8 @@ ${baseIndent}}`;
       }
       if (child.$type === "IncludeStmt")
         includeStmts.push(child);
+      if (isMetadataUsage(child) || isMetadataPrefixTag(child))
+        metadataUsages.push(child);
     }
     this.checkAmbiguousReferences(node, imports, index2, accept);
     this.checkPrivateImports(imports, index2, accept);
@@ -183608,7 +183979,7 @@ ${baseIndent}}`;
       this.checkInverseOfTargets(decl, index2, accept);
       this.checkTypeComposition(decl, index2, accept);
     }
-    this.checkTypeConformance(decls, satisfyStmts, includeStmts, index2, accept);
+    this.checkTypeConformance(decls, satisfyStmts, includeStmts, metadataUsages, index2, accept);
   }
   // ══════════════════════════════════════════════════════════════════════
   // REQ-390 — SSM017-SSM021: whole-model type conformance (issue #104)
@@ -183618,7 +183989,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, index2, accept) {
+  checkTypeConformance(decls, satisfyStmts, includeStmts, metadataUsages, 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);
@@ -183640,6 +184011,189 @@ ${baseIndent}}`;
       this.checkSatisfierSubjectType(stmt, model, index2, accept);
     for (const stmt of includeStmts)
       this.checkIncludeBindings(stmt, model, index2, accept);
+    if (metadataUsages.length > 0)
+      this.checkMetadataUsages(metadataUsages, index2, accept);
+  }
+  // ══════════════════════════════════════════════════════════════════════
+  // REQ-419 - SSM049-SSM055: metadata bindings and applicability (issue #168)
+  // ══════════════════════════════════════════════════════════════════════
+  /**
+   * REQ-419 - a name resolved for the metadata family, INCLUDING the standard
+   * library.
+   *
+   * `resolveUnique` reads the workspace, where a description carries a live
+   * node. Every metadata question reaches past it - `annotatedElement` is
+   * declared in `Metaobjects.kerml` and the metaclass hierarchy in
+   * `SysML.sysml` - and those documents are served from the precomputed index
+   * with no parse behind them. The index holds one description PER SPELLING of
+   * the same element (`PartUsage`, `SysML::PartUsage`, …), so the entries are
+   * deduplicated by document and path first: a name is ambiguous only when it
+   * reaches two different elements, and a single element is then read through
+   * the linker's lazy single-file load.
+   */
+  resolveMetadataName(name, index2, from) {
+    if (from) {
+      const scoped = this.featurePaths.resolveVisibleNameCandidates(from, name);
+      if (scoped.length === 1)
+        return scoped[0];
+    }
+    const direct = this.resolveUnique(name, index2);
+    if (direct)
+      return direct;
+    const normalized = name.trim();
+    let descs = index2.get(normalized);
+    if (!descs || descs.length === 0) {
+      const simple = normalized.split(/::|\./u).pop();
+      descs = simple ? index2.get(simple) : void 0;
+    }
+    if (!descs || descs.length === 0)
+      return void 0;
+    const unique = /* @__PURE__ */ new Map();
+    for (const desc of descs)
+      unique.set(`${String(desc.documentUri)}#${desc.path}`, desc);
+    if (unique.size !== 1)
+      return void 0;
+    const only = [...unique.values()][0];
+    return this.nodeOf(only) ?? this.linker?.resolveIndexedNode(only);
+  }
+  checkMetadataUsages(usages, index2, accept) {
+    const resolve8 = (name, from) => this.resolveMetadataName(name, index2, from);
+    const root4 = usages[0] ? ast_utils_exports.getDocument(usages[0]).parseResult.value : void 0;
+    const model = new ConformanceModel((name) => this.resolveMetadataName(name, index2, root4), (node) => this.implicit?.closureOf(node) ?? { names: /* @__PURE__ */ new Set(), complete: true });
+    const inventories = /* @__PURE__ */ new Map();
+    const inventoryOf = (type) => {
+      if (!type)
+        return metadataFeaturesOf(void 0, resolve8);
+      const cached = inventories.get(type);
+      if (cached)
+        return cached;
+      const built = metadataFeaturesOf(type, resolve8, (node) => this.implicit?.closureOf(node).names ?? []);
+      inventories.set(type, built);
+      return built;
+    };
+    const restrictions = /* @__PURE__ */ new Map();
+    const restrictionsOf = (type) => {
+      const cached = restrictions.get(type);
+      if (cached)
+        return cached;
+      const built = annotatedElementRestrictionsOf(type, resolve8);
+      restrictions.set(type, built);
+      return built;
+    };
+    for (const usage of usages) {
+      if (this.checkMetadataTypeCount(usage, accept))
+        continue;
+      const type = metadataTypeNodeOf(usage, resolve8);
+      if (type)
+        this.checkMetadataTargets(usage, restrictionsOf(type), model, accept);
+      if (isMetadataPrefixTag(usage))
+        continue;
+      this.checkMetadataBindings(usage, inventoryOf(type), model, resolve8, accept);
+    }
+  }
+  // SSM049 - OMG SysML v2 Part 1 §7.27.1: a metadata usage applies ONE
+  // metadata definition or metaclass. The grammar accepts a second type
+  // because `MetadataTyping` shares its shape with the general typing rule,
+  // and a body that binds a feature would then have two types to redefine
+  // against. `SSM022` already judges the KIND of the type; this judges how
+  // many there are.
+  checkMetadataTypeCount(usage, accept) {
+    const names = metadataTypeNamesOf(usage);
+    if (names.length < 2)
+      return false;
+    accept(severity("SSM049", "error"), DIAGNOSTIC_MESSAGES.SSM049_METADATA_MULTIPLE_TYPES(names[0], names[1]), { node: usage, code: "SSM049" });
+    return true;
+  }
+  // SSM050 / SSM051 / SSM052 / SSM053 / SSM054 - the body.
+  //
+  // Calling a written feature unknown, or a required one unbound, is a claim
+  // about what the metadata type does NOT have, so both need its complete
+  // feature inventory: a supertype this workspace could not read makes the
+  // claim unsound. A duplicate binding and a value fault are claims about what
+  // the body itself says, so they stand on the body alone.
+  checkMetadataBindings(usage, inventory, model, resolve8, accept) {
+    const bindings = metadataBindingsOf(usage);
+    const typeName = metadataTypeNamesOf(usage)[0] ?? "this metadata definition";
+    const bound = /* @__PURE__ */ new Map();
+    for (const binding of bindings) {
+      const first2 = bound.get(binding.name);
+      if (!first2) {
+        bound.set(binding.name, binding);
+        continue;
+      }
+      if (first2.form !== "redefinition" && binding.form !== "redefinition")
+        continue;
+      accept(severity("SSM051", "error"), DIAGNOSTIC_MESSAGES.SSM051_METADATA_BINDING_DUPLICATE(binding.name, typeName), { node: binding.node, code: "SSM051" });
+    }
+    const features = new Map(inventory.features.map((feature) => [feature.name, feature]));
+    for (const binding of bindings) {
+      const feature = features.get(binding.name);
+      if (!feature) {
+        if (!inventory.complete || inventory.inherited.has(binding.name))
+          continue;
+        accept(severity("SSM052", "error"), DIAGNOSTIC_MESSAGES.SSM052_METADATA_FEATURE_UNKNOWN(binding.name, typeName, knownFeatureList(inventory.features)), { node: binding.node, code: "SSM052" });
+        continue;
+      }
+      if (!binding.value)
+        continue;
+      if (valueEvaluability(binding.value, resolve8) === "instance-level") {
+        accept(severity("SSM053", "warning"), DIAGNOSTIC_MESSAGES.SSM053_METADATA_VALUE_NOT_MODEL_LEVEL(binding.name, binding.value.$cstNode?.text.trim() ?? binding.name), { node: binding.value, code: "SSM053" });
+        continue;
+      }
+      this.checkMetadataValueType(binding, feature.typeName, model, accept);
+    }
+    if (!inventory.complete)
+      return;
+    const missing = inventory.features.filter((feature) => feature.required && !bound.has(feature.name)).map((feature) => feature.name);
+    if (missing.length === 0)
+      return;
+    accept(severity("SSM050", "warning"), DIAGNOSTIC_MESSAGES.SSM050_METADATA_BINDING_MISSING(typeName, quotedList(missing)), { node: usage, code: "SSM050" });
+  }
+  // SSM054 - the shape of a bound value against the feature it binds. This is
+  // the SSM019 question asked where SSM019 cannot reach: a body member written
+  // as `level = "high";` declares no type of its own, so the type it has to
+  // match is the one the metadata definition gives the feature it redefines. A
+  // member that DOES write its own type is left to SSM019, which already reads
+  // it, rather than reported twice.
+  checkMetadataValueType(binding, featureTypeName, model, accept) {
+    if (!featureTypeName || !binding.value)
+      return;
+    if (soleDeclaredType(binding.node))
+      return;
+    const expected = model.literalKindAccepted(featureTypeName);
+    if (!expected)
+      return;
+    const actual = expressionKindOf(binding.value);
+    if (!actual || actual === expected)
+      return;
+    accept(severity("SSM054", "error"), DIAGNOSTIC_MESSAGES.SSM054_METADATA_VALUE_TYPE(binding.name, actual, featureTypeName), { node: binding.value, code: "SSM054" });
+  }
+  // SSM055 - applicability. `metadata def Classified { ref :>> annotatedElement
+  // : SysML::Usage; }` narrows the `annotatedElement` every `Metaobject`
+  // carries, and both an explicit `about` target and the element an untargeted
+  // usage sits on bind it. The comparison is between the target's METACLASS -
+  // `part x` is a `PartUsage` - and the restriction, walked through the
+  // reflective metaclass model the library ships.
+  checkMetadataTargets(usage, restrictions, model, accept) {
+    if (restrictions.length === 0)
+      return;
+    if (restrictions.some((restriction) => !restriction.resolvedType))
+      return;
+    const typeName = metadataTypeNamesOf(usage)[0] ?? "this metadata definition";
+    const allowed = [...new Set(restrictions.map((restriction) => simpleTypeName(restriction.typeName)))];
+    const targets = metadataTargetsOf(usage, (_text, occurrence) => {
+      const candidates = this.featurePaths.resolvePropertyPathCandidates(usage, "targets", occurrence);
+      return candidates.length === 1 ? candidates[0] : void 0;
+    });
+    for (const target of targets) {
+      if (!target.node)
+        continue;
+      const metaclass = metaclassNameOf(target.node);
+      const verdicts = restrictions.map((restriction) => model.conforms(metaclass, restriction.typeName));
+      if (verdicts.some((verdict) => verdict !== "unrelated"))
+        continue;
+      accept(severity("SSM055", "error"), DIAGNOSTIC_MESSAGES.SSM055_METADATA_TARGET_NOT_APPLICABLE(target.text, metaclass, typeName, quotedList(allowed)), { node: usage, code: "SSM055" });
+    }
   }
   // ══════════════════════════════════════════════════════════════════════
   // REQ-417 — SSM045-SSM048: the bindings a case makes (issue #166)
@@ -185220,7 +185774,7 @@ function specializationTargets4(node) {
     ...node.relationships ?? []
   ];
   for (const rel2 of rels) {
-    if (rel2.kind && SPECIALIZATION_KINDS7.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS8.has(rel2.kind))
       out.push(...rel2.targets);
   }
   return out;
@@ -186005,12 +186559,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_KINDS8 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS9 = /* @__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_KINDS8.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS9.has(rel2.kind))
       out.push(...rel2.targets ?? []);
   }
   return out;
@@ -186300,12 +186854,12 @@ function directImportEntries(imp, descriptions) {
   }
   return applyFilters(imp, selectMemberships(path10, form, descriptions), options);
 }
-var SPECIALIZATION_KINDS9 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS10 = /* @__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_KINDS9.has(relationship.kind)) {
+    if (relationship.kind && SPECIALIZATION_KINDS10.has(relationship.kind)) {
       targets.push(...relationship.targets ?? []);
     }
   }
@@ -188339,7 +188893,7 @@ function typeAnchor(node, refText) {
   }
   return void 0;
 }
-var REDEFINITION_KINDS5 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var REDEFINITION_KINDS6 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var CONSTANT_CARRYING_KINDS = /* @__PURE__ */ new Set([
   ":>",
   "subsets",
@@ -188728,7 +189282,7 @@ var SysmlInlayHintProvider = class {
       const parameter = mine[index2].node;
       if (!parameter.name || !parameter.$cstNode)
         continue;
-      if (allRelationships3(parameter).some((rel2) => rel2.kind && REDEFINITION_KINDS5.has(rel2.kind)))
+      if (allRelationships3(parameter).some((rel2) => rel2.kind && REDEFINITION_KINDS6.has(rel2.kind)))
         continue;
       const target = theirs[index2].node;
       if (!target.name || target.name === parameter.name)
@@ -188971,7 +189525,7 @@ var SysmlInlayHintProvider = class {
 function effectiveNameHint(node, resolver) {
   if (node.name || node.shortName?.name || !node.$cstNode)
     return void 0;
-  const redefinition = allRelationships3(node).find((rel2) => rel2.kind && REDEFINITION_KINDS5.has(rel2.kind) && (rel2.targets?.length ?? 0) > 0);
+  const redefinition = allRelationships3(node).find((rel2) => rel2.kind && REDEFINITION_KINDS6.has(rel2.kind) && (rel2.targets?.length ?? 0) > 0);
   if (!redefinition?.targets?.[0])
     return void 0;
   const names = effectiveNamesOf(node, resolver);
@@ -212996,7 +213550,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.41.0" : "dev";
+var VERSION2 = true ? "0.42.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;