sysml-diagram 0.31.2 → 0.32.0

package/out/main.js

@@ -164945,6 +164945,7 @@ function expressionKindOf(node) {
 }
 var ConformanceModel = class {
   resolve;
+  implicitBases;
   closures = /* @__PURE__ */ new Map();
   /**
    * @param resolve  A written type name → its declaration, or `undefined` when
@@ -164952,9 +164953,24 @@ var ConformanceModel = class {
    *   validator supplies its `resolveUnique`, so an ambiguous name is treated
    *   exactly as an unreadable one: it makes the walk incomplete rather than
    *   resolving to an arbitrary same-named element.
+   * @param implicitBases  REQ-411 — issue #161: the standard-library names a
+   *   declaration's KEYWORD contributes, which the source never writes. A
+   *   `part def Vehicle;` is a `Parts::Part`, and without this the closure said
+   *   it was unrelated to one.
+   *
+   *   The contribution is the WHOLE chain above the base, not the base alone,
+   *   and it reports whether that chain could be read. Both halves matter:
+   *   `Parts::Part :> Items::Item` in the vendored library is what makes a
+   *   `part def` a legitimate narrowing of an `Items::Item` feature, and a
+   *   contribution that named only `Part` while still calling the closure
+   *   COMPLETE would let SSM017 reject that narrowing on a picture it knew was
+   *   partial. An unreadable chain therefore makes the closure incomplete, and
+   *   every caller stays silent on `unknown` — the same rule the rest of this
+   *   file follows, applied to the edge the source does not write.
    */
-  constructor(resolve8) {
+  constructor(resolve8, implicitBases) {
     this.resolve = resolve8;
+    this.implicitBases = implicitBases;
   }
   /** The transitive supertype names of the type written as `name`. */
   closureOf(name) {
@@ -164987,6 +165003,12 @@ var ConformanceModel = class {
     for (const supertype of [...declaredTypesOf(node).map((t) => t.text), ...specializedNamesOf(node)]) {
       absorb(this.walk(supertype, visiting));
     }
+    const implicit = this.implicitBases?.(node);
+    if (implicit) {
+      for (const base of implicit.names)
+        names.add(simpleTypeName(base));
+      complete &&= implicit.complete;
+    }
     for (const group of compositionGroupsOf(node)) {
       if (group.kind === "intersects") {
         for (const operand of group.targets)
@@ -174359,7 +174381,6 @@ var sysmlInlayHintSettings = {
   dimension: false,
   visibility: false,
   modifiers: false,
-  specialization: false,
   redefinition: false,
   effectiveNames: false,
   importedNames: false,
@@ -175025,6 +175046,547 @@ function resolveEffectiveSubject(node) {
   return void 0;
 }
 
+// ../language-server/out/src/services/implicit-specialization.js
+var EXPLICIT_SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([
+  ":>",
+  ":>>",
+  "::>",
+  "=>",
+  "specializes",
+  "subsets",
+  "redefines",
+  "references",
+  "crosses",
+  "conjugates"
+]);
+var IMPLICIT_BASES = Object.freeze({
+  PartDecl: { def: "Parts::Part", usage: "Parts::parts" },
+  ItemDecl: { def: "Items::Item", usage: "Items::items" },
+  PortDecl: { def: "Ports::Port", usage: "Ports::ports" },
+  ActionDecl: { def: "Actions::Action", usage: "Actions::actions" },
+  StateDecl: { def: "States::StateAction", usage: "States::stateActions" },
+  ConnectionDecl: { def: "Connections::Connection", usage: "Connections::connections" },
+  InterfaceDecl: { def: "Interfaces::Interface", usage: "Interfaces::interfaces" },
+  CaseDecl: { def: "Cases::Case", usage: "Cases::cases" },
+  UseCaseDecl: { def: "UseCases::UseCase", usage: "UseCases::useCases" },
+  AnalysisCaseDecl: { def: "AnalysisCases::AnalysisCase", usage: "AnalysisCases::analysisCases" },
+  VerificationCaseDecl: { def: "VerificationCases::VerificationCase", usage: "VerificationCases::verificationCases" },
+  ViewDecl: { def: "Views::View", usage: "Views::views" },
+  ViewpointDecl: { def: "Views::ViewpointCheck", usage: "Views::viewpointChecks" },
+  RenderingDecl: { def: "Views::Rendering", usage: "Views::renderings" },
+  RequirementDecl: { def: "Requirements::RequirementCheck", usage: "Requirements::requirementChecks" },
+  ConcernDecl: { def: "Requirements::ConcernCheck", usage: "Requirements::concernChecks" },
+  ConstraintDecl: { def: "Constraints::ConstraintCheck", usage: "Constraints::constraintChecks" },
+  CalcDecl: { def: "Calculations::Calculation", usage: "Calculations::calculations" },
+  AllocationDecl: { def: "Allocations::Allocation", usage: "Allocations::allocations" },
+  AttributeDecl: { def: "Attributes::AttributeValue", usage: "Attributes::attributeValues" },
+  OccurrenceDecl: { def: "Occurrences::Occurrence", usage: "Occurrences::occurrences" },
+  MetadataDecl: { def: "Metadata::MetadataItem", usage: "Metadata::metadataItems" }
+});
+var KERML_CLASSIFIER_BASES = Object.freeze({
+  ClassDecl: "Occurrences::Occurrence",
+  StructDecl: "Objects::Object",
+  MetaclassDecl: "Metaobjects::Metaobject",
+  BehaviorDecl: "Performances::Performance",
+  DatatypeDecl: "Base::DataValue"
+});
+var KERML_FEATURE_BASES = Object.freeze({
+  StepDecl: "Performances::performances"
+});
+var ASSOCIATION_BASES = Object.freeze({ link: "Links::Link", linkObject: "Objects::LinkObject" });
+var LIBRARY_BASE_CHAINS = Object.freeze({
+  "Actions::Action": ["Performance", "Occurrence", "Anything"],
+  "Actions::actions": ["Action", "Performance", "Occurrence", "Anything", "performances", "occurrences", "things"],
+  "Allocations::Allocation": [
+    "BinaryConnection",
+    "BinaryLinkObject",
+    "BinaryLink",
+    "Link",
+    "Anything",
+    "LinkObject",
+    "Object",
+    "Occurrence",
+    "Connection",
+    "Part",
+    "Item"
+  ],
+  "Allocations::allocations": [
+    "Allocation",
+    "BinaryConnection",
+    "BinaryLinkObject",
+    "BinaryLink",
+    "Link",
+    "Anything",
+    "LinkObject",
+    "Object",
+    "Occurrence",
+    "Connection",
+    "Part",
+    "Item",
+    "binaryConnections",
+    "connections",
+    "linkObjects",
+    "links",
+    "things",
+    "objects",
+    "occurrences",
+    "parts",
+    "items",
+    "binaryLinkObjects",
+    "binaryLinks"
+  ],
+  "AnalysisCases::AnalysisCase": [
+    "Case",
+    "Calculation",
+    "Action",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "Evaluation"
+  ],
+  "AnalysisCases::analysisCases": [
+    "AnalysisCase",
+    "Case",
+    "Calculation",
+    "Action",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "Evaluation",
+    "cases",
+    "calculations",
+    "actions",
+    "performances",
+    "occurrences",
+    "things",
+    "evaluations"
+  ],
+  "Attributes::AttributeValue": ["DataValue", "Anything"],
+  "Attributes::attributeValues": ["dataValues", "DataValue", "Anything", "things"],
+  "Base::DataValue": ["Anything"],
+  "Calculations::Calculation": ["Action", "Performance", "Occurrence", "Anything", "Evaluation"],
+  "Calculations::calculations": [
+    "Calculation",
+    "Action",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "Evaluation",
+    "actions",
+    "performances",
+    "occurrences",
+    "things",
+    "evaluations"
+  ],
+  "Cases::Case": ["Calculation", "Action", "Performance", "Occurrence", "Anything", "Evaluation"],
+  "Cases::cases": [
+    "Case",
+    "Calculation",
+    "Action",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "Evaluation",
+    "calculations",
+    "actions",
+    "performances",
+    "occurrences",
+    "things",
+    "evaluations"
+  ],
+  "Connections::Connection": ["LinkObject", "Link", "Anything", "Object", "Occurrence", "Part", "Item"],
+  "Connections::connections": [
+    "Connection",
+    "LinkObject",
+    "Link",
+    "Anything",
+    "Object",
+    "Occurrence",
+    "Part",
+    "Item",
+    "linkObjects",
+    "links",
+    "things",
+    "objects",
+    "occurrences",
+    "parts",
+    "items"
+  ],
+  "Constraints::ConstraintCheck": ["BooleanEvaluation", "Evaluation", "Performance", "Occurrence", "Anything"],
+  "Constraints::constraintChecks": [
+    "ConstraintCheck",
+    "BooleanEvaluation",
+    "Evaluation",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "booleanEvaluations",
+    "evaluations",
+    "performances",
+    "occurrences",
+    "things"
+  ],
+  "Interfaces::Interface": ["Connection", "LinkObject", "Link", "Anything", "Object", "Occurrence", "Part", "Item"],
+  "Interfaces::interfaces": [
+    "Interface",
+    "Connection",
+    "LinkObject",
+    "Link",
+    "Anything",
+    "Object",
+    "Occurrence",
+    "Part",
+    "Item",
+    "connections",
+    "linkObjects",
+    "links",
+    "things",
+    "objects",
+    "occurrences",
+    "parts",
+    "items"
+  ],
+  "Items::Item": ["Object", "Occurrence", "Anything"],
+  "Items::items": ["Item", "Object", "Occurrence", "Anything", "objects", "occurrences", "things"],
+  "Links::Link": ["Anything"],
+  "Metadata::MetadataItem": ["Metaobject", "Object", "Occurrence", "Anything", "Item"],
+  "Metadata::metadataItems": [
+    "MetadataItem",
+    "Metaobject",
+    "Object",
+    "Occurrence",
+    "Anything",
+    "Item",
+    "metaobjects",
+    "objects",
+    "occurrences",
+    "things",
+    "items"
+  ],
+  "Metaobjects::Metaobject": ["Object", "Occurrence", "Anything"],
+  "Objects::LinkObject": ["Link", "Anything", "Object", "Occurrence"],
+  "Objects::Object": ["Occurrence", "Anything"],
+  "Occurrences::Occurrence": ["Anything"],
+  "Occurrences::occurrences": ["Occurrence", "Anything", "things"],
+  "Parts::Part": ["Item", "Object", "Occurrence", "Anything"],
+  "Parts::parts": ["Part", "Item", "Object", "Occurrence", "Anything", "items", "objects", "occurrences", "things"],
+  "Performances::Performance": ["Occurrence", "Anything"],
+  "Performances::performances": ["Performance", "Occurrence", "Anything", "occurrences", "things"],
+  "Ports::Port": ["Object", "Occurrence", "Anything"],
+  "Ports::ports": ["Port", "Object", "Occurrence", "Anything", "objects", "occurrences", "things"],
+  "Requirements::ConcernCheck": [
+    "RequirementCheck",
+    "RequirementConstraintCheck",
+    "ConstraintCheck",
+    "BooleanEvaluation",
+    "Evaluation",
+    "Performance",
+    "Occurrence",
+    "Anything"
+  ],
+  "Requirements::RequirementCheck": [
+    "RequirementConstraintCheck",
+    "ConstraintCheck",
+    "BooleanEvaluation",
+    "Evaluation",
+    "Performance",
+    "Occurrence",
+    "Anything"
+  ],
+  "Requirements::concernChecks": [
+    "ConcernCheck",
+    "RequirementCheck",
+    "RequirementConstraintCheck",
+    "ConstraintCheck",
+    "BooleanEvaluation",
+    "Evaluation",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "requirementChecks",
+    "constraintChecks",
+    "booleanEvaluations",
+    "evaluations",
+    "performances",
+    "occurrences",
+    "things"
+  ],
+  "Requirements::requirementChecks": [
+    "RequirementCheck",
+    "RequirementConstraintCheck",
+    "ConstraintCheck",
+    "BooleanEvaluation",
+    "Evaluation",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "constraintChecks",
+    "booleanEvaluations",
+    "evaluations",
+    "performances",
+    "occurrences",
+    "things"
+  ],
+  "States::StateAction": [
+    "Action",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "StatePerformance",
+    "DecisionPerformance"
+  ],
+  "States::stateActions": [
+    "StateAction",
+    "Action",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "StatePerformance",
+    "DecisionPerformance",
+    "actions",
+    "performances",
+    "occurrences",
+    "things"
+  ],
+  "UseCases::UseCase": ["Case", "Calculation", "Action", "Performance", "Occurrence", "Anything", "Evaluation"],
+  "UseCases::useCases": [
+    "UseCase",
+    "Case",
+    "Calculation",
+    "Action",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "Evaluation",
+    "cases",
+    "calculations",
+    "actions",
+    "performances",
+    "occurrences",
+    "things",
+    "evaluations"
+  ],
+  "VerificationCases::VerificationCase": [
+    "Case",
+    "Calculation",
+    "Action",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "Evaluation"
+  ],
+  "VerificationCases::verificationCases": [
+    "VerificationCase",
+    "Case",
+    "Calculation",
+    "Action",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "Evaluation",
+    "cases",
+    "calculations",
+    "actions",
+    "performances",
+    "occurrences",
+    "things",
+    "evaluations"
+  ],
+  "Views::Rendering": ["Part", "Item", "Object", "Occurrence", "Anything"],
+  "Views::View": ["Part", "Item", "Object", "Occurrence", "Anything"],
+  "Views::ViewpointCheck": [
+    "RequirementCheck",
+    "RequirementConstraintCheck",
+    "ConstraintCheck",
+    "BooleanEvaluation",
+    "Evaluation",
+    "Performance",
+    "Occurrence",
+    "Anything"
+  ],
+  "Views::renderings": [
+    "Rendering",
+    "Part",
+    "Item",
+    "Object",
+    "Occurrence",
+    "Anything",
+    "parts",
+    "items",
+    "objects",
+    "occurrences",
+    "things"
+  ],
+  "Views::viewpointChecks": [
+    "ViewpointCheck",
+    "RequirementCheck",
+    "RequirementConstraintCheck",
+    "ConstraintCheck",
+    "BooleanEvaluation",
+    "Evaluation",
+    "Performance",
+    "Occurrence",
+    "Anything",
+    "requirementChecks",
+    "constraintChecks",
+    "booleanEvaluations",
+    "evaluations",
+    "performances",
+    "occurrences",
+    "things"
+  ],
+  "Views::views": [
+    "View",
+    "Part",
+    "Item",
+    "Object",
+    "Occurrence",
+    "Anything",
+    "parts",
+    "items",
+    "objects",
+    "occurrences",
+    "things"
+  ]
+});
+function allRelationships(node) {
+  return [...node.preRelationships ?? [], ...node.relationships ?? []];
+}
+function statesExplicitSpecialization(node) {
+  const decl = node;
+  if (decl.typing?.type?.$refText)
+    return true;
+  return allRelationships(decl).some((rel2) => (
+    // The SYMBOLIC conjugation has no keyword: `port def In ~ Out;` parses as
+    // a relationship with `conjugate: true` and NO `kind` at all (the
+    // grammar's `conjugate?='~' targets+=RelationPath` alternative). Reading
+    // `kind` alone therefore missed it and offered `Ports::Port` beside a
+    // relationship that already says what the declaration is.
+    rel2.conjugate === true || rel2.kind !== void 0 && EXPLICIT_SPECIALIZATION_KINDS.has(rel2.kind)
+  ));
+}
+function implicitBaseOf(node) {
+  const decl = node;
+  const found = qualifiedBaseOf(decl);
+  if (!found)
+    return void 0;
+  const [qualified, isUsage2] = found;
+  return {
+    qualified,
+    simple: simpleTypeName(qualified),
+    isUsage: isUsage2,
+    metaclass: isUsage2 ? "Subsetting" : "Specialization"
+  };
+}
+function qualifiedBaseOf(decl) {
+  const classifier = decl.$type === "AssociationDecl" ? decl.isStruct === true ? ASSOCIATION_BASES.linkObject : ASSOCIATION_BASES.link : KERML_CLASSIFIER_BASES[decl.$type];
+  if (classifier)
+    return [classifier, false];
+  const feature = KERML_FEATURE_BASES[decl.$type];
+  if (feature)
+    return [feature, true];
+  const entry = IMPLICIT_BASES[decl.$type];
+  if (!entry)
+    return void 0;
+  const isUsage2 = decl.isDef !== true;
+  return [isUsage2 ? entry.usage : entry.def, isUsage2];
+}
+function impliedBaseOf(node) {
+  if (statesExplicitSpecialization(node))
+    return void 0;
+  return implicitBaseOf(node);
+}
+var ImplicitSpecializationModel = class {
+  lookup;
+  /** Resolved bases, keyed by qualified name. A MISS is never cached: the
+   *  library index may still be loading, and a cached miss would outlive it. */
+  bases = /* @__PURE__ */ new Map();
+  constructor(lookup) {
+    this.lookup = lookup;
+  }
+  /** Drop everything a rebuilt index could change. The chain table is a
+   *  constant and survives; only a resolved description can go stale. */
+  invalidate() {
+    this.bases.clear();
+  }
+  /** The implied base of one declaration, or `undefined` when there is none. */
+  baseOf(node) {
+    return impliedBaseOf(node);
+  }
+  /**
+   * The index description of a base, so a consumer can link to it.
+   *
+   * The full qualified spelling must resolve inside the standard library.
+   * A workspace namesake or an unrelated library element with the same simple
+   * name cannot supply this relationship.
+   */
+  descriptionOf(base) {
+    const cached = this.bases.get(base.qualified);
+    if (cached)
+      return cached;
+    if (!this.lookup)
+      return void 0;
+    const exact = this.lookup.descriptions(base.qualified).find((description) => {
+      const uri = description.documentUri instanceof URI2 ? description.documentUri : URI2.parse(String(description.documentUri));
+      return isStandardLibraryUri(uri);
+    });
+    if (exact)
+      this.bases.set(base.qualified, exact);
+    return exact;
+  }
+  /**
+   * The implied base of `node` and every library name above it.
+   *
+   * Answered from {@link LIBRARY_BASE_CHAINS}, so it needs no index, no parse
+   * and no network of loaded documents: the desktop host, the web worker and
+   * the headless CLIs all give the same answer, and a workspace with no
+   * library loaded still gets the real hierarchy rather than a shrug. A
+   * declaration with no implicit base has an empty closure, which is complete
+   * in the only sense that matters: there is nothing missing from it.
+   *
+   * A base the table does not cover is reported INCOMPLETE rather than as a
+   * bare name, because a caller may conclude nothing from a name's absence
+   * when the hierarchy above it was never known.
+   */
+  closureOf(node) {
+    const base = this.baseOf(node);
+    if (!base)
+      return { names: /* @__PURE__ */ new Set(), complete: true };
+    const chain = LIBRARY_BASE_CHAINS[base.qualified];
+    return {
+      names: /* @__PURE__ */ new Set([base.simple, ...(chain ?? []).map(simpleTypeName)]),
+      complete: chain !== void 0
+    };
+  }
+  /**
+   * The chain the library puts above one base, for a caller that wants to
+   * check the table against the library it was read from.
+   */
+  static libraryChainOf(qualified) {
+    return LIBRARY_BASE_CHAINS[qualified];
+  }
+  /** Every base the chain table covers, for the same reason. */
+  static coveredBases() {
+    return Object.keys(LIBRARY_BASE_CHAINS);
+  }
+};
+var models = /* @__PURE__ */ new WeakMap();
+function implicitSpecializationsFor(shared) {
+  if (!shared)
+    return void 0;
+  const existing = models.get(shared);
+  if (existing)
+    return existing;
+  const created = new ImplicitSpecializationModel(nameLookupFor(shared));
+  models.set(shared, created);
+  shared.workspace.DocumentBuilder.onBuildPhase(
+    // Indexing is the only phase that can change what a base resolves to.
+    DocumentState.IndexedContent,
+    () => created.invalidate()
+  );
+  return created;
+}
+
 // ../language-server/out/src/messages.js
 var DIAGNOSTIC_MESSAGES = {
   // REQ-006 - a broad diagram anchor cannot prove which typed occurrence owns
@@ -175379,6 +175941,12 @@ var OPERATOR_TOOLTIPS = {
   "@": { desc: "**Metadata application** shorthand - applies a metadata definition to the next element.", precedence: 0, example: "@Safety\npart def Engine;", cite: "OMG SysML v2.0 Part 1 \xA78.2.2.27 (Metadata)" },
   "@@": { desc: "**Metaclass application** - applies a metaclass annotation.", precedence: 0, example: "@@StandardProfile", cite: "OMG SysML v2.0 Part 1 \xA78.2.2.27 (Metadata)" }
 };
+var IMPLICIT_SPECIALIZATION_MESSAGES = {
+  makeExplicit: (base) => `Make implicit specialization explicit (':> ${base}')`,
+  specializes: "implicitly specializes",
+  subsets: "implicitly subsets",
+  source: "  Source: the standard library, through the declaration keyword (OMG SysML v2 Part 1 section 7.6.8)."
+};
 
 // ../language-server/out/src/services/hover-provider.js
 var MAX_HOVER_LINES = 30;
@@ -175473,7 +176041,7 @@ function directionLabel(node) {
   const dir = modifiers2.find((m) => m === "in" || m === "out" || m === "inout");
   return dir ? `${dir} ` : "";
 }
-function allRelationships(node) {
+function allRelationships2(node) {
   return [...node.preRelationships ?? [], ...node.relationships ?? []];
 }
 function relationshipTargets(rel2) {
@@ -175537,7 +176105,7 @@ function declarationLine(node, resolver, enumResolver) {
   const name = externalVariantName(node) ?? identificationLabel(named2) ?? effectiveIdentificationLabel(named2) ?? "(anonymous)";
   let typing = typingLabel(named2.typing);
   const mult = multiplicityLabel(node, resolver);
-  let rels = relationshipLabel(allRelationships(named2));
+  let rels = relationshipLabel(allRelationships2(named2));
   const implicitVariant = implicitVariantSpecialization(node);
   if (!typing && !implicitVariant && enumResolver && isEnumerationUsage(node)) {
     const types = effectiveEnumerationTypes(node, enumResolver);
@@ -175607,7 +176175,7 @@ function memberSummary(node, resolver) {
   const kind = kindLabel(node);
   const typing = typingLabel(named2.typing);
   const mult = multiplicityLabel(node, resolver);
-  const rels = relationshipLabel(allRelationships(named2));
+  const rels = relationshipLabel(allRelationships2(named2));
   return `${dir}${kind} ${name}${typing}${mult}${rels}`;
 }
 function memberList(node, resolver) {
@@ -175780,7 +176348,7 @@ function supertypeCandidates(node) {
     if (more.$refText)
       out.push({ refText: more.$refText, ref: more.ref });
   }
-  for (const rel2 of allRelationships(named2)) {
+  for (const rel2 of allRelationships2(named2)) {
     if (!rel2.kind || !DOC_SPECIALIZATION_KINDS.has(rel2.kind))
       continue;
     for (const target of rel2.targets ?? [])
@@ -176162,12 +176730,15 @@ var SysmlHoverProvider = class {
   enumerations;
   /** REQ-394 — the linker's lazy standard-library load, reused rather than duplicated. */
   linker;
+  /** REQ-411 — issue #161: the shared implicit-specialization model. */
+  implicit;
   constructor(services) {
     this.references = services.references.References;
     this.astNodeLocator = services.workspace.AstNodeLocator;
     this.documents = services.shared.workspace.LangiumDocuments;
     this.indexManager = services.shared.workspace.IndexManager;
     this.linker = services.references.Linker;
+    this.implicit = implicitSpecializationsFor(services.shared);
     const paths = new FeaturePathResolver(services);
     this.featureProperties = featurePropertyResolver(paths);
     this.enumerations = enumerationResolver(paths);
@@ -176311,8 +176882,10 @@ var SysmlHoverProvider = class {
   // target kind, and target declaration line instead of only echoing `:>`/`:>>`.
   async relationshipDetailSection(node) {
     const named2 = node;
-    const rels = allRelationships(named2);
-    if (rels.length === 0)
+    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)
       return void 0;
     const sourceKind = kindLabel(node);
     const sourceName = identificationLabel(named2) ?? "(anonymous)";
@@ -176334,6 +176907,10 @@ var SysmlHoverProvider = class {
         }
       }
     }
+    if (impliedBase) {
+      const phrase = impliedBase.isUsage ? IMPLICIT_SPECIALIZATION_MESSAGES.subsets : IMPLICIT_SPECIALIZATION_MESSAGES.specializes;
+      lines.push(`- ${sourceKind} \`${sourceName}\` ${phrase} \`${impliedBase.qualified}\``, IMPLICIT_SPECIALIZATION_MESSAGES.source);
+    }
     return lines.length > 0 ? `*Relationships:*
 ${lines.join("\n")}` : void 0;
   }
@@ -178897,12 +179474,18 @@ var SysmlValidator = class _SysmlValidator {
   // captured here. The two share one grammar today; this keeps that from becoming
   // load-bearing.
   serviceRegistry;
+  // REQ-411 — issue #161: the shared implicit-specialization model. The walk
+  // above a base needs a PARSED library declaration, so it goes through the
+  // 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;
   constructor(services) {
     this.serviceRegistry = services.shared.ServiceRegistry;
     this.indexManager = services.shared.workspace.IndexManager;
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
     this.astNodeLocator = services.workspace.AstNodeLocator;
     this.featurePaths = new FeaturePathResolver(services);
+    this.implicit = implicitSpecializationsFor(services.shared);
     this.featureProperties = featurePropertyResolver(this.featurePaths);
     this.compositionTypes = compositionTypeResolver(this.featurePaths);
     this.enumerations = enumerationResolver(this.featurePaths);
@@ -180628,7 +181211,7 @@ ${baseIndent}}`;
   // `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, index2, accept) {
-    const model = new ConformanceModel((name) => this.resolveUnique(name, index2));
+    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);
       this.checkValueAssignability(decl, model, accept);
@@ -183402,6 +183985,21 @@ function nearestDefAware(node) {
   }
   return void 0;
 }
+function nearestImplicitBaseOwner(node) {
+  for (let cur = node; cur; cur = cur.$container) {
+    if (implicitBaseOf(cur))
+      return cur;
+  }
+  return void 0;
+}
+var DECLARATION_HEAD_ENDS = /* @__PURE__ */ new Set(["{", ";", "=", ":=", "default"]);
+function declarationTailPosition(node) {
+  const leaves = cst_utils_exports.flattenCst(node).toArray().filter((leaf) => !leaf.hidden);
+  const stop = leaves.findIndex((leaf) => DECLARATION_HEAD_ENDS.has(leaf.text));
+  if (stop > 0)
+    return leaves[stop - 1].range.end;
+  return node.range.end;
+}
 function isSubjectBearing(node) {
   return !!node && (isRequirementDecl(node) || isCaseDecl(node) || isUseCaseDecl(node) || isVerificationCaseDecl(node) || isAnalysisCaseDecl(node) || isConcernDecl(node));
 }
@@ -183447,8 +184045,12 @@ function astNodeAtRange(document2, diagnostic) {
 }
 var SysmlCodeActionProvider = class {
   documents;
+  /** REQ-411 — issue #161: the shared implicit-specialization model, so the
+   *  action offers only a base the loaded library actually holds. */
+  implicit;
   constructor(services) {
     this.documents = services.shared.workspace.LangiumDocuments;
+    this.implicit = implicitSpecializationsFor(services.shared);
   }
   getCodeActions(document2, params) {
     const actions = [];
@@ -183750,6 +184352,19 @@ ${indent}}`)]
         });
       }
     }
+    const implicitOwner = nearestImplicitBaseOwner(rangeNode);
+    const implicitBase = implicitOwner ? impliedBaseOf(implicitOwner) : void 0;
+    if (implicitOwner?.$cstNode && implicitBase && this.implicit?.descriptionOf(implicitBase)) {
+      actions.push({
+        title: IMPLICIT_SPECIALIZATION_MESSAGES.makeExplicit(implicitBase.qualified),
+        kind: import_vscode_languageserver18.CodeActionKind.RefactorRewrite,
+        edit: {
+          changes: {
+            [uri]: [import_vscode_languageserver18.TextEdit.insert(declarationTailPosition(implicitOwner.$cstNode), ` :> ${implicitBase.qualified}`)]
+          }
+        }
+      });
+    }
     const importNode = nearestAncestor2(rangeNode, isImport);
     if (importNode?.$cstNode && importNode.alias && importNode.segs.every((s) => !s.star && s.name)) {
       const path10 = [importNode.head, ...importNode.segs.map((s) => s.name)].join("::");
@@ -185027,18 +185642,6 @@ function typeAnchor(node, refText) {
   }
   return void 0;
 }
-var EXPLICIT_SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([
-  ":>",
-  ":>>",
-  "::>",
-  "=>",
-  "specializes",
-  "subsets",
-  "redefines",
-  "references",
-  "crosses",
-  "conjugates"
-]);
 var REDEFINITION_KINDS4 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var CONSTANT_CARRYING_KINDS = /* @__PURE__ */ new Set([
   ":>",
@@ -185083,30 +185686,6 @@ var ACTION_KIND_USAGES = /* @__PURE__ */ new Set([
   "VerificationCaseDecl"
 ]);
 var KERML_FEATURE_DECLS = /* @__PURE__ */ new Set(["FeatureDecl", "StepDecl", "ExpressionDecl"]);
-var IMPLICIT_BASES = Object.freeze({
-  PartDecl: { def: "Parts::Part", usage: "Parts::parts" },
-  ItemDecl: { def: "Items::Item", usage: "Items::items" },
-  PortDecl: { def: "Ports::Port", usage: "Ports::ports" },
-  ActionDecl: { def: "Actions::Action", usage: "Actions::actions" },
-  StateDecl: { def: "States::StateAction", usage: "States::stateActions" },
-  ConnectionDecl: { def: "Connections::Connection", usage: "Connections::connections" },
-  InterfaceDecl: { def: "Interfaces::Interface", usage: "Interfaces::interfaces" },
-  CaseDecl: { def: "Cases::Case", usage: "Cases::cases" },
-  UseCaseDecl: { def: "UseCases::UseCase", usage: "UseCases::useCases" },
-  AnalysisCaseDecl: { def: "AnalysisCases::AnalysisCase", usage: "AnalysisCases::analysisCases" },
-  VerificationCaseDecl: { def: "VerificationCases::VerificationCase", usage: "VerificationCases::verificationCases" },
-  ViewDecl: { def: "Views::View", usage: "Views::views" },
-  ViewpointDecl: { def: "Views::ViewpointCheck", usage: "Views::viewpointChecks" },
-  RenderingDecl: { def: "Views::Rendering", usage: "Views::renderings" },
-  RequirementDecl: { def: "Requirements::RequirementCheck", usage: "Requirements::requirementChecks" },
-  ConcernDecl: { def: "Requirements::ConcernCheck", usage: "Requirements::concernChecks" },
-  ConstraintDecl: { def: "Constraints::ConstraintCheck", usage: "Constraints::constraintChecks" },
-  CalcDecl: { def: "Calculations::Calculation", usage: "Calculations::calculations" },
-  AllocationDecl: { def: "Allocations::Allocation", usage: "Allocations::allocations" },
-  AttributeDecl: { def: "Attributes::AttributeValue", usage: "Attributes::attributeValues" },
-  OccurrenceDecl: { def: "Occurrences::Occurrence", usage: "Occurrences::occurrences" },
-  MetadataDecl: { def: "Metadata::MetadataItem", usage: "Metadata::metadataItems" }
-});
 var OCCURRENCE_KIND_OWNERS = /* @__PURE__ */ new Set([
   ...Object.keys(IMPLICIT_BASES).filter((kind) => kind !== "AttributeDecl"),
   // KerML fixes a library base per classifier kind too, in the same way and in
@@ -185141,14 +185720,9 @@ var NON_VARYING_LIBRARY_TYPES = /* @__PURE__ */ new Set(["SelfLink", "HappensLin
 function markdown(value) {
   return { kind: import_vscode_languageserver20.MarkupKind.Markdown, value };
 }
-function allRelationships2(node) {
+function allRelationships3(node) {
   return [...node.preRelationships ?? [], ...node.relationships ?? []];
 }
-function hasExplicitSpecialization(node) {
-  if (node.typing?.type?.$refText)
-    return true;
-  return allRelationships2(node).some((rel2) => rel2.kind && EXPLICIT_SPECIALIZATION_KINDS.has(rel2.kind));
-}
 function keywordLeaf(node, keyword) {
   const cst = node.$cstNode;
   if (!cst)
@@ -185172,7 +185746,7 @@ function specializesNonVaryingLibraryType(node) {
   const typing = node.typing?.type?.$refText;
   if (typing && NON_VARYING_LIBRARY_TYPES.has(lastSegment3(typing)))
     return true;
-  return allRelationships2(node).flatMap((rel2) => rel2.targets ?? []).some((target) => NON_VARYING_LIBRARY_TYPES.has(lastSegment3(target)));
+  return allRelationships3(node).flatMap((rel2) => rel2.targets ?? []).some((target) => NON_VARYING_LIBRARY_TYPES.has(lastSegment3(target)));
 }
 function constantAnchor(node) {
   const cst = node.$cstNode;
@@ -185236,16 +185810,6 @@ function callArguments(node) {
 }
 var SysmlInlayHintProvider = class {
   services;
-  /**
-   * Resolved implicit bases, keyed by the qualified name in
-   * {@link IMPLICIT_BASES}. A base the index does not hold is NOT cached — the
-   * library may still be loading — and issue #240 made that miss cheap: two
-   * lookups in the shared name index rather than the full index scan it used
-   * to be, on a request VS Code re-issues on every scroll. A HIT is cached
-   * until the index is rebuilt, so the description a label links to always
-   * carries the ranges of the generation it was read from.
-   */
-  baseCache = /* @__PURE__ */ new Map();
   /**
    * REQ-395 — issue #240: the shared name lookup, built once per index
    * generation. Every category that resolves a WRITTEN name goes through it,
@@ -185290,7 +185854,6 @@ var SysmlInlayHintProvider = class {
     this.linker = services?.references.Linker;
     this.featureProperties = featurePropertyResolver(new FeaturePathResolver(services));
     services?.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => {
-      this.baseCache.clear();
       this.constantCache.clear();
       this.declaredNameCache.clear();
       this.effectiveNameResolvers = /* @__PURE__ */ new WeakMap();
@@ -185398,26 +185961,6 @@ var SysmlInlayHintProvider = class {
           ...node.$type === "VariantReference" || isOwnedEnumerationValue(node) ? {} : { textEdits: [{ range: { start: at, end: at }, newText: "ref " }] }
         });
       }
-      if (settings.specialization && node.$cstNode && decl.name && !hasExplicitSpecialization(decl)) {
-        const entry = IMPLICIT_BASES[node.$type];
-        const qualified = entry ? decl.isDef ? entry.def : entry.usage : void 0;
-        const description = qualified ? this.resolveImplicitBase(qualified, decl.isDef !== true) : void 0;
-        if (qualified && description) {
-          hints.push({
-            position: multiplicityAnchor(node.$cstNode),
-            label: [{
-              value: ` :> ${qualified}`,
-              location: {
-                uri: description.documentUri.toString(),
-                range: descriptionRange(description)
-              }
-            }],
-            kind: import_vscode_languageserver20.InlayHintKind.Type,
-            paddingLeft: true,
-            tooltip: markdown(`Implicitly specializes \`${qualified}\` from the standard library.`)
-          });
-        }
-      }
       if (settings.redefinition)
         hints.push(...this.parameterRedefinitionHints(decl));
       if (settings.effectiveNames) {
@@ -185488,7 +186031,7 @@ var SysmlInlayHintProvider = class {
       const parameter = mine[index2].node;
       if (!parameter.name || !parameter.$cstNode)
         continue;
-      if (allRelationships2(parameter).some((rel2) => rel2.kind && REDEFINITION_KINDS4.has(rel2.kind)))
+      if (allRelationships3(parameter).some((rel2) => rel2.kind && REDEFINITION_KINDS4.has(rel2.kind)))
         continue;
       const target = theirs[index2].node;
       if (!target.name || target.name === parameter.name)
@@ -185683,7 +186226,7 @@ var SysmlInlayHintProvider = class {
       return void 0;
     if (specializesNonVaryingLibraryType(node))
       return void 0;
-    const carrier = allRelationships2(node).filter((rel2) => rel2.kind && CONSTANT_CARRYING_KINDS.has(rel2.kind)).flatMap((rel2) => rel2.targets ?? []).find((target) => this.isConstantFeature(target));
+    const carrier = allRelationships3(node).filter((rel2) => rel2.kind && CONSTANT_CARRYING_KINDS.has(rel2.kind)).flatMap((rel2) => rel2.targets ?? []).find((target) => this.isConstantFeature(target));
     if (!carrier)
       return void 0;
     const anchor = constantAnchor(node);
@@ -185727,41 +186270,11 @@ var SysmlInlayHintProvider = class {
     this.constantCache.set(key2, answer);
     return answer;
   }
-  /**
-   * REQ-395 — Find one implicit base in the index.
-   *
-   * A description whose name is the full qualified spelling wins outright. The
-   * index otherwise keys library symbols by their simple name, so the fallback
-   * requires BOTH a standard-library document and the right side of the
-   * definition/usage split, which the precomputed index records — that is what
-   * keeps `Parts::Part` from matching a `part Part` somewhere else.
-   */
-  resolveImplicitBase(qualified, wantUsage) {
-    const cached = this.baseCache.get(qualified);
-    if (cached)
-      return cached;
-    if (!this.lookup)
-      return void 0;
-    const exact = this.lookup.descriptions(qualified).at(0);
-    if (exact) {
-      this.baseCache.set(qualified, exact);
-      return exact;
-    }
-    const fallback = this.lookup.descriptions(lastSegment3(qualified)).find((description) => {
-      const uri = description.documentUri instanceof URI2 ? description.documentUri : URI2.parse(String(description.documentUri));
-      if (!isStandardLibraryUri(uri))
-        return false;
-      return description.isUsage === true === wantUsage;
-    });
-    if (fallback)
-      this.baseCache.set(qualified, fallback);
-    return fallback;
-  }
 };
 function effectiveNameHint(node, resolver) {
   if (node.name || node.shortName?.name || !node.$cstNode)
     return void 0;
-  const redefinition = allRelationships2(node).find((rel2) => rel2.kind && REDEFINITION_KINDS4.has(rel2.kind) && (rel2.targets?.length ?? 0) > 0);
+  const redefinition = allRelationships3(node).find((rel2) => rel2.kind && REDEFINITION_KINDS4.has(rel2.kind) && (rel2.targets?.length ?? 0) > 0);
   if (!redefinition?.targets?.[0])
     return void 0;
   const names = effectiveNamesOf(node, resolver);
@@ -187094,6 +187607,8 @@ function ownedRelationshipTargets(element, typePattern) {
   for (const relationship of toArray(element.ownedRelationship)) {
     if (!isObject3(relationship))
       continue;
+    if (relationship.isImplied === true)
+      continue;
     const type = stringValue(relationship["@type"]) ?? "";
     if (!typePattern.test(type))
       continue;
@@ -209722,7 +210237,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.31.2" : "dev";
+var VERSION2 = true ? "0.32.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;