sysml-diagram 0.31.1 → 0.32.0

package/out/main.js

@@ -162710,6 +162710,11 @@ var FeaturePathResolver = class {
   linker;
   scopeProvider;
   snapshots = /* @__PURE__ */ new WeakMap();
+  indexedSnapshot;
+  // REQ-361 - Inheritance walks memoized against the snapshot they were read
+  // from; a new snapshot answers fresh. Keyed weakly, so a re-parsed document
+  // drops its entries with its nodes.
+  owners = /* @__PURE__ */ new WeakMap();
   propertySegments = /* @__PURE__ */ new WeakMap();
   resolvingSpecializations = /* @__PURE__ */ new Set();
   enumerationPathDepth = 0;
@@ -162720,9 +162725,12 @@ var FeaturePathResolver = class {
     this.locator = services?.workspace.AstNodeLocator;
     this.linker = services?.references.Linker;
     this.scopeProvider = services?.references.ScopeProvider;
-    services?.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => {
-      this.snapshots = /* @__PURE__ */ new WeakMap();
-    });
+    services?.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => this.dropSnapshots());
+    services?.shared.workspace.DocumentBuilder.onUpdate(() => this.dropSnapshots());
+  }
+  dropSnapshots() {
+    this.snapshots = /* @__PURE__ */ new WeakMap();
+    this.indexedSnapshot = void 0;
   }
   // REQ-220/317 — resolve every independently clickable/diagnosable segment.
   resolve(node) {
@@ -163187,10 +163195,22 @@ var FeaturePathResolver = class {
     }
     return {};
   }
+  // REQ-361 - The inheritance walk is the hot path of every written-path
+  // resolution, and a document resolves the same owners over and over: once per
+  // path that mentions them, and again for every reference tally a CodeLens
+  // pass asks for. The answer only changes with the syntax (fixed for a parse)
+  // and the index generation, so it is memoized against the snapshot that
+  // produced it. A walk that ran INSIDE a specialization cycle sees the cycle
+  // guard's empty answer, so only a top-level walk is cached.
   typedAndSpecializedOwners(node, snapshot) {
     const syntax = inheritanceSyntax(node);
     if (!syntax.hasSources)
       return [];
+    const cacheable = this.resolvingSpecializations.size === 0;
+    const depthZero = this.enumerationPathDepth === 0;
+    const cached = this.owners.get(node);
+    if (cached && cached.snapshot === snapshot && cached.depthZero === depthZero)
+      return cached.owners;
     const result = [];
     const seen = /* @__PURE__ */ new Set();
     const visit = (candidate) => {
@@ -163221,6 +163241,8 @@ var FeaturePathResolver = class {
     visit(this.isEnumUsage(node) ? this.enumerationTypingTarget(node) : this.typingTarget(node, snapshot));
     for (const specialized of this.specializationTargets(node, snapshot))
       visit(specialized);
+    if (cacheable)
+      this.owners.set(node, { snapshot, depthZero, owners: result });
     return result;
   }
   inferredEnumerationTarget(node) {
@@ -163379,8 +163401,9 @@ var FeaturePathResolver = class {
     segment.target = target.node;
     segment.description = target.description;
   }
+  // REQ-361/410 - One indexed workspace snapshot, or one per parse-only root.
   snapshot(root4) {
-    const cached = this.snapshots.get(root4);
+    const cached = this.indexManager ? this.indexedSnapshot : this.snapshots.get(root4);
     if (cached)
       return cached;
     const byName = /* @__PURE__ */ new Map();
@@ -163412,7 +163435,10 @@ var FeaturePathResolver = class {
       }
     }
     const snapshot = { byName };
-    this.snapshots.set(root4, snapshot);
+    if (this.indexManager)
+      this.indexedSnapshot = snapshot;
+    else
+      this.snapshots.set(root4, snapshot);
     return snapshot;
   }
 };
@@ -164919,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
@@ -164926,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) {
@@ -164961,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)
@@ -174333,7 +174381,6 @@ var sysmlInlayHintSettings = {
   dimension: false,
   visibility: false,
   modifiers: false,
-  specialization: false,
   redefinition: false,
   effectiveNames: false,
   importedNames: false,
@@ -174999,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
@@ -175353,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;
@@ -175447,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) {
@@ -175511,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);
@@ -175581,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) {
@@ -175754,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 ?? [])
@@ -176136,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);
@@ -176285,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)";
@@ -176308,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;
   }
@@ -178871,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);
@@ -180602,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);
@@ -183376,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));
 }
