sysml-diagram 0.32.0 → 0.34.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;
@@ -175587,6 +175867,73 @@ function implicitSpecializationsFor(shared) {
   return created;
 }
 
+// ../language-server/out/src/services/modifier-order.js
+var MODIFIER_RANK = /* @__PURE__ */ new Map([
+  ["public", 0],
+  ["private", 0],
+  ["protected", 0],
+  ["in", 1],
+  ["out", 1],
+  ["inout", 1],
+  ["derived", 2],
+  ["abstract", 3],
+  ["variation", 4],
+  ["variant", 4],
+  ["composite", 5],
+  ["constant", 6],
+  ["const", 6],
+  ["ref", 7],
+  ["var", 8],
+  ["individual", 9],
+  ["snapshot", 10],
+  ["timeslice", 10]
+]);
+var CANONICAL_MODIFIER_ORDER = "visibility, direction, derived, abstract, variation, composite, constant, ref, var, individual, then the portion kind";
+function isRankedRun(modifiers2) {
+  return modifiers2.every((m) => MODIFIER_RANK.has(m));
+}
+function firstMisplacedModifier(modifiers2) {
+  if (modifiers2.length < 2 || !isRankedRun(modifiers2))
+    return void 0;
+  for (let index2 = 1; index2 < modifiers2.length; index2++) {
+    const rank = MODIFIER_RANK.get(modifiers2[index2]);
+    for (let before = 0; before < index2; before++) {
+      if (MODIFIER_RANK.get(modifiers2[before]) > rank)
+        return { index: index2, before };
+    }
+  }
+  return void 0;
+}
+var MODIFIER_PROPERTIES = ["modifiers", "postModifiers"];
+function modifierRunsOf(node) {
+  const runs = [];
+  if (!node.$cstNode)
+    return runs;
+  for (const property3 of MODIFIER_PROPERTIES) {
+    const modifiers2 = node[property3];
+    if (!Array.isArray(modifiers2) || modifiers2.length < 2)
+      continue;
+    if (!modifiers2.every((m) => typeof m === "string"))
+      continue;
+    if (!isRankedRun(modifiers2))
+      continue;
+    const nodes = grammar_utils_exports.findNodesForProperty(node.$cstNode, property3);
+    if (nodes.length !== modifiers2.length)
+      continue;
+    if (nodes.some((cst, index2) => cst.text !== modifiers2[index2]))
+      continue;
+    runs.push({ property: property3, modifiers: modifiers2, nodes });
+  }
+  return runs;
+}
+function isRewritableRun(source, run) {
+  const written = source.slice(run.nodes[0].offset, run.nodes[run.nodes.length - 1].end);
+  return new RegExp(`^${run.modifiers.join("[ \\t]+")}$`, "u").test(written);
+}
+function canonicalModifierOrder(modifiers2) {
+  return modifiers2.map((modifier, index2) => ({ modifier, index: index2, rank: MODIFIER_RANK.get(modifier) ?? 0 })).sort((a2, b) => a2.rank - b.rank || a2.index - b.index).map((entry) => entry.modifier);
+}
+
 // ../language-server/out/src/messages.js
 var DIAGNOSTIC_MESSAGES = {
   // REQ-006 - a broad diagram anchor cannot prove which typed occurrence owns
@@ -175600,6 +175947,10 @@ var DIAGNOSTIC_MESSAGES = {
   LEX004_INVALID_STRING_ESCAPE: (escape) => `Invalid escape '\\${escape}'. KerML Table 4 permits \\' \\" \\b \\f \\t \\n and \\\\.`,
   LEX008_NON_ASCII_IDENTIFIER: (name) => `Identifier '${name}' contains a non-ASCII character. Wrap it in single quotes ('${name}') to use it as an unrestricted name.`,
   LEX009_TRAILING_WHITESPACE: "Trailing whitespace.",
+  // issue #163: SYN025. The grammar accepts any permutation of the leading
+  // modifiers so a mis-ordered declaration still parses; this names the one word
+  // that is out of place and shows the whole prefix as the BNF writes it.
+  SYN025_MODIFIER_ORDER: (modifier, before, canonical) => `Modifier '${modifier}' must be written before '${before}'. The canonical declaration prefix order is ${CANONICAL_MODIFIER_ORDER}; write '${canonical}'.`,
   // REQ-385 — OMG SysML v2 Part 1 §7.17.3 restricts control nodes to the body of
   // an action definition or usage. Successions are NOT covered (§7.13.5 sanctions
   // `first a then b;` and the `then` occurrence shorthand in a part), so the
@@ -175737,6 +176088,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 +176748,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 +176765,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 +178673,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 +178776,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 +178943,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 +179734,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 +179799,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;
@@ -179841,6 +180213,7 @@ var SysmlValidator = class _SysmlValidator {
     this.checkActionFlowStyle(node, accept);
     this.checkKeywordOrdering(node, accept);
     this.checkModifierPlacement(node, accept);
+    this.checkModifierOrder(node, accept);
     this.checkEnumerations(node, accept);
     this.checkVariability(node, accept);
     this.checkMultiplicities(node, accept);
@@ -179854,6 +180227,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);
@@ -180648,6 +181022,46 @@ ${baseIndent}}`;
       }
     }
   }
+  // REQ-413 — SYN025 canonical order of the leading declaration modifiers.
+  //
+  // `DeclarationPrefix` accepts any permutation so that a mis-ordered prefix
+  // still parses; this is the rule that then says the order is wrong, and the
+  // only place that knows it is `modifier-order.ts`, shared with the quick fix
+  // and the formatter.
+  //
+  // Read off the parsed AST rather than the text, so a modifier word inside a
+  // comment, a string, a documentation body or a name can never reach it. A run
+  // holding a modifier with no canonical position is skipped whole
+  // (`UNRANKED_MODIFIERS`). One diagnostic per RUN, not per declaration: an end
+  // writes two prefixes (`end ref constant a;`), each with its own fix, but the
+  // fix rewrites a whole run, so a second squiggle within one run would name work
+  // the first has already done.
+  checkModifierOrder(node, accept) {
+    const source = ast_utils_exports.getDocument(node)?.textDocument.getText();
+    for (const child of ast_utils_exports.streamAllContents(node)) {
+      for (const run of modifierRunsOf(child)) {
+        const misplaced = firstMisplacedModifier(run.modifiers);
+        if (!misplaced)
+          continue;
+        const canonical = canonicalModifierOrder(run.modifiers).join(" ");
+        const first2 = run.nodes[0];
+        const last2 = run.nodes[run.nodes.length - 1];
+        accept(severity("SYN025", "warning"), DIAGNOSTIC_MESSAGES.SYN025_MODIFIER_ORDER(run.modifiers[misplaced.index], run.modifiers[misplaced.before], canonical), {
+          node: child,
+          range: run.nodes[misplaced.index].range,
+          code: "SYN025",
+          // The fix rewrites the whole run, so offer it only where a
+          // one-line replacement loses nothing.
+          ...source !== void 0 && isRewritableRun(source, run) ? {
+            data: {
+              replacement: canonical,
+              range: { start: first2.range.start, end: last2.range.end }
+            }
+          } : {}
+        });
+      }
+    }
+  }
   // REQ-409 - Enumeration definitions and usages specialize the general
   // variation, attribute and reference rules with a closed value inventory.
   checkEnumerations(node, accept) {
@@ -180784,7 +181198,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 +181638,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 +182010,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 +182028,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 +182041,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 +183104,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 +183880,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 +184173,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 ?? []);
     }
   }
@@ -184022,6 +184505,16 @@ function isAliasFixData(data) {
 function isReplacementFixData(data) {
   return typeof data === "object" && data !== null && typeof data.replacement === "string";
 }
+function isReorderFixData(data) {
+  if (typeof data !== "object" || data === null)
+    return false;
+  const { replacement, range } = data;
+  if (typeof replacement !== "string" || typeof range !== "object" || range === null)
+    return false;
+  const { start: start2, end } = range;
+  const isPosition = (p) => typeof p === "object" && p !== null && typeof p.line === "number" && typeof p.character === "number";
+  return isPosition(start2) && isPosition(end);
+}
 function leafAtOffset2(node, offset2) {
   if (isLeafCstNode(node)) {
     return node.offset <= offset2 && offset2 < node.offset + node.length ? node : void 0;
@@ -184192,6 +184685,18 @@ var SysmlCodeActionProvider = class {
           });
         }
       }
+      if (code === "SYN025" && isReorderFixData(diagnostic.data)) {
+        actions.push({
+          title: `Reorder modifiers to '${diagnostic.data.replacement}'`,
+          kind: import_vscode_languageserver18.CodeActionKind.QuickFix,
+          diagnostics: [diagnostic],
+          edit: {
+            changes: {
+              [uri]: [import_vscode_languageserver18.TextEdit.replace(diagnostic.data.range, diagnostic.data.replacement)]
+            }
+          }
+        });
+      }
       if (code === "RES021") {
         actions.push({
           title: "Make this root import 'private'",
@@ -184314,6 +184819,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 === "::**") {
@@ -184900,6 +185425,25 @@ ${line2.indent}${unit}`
     });
   }
 }
