sysml-diagram 0.31.2 → 0.33.0

package/out/main.js

@@ -164097,7 +164097,7 @@ function boundValue(bound) {
 function declaredMultiplicity(node) {
   const feature = node;
   const body = feature.members?.find((member) => member.$type === "MultiplicityDecl");
-  const written = feature.multiplicity ?? body?.multiplicity;
+  const written = feature.multiplicity ?? body?.multiplicity ?? feature.innerMultiplicity ?? feature.endMultiplicity;
   if (!written) {
     for (const relationship of relationshipsOf(node)) {
       const tail = relationship.targets?.at(-1);
@@ -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)
@@ -165353,6 +165375,264 @@ function eventReferenceOf(node) {
   return { kind: "self", node };
 }
 
+// ../language-server/out/src/services/individuals.js
+var INDIVIDUAL_MULTIPLICITY = "[1]";
+var MAX_TYPE_DEPTH = 32;
+function modifiersOf(node) {
+  const decl = node;
+  const own = Array.isArray(decl.modifiers) ? decl.modifiers : [];
+  const post = Array.isArray(decl.postModifiers) ? decl.postModifiers : [];
+  const wrapper = prefixMetadataModifiersOf(node);
+  if (post.length === 0 && wrapper.length === 0)
+    return own;
+  return [...own, ...post, ...wrapper];
+}
+function prefixMetadataModifiersOf(node) {
+  const container = node.$container;
+  if (!container || container.$type !== "PrefixMetadataMember")
+    return [];
+  if (container.element !== node)
+    return [];
+  return Array.isArray(container.modifiers) ? container.modifiers : [];
+}
+function isIndividualDecl(node) {
+  return modifiersOf(node).includes("individual");
+}
+function portionKindOf(node) {
+  return modifiersOf(node).find((m) => m === "timeslice" || m === "snapshot");
+}
+function isDefinitionDecl(node) {
+  return node.isDef === true || node.$type === "BareDefDecl";
+}
+var NON_OCCURRENCE_DECL_TYPES = /* @__PURE__ */ new Set([
+  "AttributeDecl",
+  "EnumDecl",
+  "EnumValueDecl",
+  "MetadataDecl",
+  "MultiplicityDecl",
+  // A KerML `datatype` IS the data-valued root an attribute is typed by
+  // (KerML 8.3.4 DataType, which Occurrence deliberately does not specialize),
+  // so it has no life either. Its siblings stay OUT: a KerML `class` is by
+  // definition a classifier whose instances are occurrences, and `struct`,
+  // `assoc struct`, `behavior`, `function` and `predicate` all specialize it.
+  "DatatypeDecl"
+]);
+var NAMESPACE_DECL_TYPES = /* @__PURE__ */ new Set([
+  // Every name here is a real `$type` from the generated AST. `PackageDecl` and
+  // `ImportDecl` were both invented: the rules are `Package` and `Import`, so
+  // those two entries matched nothing and claimed a coverage they did not have.
+  "Package",
+  "NamespaceDecl",
+  "Document",
+  "AliasDecl",
+  "Import"
+]);
+var NON_OCCURRENCE_LABELS = {
+  AttributeDecl: "an attribute",
+  EnumDecl: "an enumeration",
+  EnumValueDecl: "an enumeration value",
+  MetadataDecl: "a metadata usage",
+  MultiplicityDecl: "a multiplicity",
+  DatatypeDecl: "a datatype",
+  Package: "a package",
+  NamespaceDecl: "a namespace",
+  AliasDecl: "an alias",
+  Import: "an import"
+};
+function nonOccurrenceLabel(node) {
+  return NON_OCCURRENCE_LABELS[node.$type] ?? "not an occurrence";
+}
+function isOccurrenceShapedDecl(node) {
+  return !NON_OCCURRENCE_DECL_TYPES.has(node.$type) && !NAMESPACE_DECL_TYPES.has(node.$type);
+}
+function writtenTypesOf(node) {
+  const decl = node;
+  const out = [];
+  for (const typing of [decl.typing, ...decl.moreTypings ?? []]) {
+    if (!typing)
+      continue;
+    const conjugated = typing.conjugate === true;
+    for (const ref of [typing.type, ...typing.moreTypes ?? []]) {
+      const text = ref?.$refText?.trim();
+      if (text)
+        out.push({ text, ref: ref?.ref, conjugated });
+    }
+  }
+  return out;
+}
+function candidatesOf(node) {
+  const out = [];
+  for (const written of writtenTypesOf(node)) {
+    if (written.conjugated)
+      continue;
+    out.push({ text: written.text, ref: written.ref });
+  }
+  for (const target of specializationTargetsOf(node))
+    out.push({ text: target });
+  return out;
+}
+var TRANSPARENT_WRAPPER_TYPES = /* @__PURE__ */ new Set([
+  "PrefixMetadataMember",
+  "MemberPrefixDecl",
+  "ThenActionMember"
+]);
+var OWNER_WALK_STOPS = /* @__PURE__ */ new Set([
+  "Package",
+  "PackageDecl",
+  "NamespaceDecl",
+  "Document"
+]);
+function owningOccurrenceOf(node) {
+  let owner = node.$container;
+  while (owner && TRANSPARENT_WRAPPER_TYPES.has(owner.$type))
+    owner = owner.$container;
+  if (!owner || OWNER_WALK_STOPS.has(owner.$type))
+    return void 0;
+  return NON_OCCURRENCE_DECL_TYPES.has(owner.$type) ? void 0 : owner;
+}
+var MAX_ALIAS_HOPS = 8;
+var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([
+  ":>",
+  "subsets",
+  ":>>",
+  "redefines",
+  "specializes",
+  "subtype"
+]);
+function specializationTargetsOf(node) {
+  const decl = node;
+  const out = [];
+  for (const rel2 of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
+    if (!rel2.kind || !SPECIALIZATION_KINDS3.has(rel2.kind))
+      continue;
+    for (const target of rel2.targets ?? []) {
+      const text = target.trim();
+      if (text)
+        out.push(text);
+    }
+  }
+  return out;
+}
+function linkedIndividualDefinitionsOf(node) {
+  return individualClosureOf(node, documentLocalResolverFor(node)).definitions;
+}
+function documentLocalResolverFor(node) {
+  const resolve8 = localResolverFor(node);
+  return (name) => {
+    const candidates = resolve8(name, node).filter((candidate) => candidate.node);
+    return candidates.length === 1 ? candidates[0].node : void 0;
+  };
+}
+function individualClosureOf(node, resolve8) {
+  const definitions = [];
+  const seenNodes = /* @__PURE__ */ new Set([node]);
+  let complete = true;
+  const record = (text, target) => {
+    if (!isIndividualDecl(target) || !isDefinitionDecl(target))
+      return;
+    if (definitions.some((each) => each.node === target))
+      return;
+    definitions.push({ text, node: target });
+  };
+  const targetOf = (candidate) => dealias(candidate.ref ?? resolve8(candidate.text));
+  const dealias = (target) => {
+    let current2 = target;
+    for (let hop = 0; current2?.$type === "AliasDecl" && hop < MAX_ALIAS_HOPS; hop++) {
+      const to = current2.target;
+      current2 = to ? resolve8(to) : void 0;
+    }
+    return current2?.$type === "AliasDecl" ? void 0 : current2;
+  };
+  const walk = (current2, depth) => {
+    if (depth > MAX_TYPE_DEPTH) {
+      complete = false;
+      return;
+    }
+    const ordinaryDefinition = isDefinitionDecl(current2) && !isIndividualDecl(current2);
+    for (const candidate of candidatesOf(current2)) {
+      const target = targetOf(candidate);
+      if (!target) {
+        if (!ordinaryDefinition)
+          complete = false;
+        continue;
+      }
+      record(candidate.text, target);
+      if (seenNodes.has(target))
+        continue;
+      seenNodes.add(target);
+      walk(target, depth + 1);
+    }
+  };
+  walk(node, 0);
+  if (portionKindOf(node)) {
+    const owner = owningOccurrenceOf(node);
+    if (owner) {
+      const inherited = individualClosureOf(owner, resolve8);
+      for (const each of inherited.definitions)
+        record(each.text, each.node);
+      if (!inherited.complete)
+        complete = false;
+    }
+  }
+  const direct = [];
+  for (const written of writtenTypesOf(node)) {
+    if (written.conjugated)
+      continue;
+    const target = targetOf(written);
+    if (!target || !isIndividualDecl(target) || !isDefinitionDecl(target))
+      continue;
+    if (direct.some((each) => each.node === target))
+      continue;
+    direct.push({ text: written.text, node: target });
+  }
+  return { definitions, direct, complete };
+}
+function identityOf(node) {
+  if (!isIndividualDecl(node) && !portionKindOf(node))
+    return void 0;
+  return effectiveIndividualOf(node, linkedIndividualDefinitionsOf(node));
+}
+function effectiveIndividualOf(node, definitions = []) {
+  const explicit = isIndividualDecl(node);
+  const portion = portionKindOf(node);
+  if (!explicit && !portion)
+    return void 0;
+  return {
+    explicit,
+    portion,
+    definition: definitions[0]?.text,
+    multiplicity: writtenMultiplicityTextOf(node) ?? INDIVIDUAL_MULTIPLICITY
+  };
+}
+function boundTextOf(bound) {
+  if (!bound)
+    return void 0;
+  if (bound.star)
+    return "*";
+  if (typeof bound.intVal === "number")
+    return String(bound.intVal);
+  return bound.bound;
+}
+function writtenMultiplicityTextOf(node) {
+  const decl = node;
+  const mult = decl.multiplicity ?? decl.innerMultiplicity ?? decl.endMultiplicity;
+  if (!mult)
+    return void 0;
+  const lo = boundTextOf(mult.lower);
+  const hi = boundTextOf(mult.upper);
+  if (lo === void 0 && hi === void 0)
+    return void 0;
+  return hi === void 0 || hi === lo ? `[${lo}]` : `[${lo}..${hi}]`;
+}
+function individualModifierCarrier(node) {
+  const own = node;
+  if ((own.modifiers ?? []).includes("individual"))
+    return node;
+  if ((own.postModifiers ?? []).includes("individual"))
+    return node;
+  return prefixMetadataModifiersOf(node).includes("individual") ? node.$container : void 0;
+}
+
 // ../language-server/out/src/services/diagram-model-provider.js
 var lastSeg = (name) => {
   const i = Math.max(name.lastIndexOf("::"), name.lastIndexOf("."));
@@ -165740,12 +166020,12 @@ var withoutCompartments = (compartments, ...titles) => {
   const kept = (compartments ?? []).filter((compartment) => !titles.includes(compartment.title));
   return kept.length ? kept : void 0;
 };
-var modifiersOf = (node) => {
+var modifiersOf2 = (node) => {
   const mods = node.modifiers;
   return Array.isArray(mods) ? mods : [];
 };
 var ANONYMOUS_INTERFACE_NAME = "(anonymous)";
-var isEndMember = (node) => node.$type === "EndDecl" || modifiersOf(node).includes("end");
+var isEndMember = (node) => node.$type === "EndDecl" || modifiersOf2(node).includes("end");
 function endRowText(node) {
   const end = node;
   const name = nameOf2(node) ?? end.innerName;
@@ -165756,9 +166036,28 @@ function endRowText(node) {
     return void 0;
   return `${head2}${mult ? ` ${mult}` : ""}`;
 }
-var portionKindOf = (node) => modifiersOf(node).find((m) => m === "timeslice" || m === "snapshot");
-var isIndividualOccurrence = (node) => modifiersOf(node).includes("individual");
+var isIndividualOccurrence = isIndividualDecl;
 var isOccurrenceModified = (node) => portionKindOf(node) !== void 0 || isIndividualOccurrence(node);
+var mergedIndividualMeta = (node, existing) => {
+  const identity6 = individualMetaOf(node);
+  if (!identity6)
+    return {};
+  return { meta: { ...identity6, ...existing ?? {} } };
+};
+var individualMetaOf = (node) => {
+  const effective = identityOf(node);
+  if (!effective)
+    return void 0;
+  const isDef = isDefinitionDecl(node);
+  return {
+    individual: {
+      explicit: effective.explicit,
+      ...isDef ? {} : { multiplicity: effective.multiplicity },
+      ...!isDef && effective.definition ? { definition: effective.definition } : {},
+      ...effective.portion ? { portion: effective.portion } : {}
+    }
+  };
+};
 var redefinedNameOf = (node) => {
   const names = effectiveNamesOf(node, localResolverFor(node));
   return names.origin === "derived" || names.origin === "written" ? names.name ?? names.shortName : void 0;
@@ -167089,7 +167388,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   isInheritedLibraryBackboneFeature(source, usage, index2) {
     if (!isLibraryDocument(ast_utils_exports.getDocument(usage)))
       return false;
-    if (modifiersOf(usage).includes("abstract"))
+    if (modifiersOf2(usage).includes("abstract"))
       return true;
     const ownerType = source.isDef === true ? source : this.resolveType(source, index2);
     const usageType = this.resolveType(usage, index2);
@@ -167258,7 +167557,10 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         compartments: extra?.compartments ?? this.compartmentsFor(n2, uri, index2, shape === "box"),
         ...packageOf2(n2),
         source: sourceOf2(n2, uri),
-        ...extra
+        ...extra,
+        // issue #162 — identity meta merges UNDER whatever the caller
+        // passes, so a caller's own `meta` never loses a key to it.
+        ...mergedIndividualMeta(n2, extra?.meta)
       });
     };
     for (const n2 of defNodes)
@@ -167797,7 +168099,7 @@ ${edge.to}`));
         gvTypeInherited: usage && !typeText(original) && !!definition || void 0,
         // REQ-405 - Tree alias suppression follows an explicit ref.
         // Intrinsic references such as package parts remain visible.
-        gvTreeExcluded: modifiersOf(original).includes("ref") && (!valueTextOf(original) || isPathExpr(original.value) || !!referenceTarget && belongsToDrawnFeatureTree(referenceTarget)) || void 0,
+        gvTreeExcluded: modifiersOf2(original).includes("ref") && (!valueTextOf(original) || isPathExpr(original.value) || !!referenceTarget && belongsToDrawnFeatureTree(referenceTarget)) || void 0,
         ...directionOf(original) ? { direction: directionOf(original) } : {}
       };
       if (!ownerId || !byId.has(ownerId) || ownerId === node.id)
@@ -174359,7 +174661,6 @@ var sysmlInlayHintSettings = {
   dimension: false,
   visibility: false,
   modifiers: false,
-  specialization: false,
   redefinition: false,
   effectiveNames: false,
   importedNames: false,
@@ -174567,7 +174868,7 @@ function outlineGroupForType(astType) {
 }
 
 // ../language-server/out/src/services/document-symbol-provider.js
-var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([":>", "specializes"]);
+var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([":>", "specializes"]);
 var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var INHERITABLE_FEATURE_TYPES = /* @__PURE__ */ new Set([
   "ActionDecl",
@@ -174639,7 +174940,7 @@ function specializationTargets2(node) {
   const n2 = node;
   const out = [];
   for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
-    if (rel2.kind && SPECIALIZATION_KINDS3.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS4.has(rel2.kind))
       out.push(...rel2.targets ?? []);
   }
   return out;
@@ -175025,6 +175326,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
@@ -175175,6 +176017,13 @@ var DIAGNOSTIC_MESSAGES = {
   SSM025_ACTION_PARAMETER_DIRECTION: (position, mine, typeName, theirs) => `Parameter ${position} is '${mine}' but the corresponding parameter of '${typeName}' is '${theirs}'. Positional correspondence redefines that parameter, and a redefinition cannot reverse a parameter's direction.`,
   SSM026_REDEFINITION_DIRECTION: (feature, mine, theirs) => `Direction '${mine}' reverses the redefined feature '${feature}', which is '${theirs}'. A redefinition refines a feature \u2014 it cannot turn an input into an output.`,
   SSM027_INTERFACE_END_TYPE: (position, endType, definition, expected) => `End ${position} is a '${endType}', but '${definition}' declares that end as '${expected}'. An interface usage connects through the ends its definition declares.`,
+  // issue #162 — individual identity (OMG SysML v2 Part 1 §7.9.4 Individuals).
+  // Each message names the life the model claims and the thing that cannot have
+  // one, because the fix is always to move the keyword or to name the definition
+  // that carries the identity.
+  SSM040_INDIVIDUAL_NOT_OCCURRENCE: (name, kind) => `'individual' names one occurrence with an identity of its own, and ${name} is ${kind}, which has no life to identify. Remove 'individual', or move it to the occurrence this belongs to.`,
+  SSM041_INDIVIDUAL_MULTIPLE_DEFINITIONS: (name, first2, second) => `${name} is typed by two individual definitions, '${first2}' and '${second}'. An individual usage names ONE life, so at most one of its types may be an 'individual def'.`,
+  SSM042_INDIVIDUAL_WITHOUT_DEFINITION: (name) => `${name} is declared 'individual' but names no individual definition. An individual usage is typed by exactly one 'individual def' - the definition that carries the identity it names.`,
   // 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.
@@ -175379,6 +176228,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 +176328,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 +176392,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 +176462,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 +176635,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 ?? [])
@@ -175822,6 +176677,9 @@ ${headerLines.join("\n")}
   if (composition.isFeature) {
     parts.push(`*Ownership:* ${composition.isComposite ? "Composite feature" : "Referential feature"}`);
   }
+  const individual = individualSection(node);
+  if (individual)
+    parts.push(individual);
   const subject = subjectInheritanceSection(node);
   if (subject)
     parts.push(subject);
@@ -175836,6 +176694,23 @@ ${headerLines.join("\n")}
   parts.push(sourceFooter(nodeSource(node)));
   return parts.join("\n\n");
 }
+function writesOwnMultiplicity(node) {
+  const n2 = node;
+  return n2.multiplicity !== void 0 || n2.innerMultiplicity !== void 0 || n2.endMultiplicity !== void 0;
+}
+function individualSection(node) {
+  const effective = identityOf(node);
+  if (!effective)
+    return void 0;
+  if (isDefinitionDecl(node)) {
+    return effective.explicit ? "*Individual:* one life. Every usage of this definition is a portion of the same occurrence." : void 0;
+  }
+  if (!effective.explicit && !effective.definition)
+    return void 0;
+  const identity6 = effective.definition ? `the life of \`${effective.definition}\`` : "one life";
+  const what = effective.portion ? `A \`${effective.portion}\` of ${identity6}` : `Identifies ${identity6}`;
+  return writesOwnMultiplicity(node) ? `*Individual:* ${what}.` : `*Individual:* ${what}, so it has multiplicity \`${effective.multiplicity}\`.`;
+}
 function subjectInheritanceSection(node) {
   const effective = resolveEffectiveSubject(node);
   if (!effective || !effective.inherited)
@@ -176162,12 +177037,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 +177189,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 +177214,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;
   }
@@ -177718,7 +178602,7 @@ var import_vscode_languageserver16 = __toESM(require_main4(), 1);
 
 // ../language-server/out/src/services/metadata-filter.js
 var INCONCLUSIVE2 = { kind: "inconclusive" };
-var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([":>", "specializes", ":>>", "redefines", "subsets"]);
+var SPECIALIZATION_KINDS5 = /* @__PURE__ */ new Set([":>", "specializes", ":>>", "redefines", "subsets"]);
 var MAX_SPECIALIZATION_DEPTH = 32;
 var MAX_VALUE_DEPTH = 16;
 function evaluateFilterCondition(condition, element, options) {
@@ -177821,7 +178705,7 @@ function declaresFeature2(node, name) {
   if (node.name === name)
     return true;
   for (const rel2 of [...node.preRelationships ?? [], ...node.relationships ?? []]) {
-    if (rel2.kind && SPECIALIZATION_KINDS4.has(rel2.kind) && (rel2.targets ?? []).includes(name))
+    if (rel2.kind && SPECIALIZATION_KINDS5.has(rel2.kind) && (rel2.targets ?? []).includes(name))
       return true;
   }
   return false;
@@ -177988,7 +178872,7 @@ function nameScope(ctx, depth = 0) {
 function specializationTargets3(node) {
   const targets = [];
   for (const rel2 of [...node.preRelationships ?? [], ...node.relationships ?? []]) {
-    if (rel2.kind && SPECIALIZATION_KINDS4.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS5.has(rel2.kind))
       targets.push(...rel2.targets ?? []);
   }
   return targets;
@@ -178779,7 +179663,7 @@ function maskNonCode(text) {
   }
   return out.join("");
 }
-var SPECIALIZATION_KINDS5 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS6 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 var CONSTRAINT_SIDE_EFFECT_TYPES = /* @__PURE__ */ new Set([
   "AssignNode",
   "SendNode",
@@ -178844,12 +179728,6 @@ function actionOnlyConstruct(node) {
   const keyword = CONTROL_NODE_KEYWORDS[node.$type];
   return keyword ? { construct: `A '${keyword}' control node`, clause: "7.17.3" } : void 0;
 }
-function portionKindOf2(node) {
-  const mods = node.modifiers;
-  if (!Array.isArray(mods))
-    return void 0;
-  return mods.find((m) => m === "timeslice" || m === "snapshot");
-}
 var NAMESPACE_ONLY_TYPES = /* @__PURE__ */ new Set(["Package", "Document", "NamespaceDecl"]);
 function owningTypeOf(node) {
   let owner = node.$container;
@@ -178897,12 +179775,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);
@@ -179271,6 +180155,7 @@ var SysmlValidator = class _SysmlValidator {
     this.checkKermlWellFormedness(node, accept);
     this.checkFilterExpressions(node, accept);
     this.checkOccurrencePortions(node, accept);
+    this.checkIndividualDeclarations(node, accept);
     this.checkCrossReferences(node, accept);
     this.checkAutoImportSuggestions(node, accept);
     this.checkUnits(node, accept);
@@ -180201,7 +181086,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_KINDS5.has(relation.kind))
+          if (!relation.kind || !SPECIALIZATION_KINDS6.has(relation.kind))
             continue;
           for (let index2 = 0; index2 < (relation.targets?.length ?? 0); index2 += 1) {
             const resolution = this.featurePaths.resolvePropertyPath(relation, "targets", index2);
@@ -180628,7 +181513,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);
@@ -180641,6 +181526,49 @@ ${baseIndent}}`;
       this.checkActionParameterCorrespondence(decl, model, accept);
       this.checkRedefinitionDirection(decl, index2, accept);
       this.checkInterfaceEndTypes(decl, model, index2, accept);
+      this.checkIndividualDefinitions(decl, model, accept);
+    }
+  }
+  // issue #162 — SSM041 / SSM042: the identity an individual usage names.
+  //
+  // OMG SysML v2 Part 1 §7.9.4 derives `OccurrenceUsage::individualDefinition`
+  // as the usage's types that are individual occurrence definitions, and
+  // constrains it twice: at most one for ANY occurrence usage, and exactly one
+  // for a usage written `individual`. Both say the same thing — an individual
+  // usage names ONE life — from the two sides.
+  //
+  //  SSM041 — two individual definitions written on the same usage. Judged on the
+  //           DIRECTLY written types only, exactly as the metamodel derives them:
+  //           reaching a second identity through a supertype is how the canonical
+  //           models legitimately relate an individual to the family it belongs to.
+  //  SSM042 — an `individual` usage that reaches no individual definition at all.
+  //           Judged over the whole type-and-specialization walk, because a usage
+  //           inherits identity (`individual timeslice t :> ind;` takes its
+  //           definition from the `ind` it subsets), and only when that walk was
+  //           COMPLETE: an unread supertype may never be read as an absence.
+  // issue #162 — the node whose own text contains the `individual` keyword. It is
+  // the declaration itself, unless an enclosing `#Tag` wrapper carries the prefix.
+  // REQ-412 — SSM041/SSM042: the identity an individual usage names
+  checkIndividualDefinitions(decl, model, accept) {
+    if (decl.isDef === true || decl.$type === "BareDefDecl")
+      return;
+    if (!isOccurrenceShapedDecl(decl))
+      return;
+    const explicit = isIndividualDecl(decl);
+    if (!explicit && writtenTypesOf(decl).filter((each) => !each.conjugated).length < 2)
+      return;
+    const closure2 = individualClosureOf(decl, (name) => model.declarationOf(name));
+    const label = decl.name ? `'${decl.name}'` : `This '${kindLabel2(decl)}'`;
+    if (closure2.direct.length > 1) {
+      accept(severity("SSM041", "error"), DIAGNOSTIC_MESSAGES.SSM041_INDIVIDUAL_MULTIPLE_DEFINITIONS(label, closure2.direct[0].text, closure2.direct[1].text), {
+        node: decl,
+        code: "SSM041",
+        relatedInformation: declarationSite(closure2.direct[1].node, closure2.direct[1].text)
+      });
+      return;
+    }
+    if (explicit && closure2.definitions.length === 0 && closure2.complete) {
+      accept(severity("SSM042", "error"), DIAGNOSTIC_MESSAGES.SSM042_INDIVIDUAL_WITHOUT_DEFINITION(label), { node: decl, code: "SSM042" });
     }
   }
   // REQ-390 — SSM017: a redefining feature narrows the feature it redefines, so
@@ -180970,8 +181898,9 @@ ${baseIndent}}`;
   // SysML usage kind IS an OccurrenceUsage (part, item, action, state, port,
   // connection, case, …) while the data-valued ones are few and closed: an
   // AttributeUsage is typed by a DataType and an enumeration is a special attribute,
-  // neither of which has a life to carve up.
-  static NON_OCCURRENCE_OWNER_TYPES = /* @__PURE__ */ new Set(["AttributeDecl", "EnumDecl", "EnumValueDecl", "MetadataDecl", "MultiplicityDecl"]);
+  // neither of which has a life to carve up. issue #162 — SSM040 judges an
+  // `individual` against the same list, so the two share one spelling of it.
+  static NON_OCCURRENCE_OWNER_TYPES = NON_OCCURRENCE_DECL_TYPES;
   // REQ-160 — OMG SysML v2 §8.2.2.9 (Occurrences) with the Kernel Semantic Library
   // `Occurrences::TimeSlice` / `Occurrences::Snapshot`:
   //
@@ -180987,7 +181916,7 @@ ${baseIndent}}`;
   // without resolving a single cross-reference.
   checkOccurrencePortions(node, accept) {
     for (const child of ast_utils_exports.streamAllContents(node)) {
-      const kind = portionKindOf2(child);
+      const kind = portionKindOf(child);
       if (!kind)
         continue;
       const label = declLabel(child, kind);
@@ -181000,11 +181929,36 @@ ${baseIndent}}`;
         accept(severity("SSM015", "error"), `A '${kind}' is a portion of an occurrence's life, and '${owner.name ?? owner.$type}' is not an occurrence.`, { node: child, code: "SSM015" });
         continue;
       }
-      if (kind === "timeslice" && portionKindOf2(owner) === "snapshot") {
+      if (kind === "timeslice" && portionKindOf(owner) === "snapshot") {
         accept(severity("SSM016", "error"), `A 'snapshot' is a zero-duration timeslice, so ${label} cannot be a timeslice of it - a portion of an instant is itself a snapshot.`, { node: child, code: "SSM016" });
       }
     }
   }
+  // ══════════════════════════════════════════════════════════════════════
+  // issue #162 — SSM040: `individual` presupposes an occurrence
+  // ══════════════════════════════════════════════════════════════════════
+  // OMG SysML v2 Part 1 §7.9.4 puts `isIndividual` on OccurrenceDefinition and
+  // OccurrenceUsage, and nowhere else. An attribute is typed by a DataType and
+  // has no life; a package is a namespace and is not a type at all. Writing
+  // `individual` there claims an identity over time for something that has none.
+  //
+  // Structural: it reads the modifier and the declaration kind only, so it holds
+  // with nothing resolved. The quick fix removes the keyword.
+  // REQ-412 — SSM040: `individual` on a declaration that is not an occurrence
+  checkIndividualDeclarations(node, accept) {
+    for (const child of ast_utils_exports.streamAllContents(node)) {
+      if (!isIndividualDecl(child) || isOccurrenceShapedDecl(child))
+        continue;
+      const name = child.name;
+      const carrier = individualModifierCarrier(child);
+      accept(severity("SSM040", "error"), DIAGNOSTIC_MESSAGES.SSM040_INDIVIDUAL_NOT_OCCURRENCE(name ? `'${name}'` : "this declaration", nonOccurrenceLabel(child)), {
+        node: child,
+        code: "SSM040",
+        data: { individualModifier: true },
+        ...carrier?.$cstNode ? { range: carrier.$cstNode.range } : {}
+      });
+    }
+  }
   // REQ-328 — KSM008: a `filter` membership condition must be Boolean. Only a
   // *definitely* non-Boolean expression is flagged — a string or numeric/quantity
   // literal, or an arithmetic/range binary expression. A bare feature path is left
@@ -182038,7 +182992,7 @@ function specializationTargets4(node) {
     ...node.relationships ?? []
   ];
   for (const rel2 of rels) {
-    if (rel2.kind && SPECIALIZATION_KINDS5.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS6.has(rel2.kind))
       out.push(...rel2.targets);
   }
   return out;
@@ -182814,12 +183768,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_KINDS6 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS7 = /* @__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_KINDS6.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS7.has(rel2.kind))
       out.push(...rel2.targets ?? []);
   }
   return out;
@@ -183107,12 +184061,12 @@ function directImportEntries(imp, descriptions) {
   }
   return applyFilters(imp, selectMemberships(path10, form, descriptions), options);
 }
-var SPECIALIZATION_KINDS7 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS8 = /* @__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_KINDS7.has(relationship.kind)) {
+    if (relationship.kind && SPECIALIZATION_KINDS8.has(relationship.kind)) {
       targets.push(...relationship.targets ?? []);
     }
   }
@@ -183402,6 +184356,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 +184416,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 = [];
@@ -183712,6 +184685,26 @@ ${indent}}`)]
           }
         });
       }
+      if (code === "SSM040" && diagnostic.data && diagnostic.data.individualModifier === true) {
+        const declText = document2.textDocument.getText(diagnostic.range);
+        const match = /\bindividual\b[ \t]*/u.exec(declText);
+        if (match) {
+          const start2 = document2.textDocument.offsetAt(diagnostic.range.start) + match.index;
+          actions.push({
+            title: "Remove 'individual'",
+            kind: import_vscode_languageserver18.CodeActionKind.QuickFix,
+            diagnostics: [diagnostic],
+            edit: {
+              changes: {
+                [uri]: [import_vscode_languageserver18.TextEdit.replace({
+                  start: document2.textDocument.positionAt(start2),
+                  end: document2.textDocument.positionAt(start2 + match[0].length)
+                }, "")]
+              }
+            }
+          });
+        }
+      }
       if (code === "STYL006") {
         const suffix = document2.textDocument.getText(diagnostic.range).replace(/\s+/gu, "");
         if (suffix === "::**") {
@@ -183750,6 +184743,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 +186033,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 +186077,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 +186111,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 +186137,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 +186201,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 +186245,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 +186352,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 +186422,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 +186617,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 +186661,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 +187998,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 +210628,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.31.2" : "dev";
+var VERSION2 = true ? "0.33.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;