@@ -183421,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 = [];
@@ -183724,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("::");
@@ -185001,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([
   ":>",
@@ -185057,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
@@ -185115,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)
@@ -185146,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;
@@ -185210,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,
@@ -185264,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();
@@ -185372,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) {
@@ -185462,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)
@@ -185657,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);
@@ -185701,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);
@@ -185822,10 +186361,26 @@ var SysmlCodeLensProvider = class {
   constructor(services) {
     this.services = services;
   }
-  // TSK_023 — A "N references" lens above a definition (find-references on click).
-  referencesLens(node, uri, range) {
+  // TSK_023 — Every reference tally this pass needs, from one workspace sweep.
+  // A sweep resolves every written path in every document, so one per lens made
+  // a file with a dozen requirement definitions take seconds and the lenses
+  // never reached the editor.
+  referenceCounts(root4) {
+    const targets = [];
+    walkAst(root4, (node) => {
+      if (isRequirementDecl(node) && node.isDef && node.name)
+        targets.push(node);
+      if (isVerificationCaseDecl(node) && node.isDef && node.name)
+        targets.push(node);
+    });
     const refProvider = this.services.lsp.ReferencesProvider;
-    const count = typeof refProvider?.referenceCount === "function" ? refProvider.referenceCount(node) : 0;
+    if (typeof refProvider?.referenceCounts !== "function")
+      return /* @__PURE__ */ new Map();
+    return refProvider.referenceCounts(targets);
+  }
+  // TSK_023 — A "N references" lens above a definition (find-references on click).
+  referencesLens(node, uri, range, counts) {
+    const count = counts.get(node) ?? 0;
     return {
       range,
       command: {
@@ -185844,6 +186399,7 @@ var SysmlCodeLensProvider = class {
     const uri = document2.uri.toString();
     const requirements = indexByName(root4, "RequirementDecl");
     const parts = indexByName(root4, "PartDecl");
+    const counts = this.referenceCounts(root4);
     walkAst(root4, (node) => {
       const cst = node.$cstNode;
       if (!cst)
@@ -185877,7 +186433,7 @@ var SysmlCodeLensProvider = class {
         });
       }
       if (isRequirementDecl(node) && node.isDef && node.name) {
-        lenses.push(this.referencesLens(node, uri, range));
+        lenses.push(this.referencesLens(node, uri, range, counts));
       }
       if (isVerificationCaseDecl(node) && node.isDef && node.name) {
         const result = evaluateVerificationCase(node, (name) => requirements.get(name), (name) => parts.get(name));
@@ -185897,7 +186453,7 @@ var SysmlCodeLensProvider = class {
             arguments: [uri, node.name]
           }
         });
-        lenses.push(this.referencesLens(node, uri, range));
+        lenses.push(this.referencesLens(node, uri, range, counts));
       }
     });
     return lenses;
@@ -186113,6 +186669,14 @@ var SysmlReferencesProvider = class extends DefaultReferencesProvider {
   referenceCount(target) {
     return this.references.findReferences(target, { includeDeclaration: false }).count();
   }
+  // TSK_023 - One sweep answers every tally a CodeLens pass needs. Counting them
+  // one at a time repeats the whole written-path scan per lens.
+  referenceCounts(targets) {
+    const references = this.references;
+    if (typeof references?.referenceCounts === "function")
+      return references.referenceCounts(targets);
+    return new Map(targets.map((target) => [target, this.referenceCount(target)]));
+  }
 };
 
 // ../language-server/out/src/services/written-path-references.js
@@ -186128,6 +186692,53 @@ var WrittenPathReferences = class extends DefaultReferences {
     const segment = this.paths.segmentAt(source);
     return segment ? segment.target : super.findDeclaration(source);
   }
+  /**
+   * TSK_023 - How many references each target has, in ONE workspace sweep.
+   *
+   * `findReferences` resolves every written path in every document, so asking
+   * it per target multiplies that sweep by the number of targets. A CodeLens
+   * pass over a file with a dozen requirement definitions paid it a dozen
+   * times and took seconds, which reads in the editor as lenses that never
+   * appear. The tally below answers all of them from a single sweep.
+   */
+  referenceCounts(targets) {
+    const counts = new Map(targets.map((target) => [target, 0]));
+    if (targets.length === 0)
+      return counts;
+    const seen = new Map(targets.map((target) => [target, /* @__PURE__ */ new Set()]));
+    const byIdentity = /* @__PURE__ */ new Map();
+    for (const target of targets) {
+      const targetUri = ast_utils_exports.getDocument(target).uri.toString();
+      byIdentity.set(`${targetUri}|${this.nodeLocator.getAstNodePath(target)}`, target);
+      const found = seen.get(target);
+      for (const reference of super.findReferences(target, { includeDeclaration: false })) {
+        const key2 = `${reference.sourceUri}|${reference.segment.offset}`;
+        if (found.has(key2))
+          continue;
+        found.add(key2);
+        counts.set(target, (counts.get(target) ?? 0) + 1);
+      }
+    }
+    for (const document2 of this.documents.all) {
+      for (const node of ast_utils_exports.streamAllContents(document2.parseResult.value)) {
+        for (const path10 of this.paths.writtenPaths(node)) {
+          for (const segment of path10.segments) {
+            const description = segment.description;
+            const target = segment.target && counts.has(segment.target) ? segment.target : description ? byIdentity.get(`${description.documentUri.toString()}|${description.path}`) : void 0;
+            if (!target)
+              continue;
+            const found = seen.get(target);
+            const key2 = `${document2.uri}|${segment.cst.offset}`;
+            if (found.has(key2))
+              continue;
+            found.add(key2);
+            counts.set(target, (counts.get(target) ?? 0) + 1);
+          }
+        }
+      }
+    }
+    return counts;
+  }
   findReferences(target, options) {
     const result = super.findReferences(target, options).toArray();
     const targetUri = ast_utils_exports.getDocument(target).uri;
@@ -186996,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;
@@ -209624,7 +210237,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.31.1" : "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;