+function modifierOrderRewrites(document2, out) {
+  const root4 = document2.parseResult?.value;
+  if (!root4)
+    return;
+  const source = document2.textDocument.getText();
+  for (const node of ast_utils_exports.streamAllContents(root4)) {
+    for (const run of modifierRunsOf(node)) {
+      if (!firstMisplacedModifier(run.modifiers))
+        continue;
+      if (!isRewritableRun(source, run))
+        continue;
+      out.push({
+        offset: run.nodes[0].offset,
+        end: run.nodes[run.nodes.length - 1].end,
+        newText: canonicalModifierOrder(run.modifiers).join(" ")
+      });
+    }
+  }
+}
 function withinRange(document2, rewrite, range) {
   if (!range)
     return true;
@@ -184909,25 +185453,26 @@ function withinRange(document2, rewrite, range) {
 function styleEdits(input) {
   const { document: document2, settings, options, baseEdits, protectedRanges, range, reservedKeywords } = input;
   const wantsRewrite = settings.emptyBody !== "preserve" || settings.quotedNames !== "preserve" || settings.documentationIndent !== "preserve" || settings.keywords !== "preserve" || settings.lineWidth > 0;
-  if (!wantsRewrite)
-    return [];
   const leaves = leavesOf(document2);
   if (leaves.length === 0)
     return [];
-  const projection2 = projectFormatted(document2, baseEdits);
   const rewrites = [];
-  if (settings.keywords === "symbolic")
-    keywordRewrites(leaves, rewrites);
-  if (settings.emptyBody !== "preserve") {
-    emptyBodyRewrites(document2, leaves, projection2, settings, options, rewrites);
-  }
-  if (settings.quotedNames === "unquoteSafe")
-    quotedNameRewrites(leaves, reservedKeywords, rewrites);
-  if (settings.documentationIndent === "align") {
-    documentationRewrites(document2, leaves, projection2, options, rewrites);
-  }
-  if (settings.lineWidth > 0)
-    wrapRewrites(leaves, projection2, options, settings.lineWidth, rewrites);
+  modifierOrderRewrites(document2, rewrites);
+  if (wantsRewrite) {
+    const projection2 = projectFormatted(document2, baseEdits);
+    if (settings.keywords === "symbolic")
+      keywordRewrites(leaves, rewrites);
+    if (settings.emptyBody !== "preserve") {
+      emptyBodyRewrites(document2, leaves, projection2, settings, options, rewrites);
+    }
+    if (settings.quotedNames === "unquoteSafe")
+      quotedNameRewrites(leaves, reservedKeywords, rewrites);
+    if (settings.documentationIndent === "align") {
+      documentationRewrites(document2, leaves, projection2, options, rewrites);
+    }
+    if (settings.lineWidth > 0)
+      wrapRewrites(leaves, projection2, options, settings.lineWidth, rewrites);
+  }
   const doc = document2.textDocument;
   const source = doc.getText();
   const accepted = [];
@@ -184952,8 +185497,8 @@ function styleEdits(input) {
 
 // ../language-server/out/src/services/formatter.js
 var INDENT = Formatting.indent({ allowMore: true });
-var DEDENT = Formatting.noIndent();
 var NL = Formatting.newLine();
+var DEDENT_NL = { options: {}, moves: [{ lines: 1, tabs: -1 }] };
 var SPACE = Formatting.oneSpace();
 var NO_SPACE = Formatting.noSpace();
 var SysmlFormatter = class extends AbstractFormatter {
@@ -185079,14 +185624,15 @@ var SysmlFormatter = class extends AbstractFormatter {
    * leaves every other hidden-node path untouched.
    */
   createTextEdit(a2, b, formatting, context) {
-    const edits = super.createTextEdit(a2, b, formatting, context);
+    const action = formatting === DEDENT_NL && context.indentation <= 0 ? NL : formatting;
+    const edits = super.createTextEdit(a2, b, action, context);
     if (!b.hidden)
       return edits;
     const startRange = {
       start: { line: b.range.start.line, character: 0 },
       end: b.range.start
     };
-    context.indentation += this.findFittingMove(startRange, formatting.moves, context)?.tabs ?? 0;
+    context.indentation += this.findFittingMove(startRange, action.moves, context)?.tabs ?? 0;
     return edits;
   }
   // REQ-259 — Dispatch formatting from AST node kind
@@ -185215,10 +185761,10 @@ var SysmlFormatter = class extends AbstractFormatter {
   fmtBlock(node, keyword) {
     const f = this.getNodeFormatter(node);
     if (!isDocument(node.$container)) {
-      f.keyword(keyword).prepend(Formatting.newLines(1 + this.active.blankLines));
+      this.lineAnchor(node, f, keyword).prepend(Formatting.newLines(1 + this.active.blankLines));
     }
     f.keyword(keyword).append(SPACE);
-    this.fmtBraces(f);
+    this.fmtBraces(node, f);
   }
   // REQ-355 — Filtered imports keep the `[@Meta]` condition tight against the path
   fmtImport(node) {
@@ -185234,11 +185780,26 @@ var SysmlFormatter = class extends AbstractFormatter {
       ff.keyword("@@").append(NO_SPACE);
     }
   }
+  /**
+   * REQ-258 — Where a member's line break belongs.
+   *
+   * A declaration's kind keyword is NOT always its first token: a leading
+   * modifier (`derived ref attribute a;`), a visibility (`private package P;`)
+   * or a `standard library` marker is written ahead of it. Prepending the
+   * newline to the keyword split such a declaration over two lines. Ask the CST
+   * where the node actually starts rather than listing the words that can come
+   * first, so a grammar change cannot quietly reintroduce the split.
+   */
+  lineAnchor(node, f, keyword) {
+    const start2 = node.$cstNode?.offset;
+    const at = grammar_utils_exports.findNodeForKeyword(node.$cstNode, keyword)?.offset;
+    return start2 !== void 0 && at !== void 0 && at > start2 ? f.node(node) : f.keyword(keyword);
+  }
   // REQ-258, REQ-260 — Format one element per line with canonical keyword spacing
   fmtElement(node, keyword) {
     const f = this.getNodeFormatter(node);
     if (!isDocument(node.$container))
-      f.keyword(keyword).prepend(NL);
+      this.lineAnchor(node, f, keyword).prepend(NL);
     f.keyword(keyword).append(SPACE);
     if (node.isDef) {
       f.keyword("def").prepend(SPACE).append(SPACE);
@@ -185248,50 +185809,59 @@ var SysmlFormatter = class extends AbstractFormatter {
     f.keyword(":>>").surround(SPACE);
     f.keyword("=").surround(SPACE);
     f.keyword(";").prepend(NO_SPACE);
-    this.fmtBraces(f);
+    this.fmtBraces(node, f);
   }
   // REQ-260 — Keep multi-word `verification case` keyword phrase together
   fmtVerificationCase(node) {
     const f = this.getNodeFormatter(node);
     if (!isDocument(node.$container))
-      f.keyword("verification").prepend(NL);
+      this.lineAnchor(node, f, "verification").prepend(NL);
     f.keyword("verification").append(SPACE);
     f.keyword("case").append(SPACE);
     if (node.isDef)
       f.keyword("def").append(SPACE);
     f.keyword(":").surround(SPACE);
     f.keyword(";").prepend(NO_SPACE);
-    this.fmtBraces(f);
+    this.fmtBraces(node, f);
   }
   // REQ-260 — Keep multi-word `analysis case` keyword phrase together
   fmtAnalysisCase(node) {
     const f = this.getNodeFormatter(node);
     if (!isDocument(node.$container))
-      f.keyword("analysis").prepend(NL);
+      this.lineAnchor(node, f, "analysis").prepend(NL);
     f.keyword("analysis").append(SPACE);
     f.keyword("case").append(SPACE);
     if (node.isDef)
       f.keyword("def").append(SPACE);
     f.keyword(":").surround(SPACE);
     f.keyword(";").prepend(NO_SPACE);
-    this.fmtBraces(f);
+    this.fmtBraces(node, f);
   }
   // REQ-260 — Keep multi-word `use case` keyword phrase together
   fmtUseCase(node) {
     const f = this.getNodeFormatter(node);
     if (!isDocument(node.$container))
-      f.keyword("use").prepend(NL);
+      this.lineAnchor(node, f, "use").prepend(NL);
     f.keyword("use").append(SPACE);
     f.keyword("case").append(SPACE);
     if (node.isDef)
       f.keyword("def").append(SPACE);
     f.keyword(":").surround(SPACE);
     f.keyword(";").prepend(NO_SPACE);
-    this.fmtBraces(f);
+    this.fmtBraces(node, f);
   }
-  fmtBraces(f) {
+  /**
+   * REQ-258 — A block's braces.
+   *
+   * The closing brace steps back out only when the body actually stepped in.
+   * An EMPTY body never opened a level (`{` and `}` are adjacent, and the
+   * indent `{` appends is spent on `}` itself), so dedenting it would take the
+   * brace one level below its owner.
+   */
+  fmtBraces(node, f) {
     f.keyword("{").surround(SPACE).append(INDENT);
-    f.keyword("}").prepend(DEDENT).prepend(NL);
+    const members = node.members;
+    f.keyword("}").prepend(members && members.length > 0 ? DEDENT_NL : NL);
   }
 };
 
@@ -210237,7 +210807,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.32.0" : "dev";
+var VERSION2 = true ? "0.34.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;