sysml-diagram 0.32.0 → 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);
@@ -165375,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("."));
@@ -165762,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;
@@ -165778,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;
@@ -167111,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);
@@ -167280,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)
@@ -167819,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)
@@ -174588,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",
@@ -174660,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;
@@ -175737,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.
@@ -176390,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);
@@ -176404,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)
@@ -178295,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) {
@@ -178398,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;
@@ -178565,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;
@@ -179356,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",
@@ -179421,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;
@@ -179854,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);
@@ -180784,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);
@@ -181224,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
@@ -181553,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`:
   //
@@ -181570,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);
@@ -181583,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
@@ -182621,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;
@@ -183397,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;
@@ -183690,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 ?? []);
     }
   }
@@ -184314,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 === "::**") {
@@ -210237,7 +210628,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.32.0" : "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;