sysml-validate 0.15.7 → 0.16.0

package/out/main.js

@@ -4108,21 +4108,21 @@ var require_main2 = __commonJS({
         }
         TextDocumentItem3.is = is;
       })(TextDocumentItem2 || (exports3.TextDocumentItem = TextDocumentItem2 = {}));
-      var MarkupKind3;
-      (function(MarkupKind4) {
-        MarkupKind4.PlainText = "plaintext";
-        MarkupKind4.Markdown = "markdown";
+      var MarkupKind4;
+      (function(MarkupKind5) {
+        MarkupKind5.PlainText = "plaintext";
+        MarkupKind5.Markdown = "markdown";
         function is(value) {
           var candidate = value;
-          return candidate === MarkupKind4.PlainText || candidate === MarkupKind4.Markdown;
+          return candidate === MarkupKind5.PlainText || candidate === MarkupKind5.Markdown;
         }
-        MarkupKind4.is = is;
-      })(MarkupKind3 || (exports3.MarkupKind = MarkupKind3 = {}));
+        MarkupKind5.is = is;
+      })(MarkupKind4 || (exports3.MarkupKind = MarkupKind4 = {}));
       var MarkupContent2;
       (function(MarkupContent3) {
         function is(value) {
           var candidate = value;
-          return Is2.objectLiteral(value) && MarkupKind3.is(candidate.kind) && Is2.string(candidate.value);
+          return Is2.objectLiteral(value) && MarkupKind4.is(candidate.kind) && Is2.string(candidate.value);
         }
         MarkupContent3.is = is;
       })(MarkupContent2 || (exports3.MarkupContent = MarkupContent2 = {}));
@@ -24188,14 +24188,14 @@ var TextDocumentItem;
   TextDocumentItem2.is = is;
 })(TextDocumentItem || (TextDocumentItem = {}));
 var MarkupKind;
-(function(MarkupKind3) {
-  MarkupKind3.PlainText = "plaintext";
-  MarkupKind3.Markdown = "markdown";
+(function(MarkupKind4) {
+  MarkupKind4.PlainText = "plaintext";
+  MarkupKind4.Markdown = "markdown";
   function is(value) {
     const candidate = value;
-    return candidate === MarkupKind3.PlainText || candidate === MarkupKind3.Markdown;
+    return candidate === MarkupKind4.PlainText || candidate === MarkupKind4.Markdown;
   }
-  MarkupKind3.is = is;
+  MarkupKind4.is = is;
 })(MarkupKind || (MarkupKind = {}));
 var MarkupContent;
 (function(MarkupContent2) {
@@ -57803,7 +57803,14 @@ var sysmlOutlineSettings = {
   hiddenCategories: []
 };
 var sysmlInlayHintSettings = {
-  dimension: false
+  enabled: true,
+  multiplicity: true,
+  dimension: false,
+  visibility: false,
+  modifiers: false,
+  specialization: false,
+  redefinition: false,
+  effectiveNames: false
 };
 function asDiagnosticLevel(value, fallback = "off") {
   return value === "off" || value === "warning" || value === "error" ? value : fallback;
@@ -58685,7 +58692,16 @@ var DIAGNOSTIC_MESSAGES = {
   SSM025_ACTION_PARAMETER_COUNT: (usage, declared, typeName, available) => `'${usage}' declares ${declared} directed parameter${declared === 1 ? "" : "s"} but its definition '${typeName}' has ${available}. An action usage's parameters correspond positionally to its definition's, so there is no ${available === 0 ? "parameter" : `${available + 1}th parameter`} to correspond to.`,
   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.`
+  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.`,
+  // 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.
+  STYL008_FORMAT_DIRECTIVE_UNATTACHED: "This `sysml-format ignore` directive has no element after it to attach to, so nothing is preserved. Move it directly above the element whose layout you want to keep.",
+  // REQ-345, REQ-393 — the formatter-settings refusal is shown to the user
+  // through `window/showWarningMessage`, so its text lives here like every
+  // other reviewable string rather than inline at the call site.
+  FORMAT_SETTINGS_REFUSED: (detail) => `SysML formatter settings ignored (${detail}). The previous value is still in use.`,
+  STYL008_FORMAT_DIRECTIVE_UNKNOWN: (argument) => `Unknown formatter directive '${argument || "(none)"}'. The only directive is 'sysml-format ignore', which preserves the next element's layout.`
 };
 var KEYWORD_TOOLTIPS = {
   // Package / namespace
@@ -58882,6 +58898,107 @@ var OPERATOR_TOOLTIPS = {
   "@@": { desc: "**Metaclass application** \u2014 applies a metaclass annotation.", precedence: 0, example: "@@StandardProfile", cite: "OMG SysML v2.0 Part 1 \xA78.2.2.27 (Metadata)" }
 };
 
+// ../language-server/out/src/services/format-directives.js
+var DIRECTIVE_WORD = "sysml-format";
+var IGNORE_ARGUMENT = "ignore";
+var EMPTY_SCAN = { directives: [], protectedRanges: [] };
+function commentBody(text) {
+  if (text.startsWith("//*") && text.endsWith("*/") && text.length >= 5)
+    return text.slice(3, -2);
+  if (text.startsWith("//"))
+    return text.slice(2);
+  if (text.startsWith("/*") && text.endsWith("*/") && text.length >= 4)
+    return text.slice(2, -2);
+  return void 0;
+}
+function classify(text) {
+  const body = commentBody(text);
+  if (body === void 0)
+    return void 0;
+  const trimmed = body.trim();
+  if (trimmed !== DIRECTIVE_WORD && !trimmed.startsWith(`${DIRECTIVE_WORD} `) && !trimmed.startsWith(`${DIRECTIVE_WORD}	`)) {
+    return void 0;
+  }
+  const argument = trimmed.slice(DIRECTIVE_WORD.length).trim();
+  return { kind: argument === IGNORE_ARGUMENT ? "ignore" : "malformed", argument };
+}
+function looksLikeFormatDirective(text) {
+  return text.includes(DIRECTIVE_WORD);
+}
+function nodesByStartOffset(root3) {
+  const byOffset = /* @__PURE__ */ new Map();
+  for (const node of ast_utils_exports.streamAllContents(root3)) {
+    const cst = node.$cstNode;
+    if (!cst)
+      continue;
+    const existing = byOffset.get(cst.offset);
+    if (!existing || (existing.$cstNode?.end ?? 0) < cst.end)
+      byOffset.set(cst.offset, node);
+  }
+  return byOffset;
+}
+function mergeSlices(slices) {
+  const sorted = [...slices].sort((a2, b) => a2.offset - b.offset || a2.end - b.end);
+  const merged = [];
+  for (const slice of sorted) {
+    const last2 = merged.at(-1);
+    if (last2 && slice.offset <= last2.end) {
+      last2.end = Math.max(last2.end, slice.end);
+    } else {
+      merged.push({ ...slice });
+    }
+  }
+  return merged;
+}
+function scanFormatDirectives(document) {
+  const root3 = document.parseResult?.value;
+  const rootCst = root3?.$cstNode;
+  if (!root3 || !rootCst)
+    return EMPTY_SCAN;
+  const text = document.textDocument.getText();
+  if (!looksLikeFormatDirective(text))
+    return EMPTY_SCAN;
+  const leaves = cst_utils_exports.flattenCst(rootCst).toArray();
+  const directives = [];
+  const protectedRanges = [];
+  let byOffset;
+  for (let index = 0; index < leaves.length; index++) {
+    const leaf = leaves[index];
+    if (!leaf.hidden)
+      continue;
+    const classified = classify(leaf.text);
+    if (!classified)
+      continue;
+    const comment = { offset: leaf.offset, end: leaf.end };
+    if (classified.kind === "malformed") {
+      directives.push({ kind: "malformed", comment, argument: classified.argument });
+      continue;
+    }
+    let next;
+    for (let scan = index + 1; scan < leaves.length; scan++) {
+      if (!leaves[scan].hidden) {
+        next = leaves[scan];
+        break;
+      }
+    }
+    byOffset ??= nodesByStartOffset(root3);
+    const target = next ? byOffset.get(next.offset)?.$cstNode : void 0;
+    if (!target) {
+      directives.push({ kind: "dangling", comment, argument: classified.argument });
+      continue;
+    }
+    const slice = { offset: target.offset, end: target.end };
+    directives.push({ kind: "ignore", comment, argument: classified.argument, target: slice });
+    protectedRanges.push(slice);
+  }
+  if (directives.length === 0)
+    return EMPTY_SCAN;
+  return { directives, protectedRanges: mergeSlices(protectedRanges) };
+}
+function intersectsProtected(ranges, offset, end) {
+  return ranges.some((slice) => offset < slice.end && end > slice.offset);
+}
+
 // ../language-server/out/src/services/v1-guardrail.js
 var V1_KEYWORD_MAP = {
   block: { v2: "part def", note: "SysML v2 replaces the v1 'Block' with 'part def'." },
@@ -60268,6 +60385,23 @@ var SysmlValidator = class _SysmlValidator {
     }
     this.checkMixedIndentation(node, doc, accept);
     this.checkAlphabetizedImportGroups(node, doc, accept);
+    this.checkFormatDirectives(node, doc, accept);
+  }
+  // REQ-392 — STYL008 a `sysml-format` directive the formatter cannot act on.
+  // A well-formed `sysml-format ignore` that found its element is silent; only
+  // an unknown argument and one with nothing left to attach to are reported,
+  // each on the comment itself so the fix is where the cursor lands.
+  checkFormatDirectives(root3, doc, accept) {
+    for (const directive of scanFormatDirectives(doc).directives) {
+      if (directive.kind === "ignore")
+        continue;
+      const range = {
+        start: doc.textDocument.positionAt(directive.comment.offset),
+        end: doc.textDocument.positionAt(directive.comment.end)
+      };
+      const message = directive.kind === "dangling" ? DIAGNOSTIC_MESSAGES.STYL008_FORMAT_DIRECTIVE_UNATTACHED : DIAGNOSTIC_MESSAGES.STYL008_FORMAT_DIRECTIVE_UNKNOWN(directive.argument);
+      accept(severity("STYL008", "info"), message, { node: root3, range, code: "STYL008" });
+    }
   }
   // REQ-332 — STYL004 mixed tab + space indentation.
   checkMixedIndentation(root3, doc, accept) {
@@ -61187,10 +61321,22 @@ ${baseIndent}}`;
   // target feature, so each end must be able to hold it (OMG SysML v2 Part 1
   // §7.12 ItemFlow / PayloadFeature). Reported per end, and only when the end
   // resolves unambiguously and carries exactly one written type.
+  //
+  // A MESSAGE is deliberately exempt, though the grammar folds it into the same
+  // statement. OMG SysML 8.2.2.16 gives `flow` FlowEndMembers — a FlowEnd is a
+  // FlowFeature, the feature that holds the payload — while a message's `from`
+  // and `to` are MessageEventMembers: `message m of i : I from evt1 to evt2` is
+  // "parsed as an abstract FlowUsage, but without any flowEnds", its two ends
+  // redefining Message::sourceEvent and Message::targetEvent (8.4.12.2). The
+  // ends of a message are the two OCCURRENCES that exchange the payload, so
+  // demanding that they be able to hold it reports every sequence-diagram
+  // message as an error.
   checkFlowPayload(decl, model, index, accept) {
     if (decl.$type !== "FlowStmt")
       return;
     const flow = decl;
+    if (flow.flowKind === "message")
+      return;
     const payload = flowPayloadType(flow.payload);
     if (!payload || payload.conjugated)
       return;
@@ -62898,6 +63044,7 @@ var STYLE_ADVISORY_CODES = /* @__PURE__ */ new Set([
   "STYL005",
   "STYL006",
   "STYL007",
+  "STYL008",
   "LEX009",
   // trailing whitespace
   "SYN024",
@@ -63976,6 +64123,18 @@ function resolveEffectiveSubject(node) {
 
 // ../language-server/out/src/services/hover-provider.js
 var MAX_HOVER_LINES = 30;
+var MAX_DOC_DEPTH = 16;
+var MAX_DOC_NODES = 64;
+var MAX_DOC_SECTION_LINES = 14;
+var DOC_SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([
+  ":>",
+  ":>>",
+  "::>",
+  "specializes",
+  "subsets",
+  "redefines",
+  "references"
+]);
 function leafAtOffset(node, offset) {
   if (isLeafCstNode(node)) {
     return node.offset <= offset && offset < node.offset + node.length ? node : void 0;
@@ -64130,22 +64289,26 @@ function multiplicityPlainEnglish(node) {
     return lo === 1 ? "Exactly 1 value" : `Exactly ${lo} values`;
   return `Between ${lo} and ${hi ?? "*"} values`;
 }
-function docComment(node) {
+function localDocs(node) {
+  const bodies = [];
   const members = node.members;
   if (Array.isArray(members)) {
     for (const m of members) {
       const body = docBody(m);
       if (body)
-        return body;
+        bodies.push(body);
     }
   }
+  if (bodies.length > 0)
+    return bodies;
   const siblings = node.$container?.members;
   if (Array.isArray(siblings)) {
     const index = siblings.indexOf(node);
-    if (index > 0)
-      return docBody(siblings[index - 1]);
+    const preceding = index > 0 ? docBody(siblings[index - 1]) : void 0;
+    if (preceding)
+      bodies.push(preceding);
   }
-  return void 0;
+  return bodies;
 }
 function docBody(node) {
   const member = node;
@@ -64291,13 +64454,67 @@ function buildCommentHover(node) {
   lines.push("", sourceFooter(nodeSource(node)));
   return lines.join("\n");
 }
+function uniqueLocalTarget(source, targetText) {
+  const root3 = ast_utils_exports.getDocument(source).parseResult?.value;
+  if (!root3)
+    return void 0;
+  let found;
+  for (const candidate of ast_utils_exports.streamAllContents(root3)) {
+    const named = candidate;
+    if (named.name !== targetText && named.shortName?.name !== targetText)
+      continue;
+    if (found)
+      return void 0;
+    found = candidate;
+  }
+  return found;
+}
+function declarationLink(node) {
+  const uri = ast_utils_exports.getDocument(node).uri.toString();
+  const line = (node.$cstNode?.range.start.line ?? 0) + 1;
+  return `[${shortUri(uri)}:${line}](${uri}#L${line})`;
+}
+function limitDocSection(value) {
+  const lines = value.split(/\r?\n/u);
+  if (lines.length <= MAX_DOC_SECTION_LINES)
+    return value;
+  const kept = lines.slice(0, MAX_DOC_SECTION_LINES);
+  if (kept.filter((line) => line.startsWith("```")).length % 2 !== 0)
+    kept.push("```");
+  kept.push("\u2026");
+  return kept.join("\n");
+}
+function renderDocs(bodies, provenance) {
+  const body = limitDocSection(bodies.join("\n\n"));
+  return provenance ? `${provenance}
+
+${body}` : body;
+}
+function supertypeCandidates(node) {
+  const named = node;
+  const out = [];
+  const typing = named.typing;
+  if (typing?.type?.$refText)
+    out.push({ refText: typing.type.$refText, ref: typing.type.ref });
+  for (const more of typing?.moreTypes ?? []) {
+    if (more.$refText)
+      out.push({ refText: more.$refText, ref: more.ref });
+  }
+  for (const rel of allRelationships(named)) {
+    if (!rel.kind || !DOC_SPECIALIZATION_KINDS.has(rel.kind))
+      continue;
+    for (const target of rel.targets ?? [])
+      out.push({ refText: target });
+  }
+  return out;
+}
 function buildContextualHover(node) {
   const contextual = nearestAncestor(node, /* @__PURE__ */ new Set(["IfExpr", "MetadataAnnotation", "RepStmt", "CommentStmt"]));
   if (!contextual)
     return void 0;
   return buildConditionalHover(contextual) ?? buildMetadataAnnotationHover(contextual) ?? buildRepresentationHover(contextual) ?? buildCommentHover(contextual);
 }
-function buildHoverMarkdown(node, relationshipDetails) {
+function buildHoverMarkdown(node, relationshipDetails, documentation) {
   const named = node;
   const dir = directionLabel(node);
   const kind = kindLabel2(node);
@@ -64306,7 +64523,7 @@ function buildHoverMarkdown(node, relationshipDetails) {
   const mult = multiplicityLabel(node);
   const multHint = multiplicityPlainEnglish(node);
   const rels = relationshipLabel(allRelationships(named));
-  const doc = docComment(node);
+  const doc = documentation;
   const members = memberList(node);
   const headerLines = [`${dir}${kind} ${name}${typing}${mult}${rels}`];
   if (members.length > 0) {
@@ -64659,11 +64876,14 @@ var SysmlHoverProvider = class {
   astNodeLocator;
   documents;
   indexManager;
+  /** REQ-394 — the linker's lazy standard-library load, reused rather than duplicated. */
+  linker;
   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;
   }
   // REQ-246, REQ-334, REQ-335, REQ-336, REQ-342, REQ-343 — Route hover requests to markdown tooltip builders
   async getHoverContent(document, params) {
@@ -64737,7 +64957,50 @@ var SysmlHoverProvider = class {
     };
   }
   async buildElementHover(node) {
-    return buildHoverMarkdown(node, await this.relationshipDetailSection(node));
+    return buildHoverMarkdown(node, await this.relationshipDetailSection(node), await this.documentationSection(node));
+  }
+  /**
+   * REQ-394 — The documentation an element reads with.
+   *
+   * Its own `doc` members win, all of them, in declaration order. With none of
+   * its own, the walk goes up the typing and specialization graph breadth
+   * first, so the CLOSEST documented type wins over a more general ancestor,
+   * and stops at the first documented one — naming it, and linking to it, so
+   * the reader can see where the prose came from.
+   *
+   * The walk resolves through the same machinery as go-to-definition
+   * (`resolveRelationshipTarget` — local nodes, then the workspace index, then
+   * one lazily parsed library file), so cross-file and standard-library
+   * documentation arrive without a second name resolver. A `visited` set plus
+   * the depth and node budgets make a cyclic or malformed graph terminate.
+   */
+  async documentationSection(node) {
+    const own = localDocs(node);
+    if (own.length > 0)
+      return renderDocs(own);
+    const visited = /* @__PURE__ */ new Set([node]);
+    let frontier = [node];
+    for (let depth = 0; depth < MAX_DOC_DEPTH && frontier.length > 0; depth++) {
+      const next = [];
+      for (const current2 of frontier) {
+        for (const candidate of supertypeCandidates(current2)) {
+          if (visited.size >= MAX_DOC_NODES)
+            return void 0;
+          const target = candidate.ref ?? this.resolveDocumentationTarget(current2, candidate.refText);
+          if (!target || visited.has(target))
+            continue;
+          visited.add(target);
+          const inherited = localDocs(target);
+          if (inherited.length > 0) {
+            const label = identificationLabel(target) ?? candidate.refText;
+            return renderDocs(inherited, `*Documentation inherited from ${kindLabel2(target)} \`${label}\`* \u2014 ${declarationLink(target)}`);
+          }
+          next.push(target);
+        }
+      }
+      frontier = next;
+    }
+    return void 0;
   }
   async buildOperatorHover(token) {
     const qualifiedName = OPERATOR_FUNCTIONS[token];
@@ -64787,6 +65050,46 @@ var SysmlHoverProvider = class {
     return lines.length > 0 ? `*Relationships:*
 ${lines.join("\n")}` : void 0;
   }
+  /**
+   * REQ-394 — Resolve a supertype for the documentation walk without pulling a
+   * document into the workspace.
+   *
+   * The card itself may lazily parse ONE indexed library target (REQ-251), and
+   * that is the budget. Looking for an inherited `doc` must not add to it, so
+   * this reuses the LINKER's own lazy load — the same path a cross-reference
+   * takes, which parses a standard-library file off to the side and caches it
+   * — instead of `getOrCreateDocument`, which would make every hover grow
+   * `LangiumDocuments`.
+   *
+   * The match has to be UNAMBIGUOUS. This is not a scope-aware resolver — it
+   * cannot apply imports or visibility — so it only accepts a name written
+   * exactly as the index holds it, or a final segment that names exactly one
+   * element in the whole index. Two `Vehicle`s in different packages, or an
+   * unresolved reference that happens to share a final segment with something
+   * unrelated, therefore yield NO documentation instead of another element's
+   * prose picked by index order. Wrong documentation reads as authoritative;
+   * none reads as none.
+   */
+  resolveDocumentationTarget(source, targetText) {
+    const local = uniqueLocalTarget(source, targetText);
+    if (local)
+      return local;
+    const key = relationshipTargetKey(targetText);
+    const exact = /* @__PURE__ */ new Map();
+    const byKey = /* @__PURE__ */ new Map();
+    for (const description of this.indexManager.allElements()) {
+      const id = `${description.documentUri.toString()}#${description.path}`;
+      if (description.name === targetText)
+        exact.set(id, description);
+      else if (description.name === key)
+        byKey.set(id, description);
+    }
+    const pool = exact.size > 0 ? exact : byKey;
+    if (pool.size !== 1)
+      return void 0;
+    const chosen = pool.values().next().value;
+    return this.linker.resolveIndexedNode?.(chosen) ?? chosen.node;
+  }
   async resolveRelationshipTarget(source, targetText) {
     const local = this.findLocalRelationshipTarget(source, targetText);
     if (local)
@@ -66659,6 +66962,19 @@ var SysmlLinker = class extends DefaultLinker {
     const root3 = this.parsedLibraryDocument(nodeDescription.documentUri)?.parseResult?.value;
     return root3 ? this.astNodeLocator.getAstNode(root3, nodeDescription.path) : void 0;
   }
+  /**
+   * REQ-394 — Resolve an indexed description to a node WITHOUT adding a
+   * document to the workspace.
+   *
+   * This is the same path a cross-reference takes (`loadAstNode`): an already
+   * live node, otherwise the standard-library file parsed once off to the side
+   * and cached here. Hover's documentation walk uses it so looking for an
+   * inherited `doc` never pulls a library file into `LangiumDocuments`, and so
+   * there is one lazy-library-load path rather than two.
+   */
+  resolveIndexedNode(nodeDescription) {
+    return this.loadAstNode(nodeDescription);
+  }
   /** Parse (once) the standard-library file a precomputed description points at.
    *  Prefers an already-live workspace document when one exists (runtime-loaded
    *  library, or the user opened the file) so there is never a second copy. */
@@ -67290,14 +67606,526 @@ function getNodeAtRange(document, params) {
   return leafAtOffset2(root3, offset)?.astNode;
 }
 
+// ../language-server/out/src/services/formatter-settings.js
+var FORMATTER_DEFAULTS = Object.freeze({
+  indentStyle: "editor",
+  indentSize: 0,
+  blankLines: 1,
+  lineWidth: 0,
+  emptyBody: "preserve",
+  quotedNames: "preserve",
+  documentationIndent: "preserve",
+  keywords: "preserve"
+});
+var sysmlFormatterSettings = { ...FORMATTER_DEFAULTS };
+var OPTION_PREFIX = "sysml.format.";
+var INDENT_STYLES = ["editor", "spaces", "tabs"];
+var EMPTY_BODY_STYLES = ["preserve", "semicolon", "braces"];
+var QUOTED_NAME_STYLES = ["preserve", "unquoteSafe"];
+var DOC_INDENT_STYLES = ["preserve", "align"];
+var KEYWORD_STYLES = ["preserve", "symbolic"];
+var MAX_INDENT_SIZE = 16;
+var MIN_LINE_WIDTH = 40;
+var MAX_LINE_WIDTH = 400;
+var MAX_BLANK_LINES = 2;
+function readEnum(name, value, allowed, fallback, issues) {
+  if (value === void 0)
+    return fallback;
+  if (typeof value === "string" && allowed.includes(value))
+    return value;
+  issues.push({ setting: name, value, reason: `expected one of ${allowed.map((a2) => `'${a2}'`).join(", ")}` });
+  return fallback;
+}
+function readInt(name, value, min2, max, fallback, issues, zeroMeans) {
+  if (value === void 0)
+    return fallback;
+  if (typeof value === "number" && Number.isInteger(value) && (value === 0 && zeroMeans !== void 0 ? true : value >= min2 && value <= max)) {
+    return value;
+  }
+  const range = zeroMeans !== void 0 ? `0 (${zeroMeans}) or ${min2}\u2013${max}` : `${min2}\u2013${max}`;
+  issues.push({ setting: name, value, reason: `expected an integer ${range}` });
+  return fallback;
+}
+function resolveFormatterSettings(raw, base = FORMATTER_DEFAULTS) {
+  const issues = [];
+  const source = raw && typeof raw === "object" ? raw : {};
+  const settings = {
+    indentStyle: readEnum("sysml.format.indentStyle", source.indentStyle, INDENT_STYLES, base.indentStyle, issues),
+    indentSize: readInt("sysml.format.indentSize", source.indentSize, 1, MAX_INDENT_SIZE, base.indentSize, issues, "follow the editor"),
+    blankLines: readInt("sysml.format.blankLines", source.blankLines, 0, MAX_BLANK_LINES, base.blankLines, issues),
+    lineWidth: readInt("sysml.format.lineWidth", source.lineWidth, MIN_LINE_WIDTH, MAX_LINE_WIDTH, base.lineWidth, issues, "never wrap"),
+    emptyBody: readEnum("sysml.format.emptyBody", source.emptyBody, EMPTY_BODY_STYLES, base.emptyBody, issues),
+    quotedNames: readEnum("sysml.format.quotedNames", source.quotedNames, QUOTED_NAME_STYLES, base.quotedNames, issues),
+    documentationIndent: readEnum("sysml.format.documentationIndent", source.documentationIndent, DOC_INDENT_STYLES, base.documentationIndent, issues),
+    keywords: readEnum("sysml.format.keywords", source.keywords, KEYWORD_STYLES, base.keywords, issues)
+  };
+  return { settings, issues };
+}
+function resolveFormatterOptions(options, workspace = sysmlFormatterSettings) {
+  const overrides = {};
+  for (const [key, value] of Object.entries(options ?? {})) {
+    if (key.startsWith(OPTION_PREFIX))
+      overrides[key.slice(OPTION_PREFIX.length)] = value;
+  }
+  return resolveFormatterSettings(overrides, workspace);
+}
+function effectiveFormattingOptions(options, settings) {
+  const insertSpaces = settings.indentStyle === "editor" ? options.insertSpaces : settings.indentStyle === "spaces";
+  const tabSize = settings.indentSize === 0 ? options.tabSize : settings.indentSize;
+  if (insertSpaces === options.insertSpaces && tabSize === options.tabSize)
+    return options;
+  return { ...options, insertSpaces, tabSize };
+}
+function indentUnit(options) {
+  return options.insertSpaces ? " ".repeat(Math.max(1, options.tabSize)) : "	";
+}
+
+// ../language-server/out/src/services/formatter-style.js
+var SYMBOLIC_KEYWORDS = Object.freeze({
+  specializes: ":>",
+  subsets: ":>",
+  redefines: ":>>",
+  references: "::>",
+  crosses: "=>"
+});
+var TYPING_PHRASES = ["typed", "defined"];
+var BARE_ID2 = /^[_a-zA-Z]\w*$/u;
+var ESCAPED_NAME = /^'([^'\\]|\\.)*'$/u;
+function projectFormatted(document, edits) {
+  const doc = document.textDocument;
+  const source = doc.getText();
+  const list = edits.map((edit) => ({
+    start: doc.offsetAt(edit.range.start),
+    end: doc.offsetAt(edit.range.end),
+    newText: edit.newText
+  })).sort((a2, b) => a2.start - b.start);
+  let out = "";
+  let cursor = 0;
+  let delta = 0;
+  const marks = [];
+  for (const edit of list) {
+    if (edit.start < cursor)
+      continue;
+    out += source.slice(cursor, edit.start) + edit.newText;
+    delta += edit.newText.length - (edit.end - edit.start);
+    marks.push({ at: edit.end, delta });
+    cursor = edit.end;
+  }
+  out += source.slice(cursor);
+  return {
+    text: out,
+    project(offset) {
+      let low = 0;
+      let high = marks.length - 1;
+      let applied = 0;
+      while (low <= high) {
+        const mid = low + high >> 1;
+        if (marks[mid].at <= offset) {
+          applied = marks[mid].delta;
+          low = mid + 1;
+        } else {
+          high = mid - 1;
+        }
+      }
+      return offset + applied;
+    }
+  };
+}
+function lineAt(text, offset) {
+  const start = text.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
+  const nl = text.indexOf("\n", offset);
+  const end = nl < 0 ? text.length : nl;
+  const indent = /^[ \t]*/u.exec(text.slice(start, end))?.[0] ?? "";
+  return { start, end, indent };
+}
+function leavesOf(document) {
+  const rootCst = document.parseResult?.value?.$cstNode;
+  return rootCst ? cst_utils_exports.flattenCst(rootCst).toArray() : [];
+}
+function nextLeaf(leaves, index, skipHidden) {
+  for (let scan = index + 1; scan < leaves.length; scan++) {
+    if (!skipHidden || !leaves[scan].hidden)
+      return leaves[scan];
+  }
+  return void 0;
+}
+function keywordRewrites(leaves, out) {
+  for (let index = 0; index < leaves.length; index++) {
+    const leaf = leaves[index];
+    if (leaf.hidden)
+      continue;
+    const symbol = SYMBOLIC_KEYWORDS[leaf.text];
+    if (symbol) {
+      out.push({ offset: leaf.offset, end: leaf.end, newText: symbol });
+      continue;
+    }
+    if (TYPING_PHRASES.includes(leaf.text) && leaf.astNode?.$type === "Typing") {
+      const by = nextLeaf(leaves, index, true);
+      if (by?.text === "by" && by.astNode?.$type === "Typing") {
+        out.push({ offset: leaf.offset, end: by.end, newText: ":" });
+      }
+    }
+  }
+}
+var BRACE_ONLY_BODIES = /* @__PURE__ */ new Set([
+  "InvShorthand",
+  "ActionBlock",
+  "EffectClause",
+  "Import"
+]);
+function emptyBraces(node, leaves, source) {
+  const cst = node.$cstNode;
+  if (!cst)
+    return void 0;
+  let open;
+  let close;
+  for (const leaf of leaves) {
+    if (leaf.offset < cst.offset || leaf.end > cst.end || leaf.astNode !== node)
+      continue;
+    if (leaf.text === "{" && !open)
+      open = leaf;
+    if (leaf.text === "}")
+      close = leaf;
+  }
+  if (!open || !close || close.offset < open.end)
+    return void 0;
+  return source.slice(open.end, close.offset).trim().length === 0 ? { open, close } : void 0;
+}
+function terminatingSemicolon(node, leaves) {
+  const cst = node.$cstNode;
+  if (!cst)
+    return void 0;
+  for (let index = leaves.length - 1; index >= 0; index--) {
+    const leaf = leaves[index];
+    if (leaf.end !== cst.end)
+      continue;
+    return leaf.text === ";" && leaf.astNode === node ? leaf : void 0;
+  }
+  return void 0;
+}
+function emptyBodyRewrites(document, leaves, projection, settings, options, out) {
+  const root3 = document.parseResult?.value;
+  if (!root3)
+    return;
+  const source = document.textDocument.getText();
+  const leafBefore = /* @__PURE__ */ new Map();
+  for (let index = 1; index < leaves.length; index++)
+    leafBefore.set(leaves[index].offset, leaves[index - 1]);
+  for (const node of ast_utils_exports.streamAllContents(root3)) {
+    const members = node.members;
+    if (!Array.isArray(members) || members.length > 0)
+      continue;
+    if (BRACE_ONLY_BODIES.has(node.$type))
+      continue;
+    if (settings.emptyBody === "semicolon") {
+      const braces = emptyBraces(node, leaves, source);
+      if (!braces)
+        continue;
+      const previous = leafBefore.get(braces.open.offset);
+      const from = previous && previous.end <= braces.open.offset ? previous.end : braces.open.offset;
+      out.push({ offset: from, end: braces.close.end, newText: ";" });
+      continue;
+    }
+    if (settings.emptyBody === "braces") {
+      if (emptyBraces(node, leaves, source))
+        continue;
+      const semicolon = terminatingSemicolon(node, leaves);
+      if (!semicolon)
+        continue;
+      const indent = lineAt(projection.text, projection.project(node.$cstNode.offset)).indent;
+      out.push({
+        offset: semicolon.offset,
+        end: semicolon.end,
+        newText: ` {
+${indent}}`
+      });
+    }
+  }
+}
+function quotedNameRewrites(leaves, reservedKeywords, out) {
+  const occurrences = /* @__PURE__ */ new Map();
+  const declared = /* @__PURE__ */ new Set();
+  const bareSpellings = /* @__PURE__ */ new Set();
+  for (const leaf of leaves) {
+    if (leaf.hidden)
+      continue;
+    if (BARE_ID2.test(leaf.text) && !reservedKeywords.has(leaf.text)) {
+      bareSpellings.add(leaf.text);
+      continue;
+    }
+    if (!ESCAPED_NAME.test(leaf.text))
+      continue;
+    const body = leaf.text.slice(1, -1);
+    if (!BARE_ID2.test(body) || reservedKeywords.has(body))
+      continue;
+    const list = occurrences.get(body);
+    if (list)
+      list.push(leaf);
+    else
+      occurrences.set(body, [leaf]);
+    if (grammar_utils_exports.findAssignment(leaf)?.feature === "name")
+      declared.add(body);
+  }
+  for (const [body, list] of occurrences) {
+    if (!declared.has(body) || bareSpellings.has(body))
+      continue;
+    for (const leaf of list)
+      out.push({ offset: leaf.offset, end: leaf.end, newText: body });
+  }
+}
+function documentationRewrites(document, leaves, projection, options, out) {
+  for (const leaf of leaves) {
+    if (leaf.hidden || !leaf.text.includes("\n"))
+      continue;
+    const owner = leaf.astNode?.$type;
+    if (owner !== "DocCommentMember" && owner !== "CommentStmt")
+      continue;
+    if (!leaf.text.includes("/*"))
+      continue;
+    const projected = projection.project(leaf.offset);
+    const line = lineAt(projection.text, projected);
+    if (projection.text.slice(line.start, projected).trim().length > 0)
+      continue;
+    const target = line.indent;
+    const bodyLines = leaf.text.split("\n");
+    let common;
+    for (let index = 1; index < bodyLines.length; index++) {
+      const raw = bodyLines[index].replace(/\r$/u, "");
+      if (raw.trim().length === 0)
+        continue;
+      const lead = /^[ \t]*/u.exec(raw)?.[0] ?? "";
+      if (common === void 0 || lead.length < common.length)
+        common = lead;
+    }
+    if (common === void 0)
+      continue;
+    let cursor = leaf.offset + bodyLines[0].length + 1;
+    for (let index = 1; index < bodyLines.length; index++) {
+      const raw = bodyLines[index];
+      const lead = /^[ \t]*/u.exec(raw)?.[0] ?? "";
+      if (raw.replace(/\r$/u, "").trim().length > 0) {
+        const shifted = target + lead.slice(Math.min(common.length, lead.length));
+        if (shifted !== lead)
+          out.push({ offset: cursor, end: cursor + lead.length, newText: shifted });
+      }
+      cursor += raw.length + 1;
+    }
+  }
+}
+function wrapRewrites(leaves, projection, options, lineWidth, out) {
+  const unit = indentUnit(options);
+  for (let index = 0; index < leaves.length; index++) {
+    const leaf = leaves[index];
+    if (leaf.hidden || leaf.text !== ",")
+      continue;
+    const following = nextLeaf(leaves, index, false);
+    if (!following)
+      continue;
+    const projected = projection.project(leaf.offset);
+    const line = lineAt(projection.text, projected);
+    if (line.end - line.start <= lineWidth)
+      continue;
+    if (projection.text.slice(projection.project(leaf.end), line.end).trim().length === 0)
+      continue;
+    if (projection.text.slice(projected, projection.project(following.offset)).includes("\n"))
+      continue;
+    out.push({
+      offset: leaf.end,
+      end: following.offset,
+      newText: `
+${line.indent}${unit}`
+    });
+  }
+}
+function withinRange(document, rewrite, range) {
+  if (!range)
+    return true;
+  const doc = document.textDocument;
+  return doc.offsetAt(range.start) <= rewrite.offset && rewrite.end <= doc.offsetAt(range.end);
+}
+function styleEdits(input) {
+  const { document, 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(document);
+  if (leaves.length === 0)
+    return [];
+  const projection = projectFormatted(document, baseEdits);
+  const rewrites = [];
+  if (settings.keywords === "symbolic")
+    keywordRewrites(leaves, rewrites);
+  if (settings.emptyBody !== "preserve") {
+    emptyBodyRewrites(document, leaves, projection, settings, options, rewrites);
+  }
+  if (settings.quotedNames === "unquoteSafe")
+    quotedNameRewrites(leaves, reservedKeywords, rewrites);
+  if (settings.documentationIndent === "align") {
+    documentationRewrites(document, leaves, projection, options, rewrites);
+  }
+  if (settings.lineWidth > 0)
+    wrapRewrites(leaves, projection, options, settings.lineWidth, rewrites);
+  const doc = document.textDocument;
+  const source = doc.getText();
+  const accepted = [];
+  let lastEnd = -1;
+  for (const rewrite of rewrites.sort((a2, b) => a2.offset - b.offset || a2.end - b.end)) {
+    if (rewrite.offset < lastEnd)
+      continue;
+    if (source.slice(rewrite.offset, rewrite.end) === rewrite.newText)
+      continue;
+    if (intersectsProtected(protectedRanges, rewrite.offset, rewrite.end))
+      continue;
+    if (!withinRange(document, rewrite, range))
+      continue;
+    accepted.push(rewrite);
+    lastEnd = rewrite.end;
+  }
+  return accepted.map((rewrite) => ({
+    range: { start: doc.positionAt(rewrite.offset), end: doc.positionAt(rewrite.end) },
+    newText: rewrite.newText
+  }));
+}
+
 // ../language-server/out/src/services/formatter.js
 var INDENT = Formatting.indent({ allowMore: true });
 var DEDENT = Formatting.noIndent();
 var NL = Formatting.newLine();
-var NL2 = Formatting.newLines(2);
 var SPACE = Formatting.oneSpace();
 var NO_SPACE = Formatting.noSpace();
 var SysmlFormatter = class extends AbstractFormatter {
+  services;
+  /**
+   * The settings in force for the request being served. Formatting is
+   * synchronous from `formatDocument` through the AST pass, so a field is the
+   * whole of the plumbing the base class does not offer.
+   */
+  active = FORMATTER_DEFAULTS;
+  keywordCache;
+  constructor(services) {
+    super();
+    this.services = services;
+  }
+  // REQ-392, REQ-393 — Full-document formatting.
+  formatDocument(document, params) {
+    return this.formatWith(document, params.options, (options) => super.formatDocument(document, { ...params, options }));
+  }
+  // REQ-392, REQ-393 — Range formatting. A range that reaches into a preserved
+  // element formats the rest of the range and leaves that element whole: the
+  // base formatter narrows to the range, and the same filter then drops
+  // whatever would have rewritten a frozen slice, so a partial rewrite is
+  // impossible. The settings are resolved identically to the full-document
+  // path, so the two cannot produce different style.
+  formatDocumentRange(document, params) {
+    return this.formatWith(document, params.options, (options) => super.formatDocumentRange(document, { ...params, options }), params.range);
+  }
+  // REQ-392, REQ-393 — Format-on-type formats the current line.
+  formatDocumentOnType(document, params) {
+    const line = { start: { line: params.position.line, character: 0 }, end: params.position };
+    return this.formatWith(document, params.options, (options) => super.formatDocumentOnType(document, { ...params, options }), line);
+  }
+  /**
+   * REQ-392, REQ-393 — One pipeline for all three entry points: resolve the
+   * settings, run the base whitespace pass under them, drop whatever a
+   * `sysml-format ignore` froze, then add the token-level rewrites the style
+   * options ask for.
+   */
+  formatWith(document, requested, base, range) {
+    const { settings } = resolveFormatterOptions(requested);
+    const options = effectiveFormattingOptions(requested, settings);
+    this.active = settings;
+    const protectedRanges = scanFormatDirectives(document).protectedRanges;
+    const baseEdits = this.preserveIgnored(document, base(options), protectedRanges);
+    const style = styleEdits({
+      document,
+      settings,
+      options,
+      baseEdits,
+      protectedRanges,
+      range,
+      reservedKeywords: this.reservedKeywords()
+    });
+    return this.merge(document, baseEdits, style);
+  }
+  /**
+   * REQ-392 — Drop every edit that reaches inside a preserved element.
+   *
+   * Langium only ever edits the whitespace BETWEEN two tokens, so an edit is
+   * either wholly inside a preserved slice (dropped, leaving the slice
+   * byte-for-byte identical, line endings included) or wholly outside it
+   * (kept, so the element's own indentation and its surroundings are still
+   * formatted).
+   */
+  preserveIgnored(document, edits, ranges) {
+    if (edits.length === 0 || ranges.length === 0)
+      return edits;
+    const text = document.textDocument;
+    return edits.filter((edit) => !intersectsProtected(ranges, text.offsetAt(edit.range.start), text.offsetAt(edit.range.end)));
+  }
+  /**
+   * REQ-393 — Combine the whitespace pass with the token rewrites. A token
+   * rewrite wins where the two touch: `part def P { }` → `part def P;` has to
+   * swallow the space the whitespace pass wanted to put before the brace.
+   */
+  merge(document, baseEdits, style) {
+    if (style.length === 0)
+      return baseEdits;
+    const text = document.textDocument;
+    const spans = style.map((edit) => ({
+      offset: text.offsetAt(edit.range.start),
+      end: text.offsetAt(edit.range.end)
+    }));
+    const kept = baseEdits.filter((edit) => {
+      const start = text.offsetAt(edit.range.start);
+      const end = text.offsetAt(edit.range.end);
+      return !spans.some((span) => start < span.end && end > span.offset);
+    });
+    return [...kept, ...style].sort((a2, b) => text.offsetAt(a2.range.start) - text.offsetAt(b.range.start));
+  }
+  /**
+   * REQ-393 — Every keyword the grammar reserves. A quoted name may only lose
+   * its quotes when the bare spelling would still be a name and not a keyword,
+   * and the grammar is the only honest source for that list.
+   */
+  reservedKeywords() {
+    if (this.keywordCache)
+      return this.keywordCache;
+    const keywords = /* @__PURE__ */ new Set();
+    const grammar = this.services?.Grammar;
+    if (grammar) {
+      for (const node of ast_utils_exports.streamAllContents(grammar)) {
+        if (node.$type === "Keyword") {
+          const value = node.value;
+          if (value && /^[_a-zA-Z]\w*$/u.test(value))
+            keywords.add(value);
+        }
+      }
+    }
+    this.keywordCache = keywords;
+    return keywords;
+  }
+  /**
+   * REQ-392 — Keep the indentation level a comment interrupts.
+   *
+   * Langium 3.5's `createTextEdit` returns early for a hidden node and never
+   * applies the formatting action's indentation move to the running context.
+   * `{` carries the block's `indent` action, so a comment sitting between `{`
+   * and the first member — which is exactly where a `sysml-format ignore`
+   * directive goes — dropped the whole block back to column 0. Applying the
+   * move ourselves restores the level a composite node would have kept, and
+   * leaves every other hidden-node path untouched.
+   */
+  createTextEdit(a2, b, formatting, context) {
+    const edits = super.createTextEdit(a2, b, formatting, 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;
+    return edits;
+  }
   // REQ-259 — Dispatch formatting from AST node kind
   format(node) {
     if (isDocument(node)) {
@@ -67405,13 +68233,28 @@ var SysmlFormatter = class extends AbstractFormatter {
     f.keyword(first2).append(SPACE);
     f.keyword(second).prepend(SPACE);
   }
+  /**
+   * REQ-393 — Top-level element separation is decided HERE and nowhere else.
+   *
+   * The first element gets `noSpace`, which erases leading blank lines rather
+   * than adding two of them: the document-level rule and the element's own
+   * `prepend` used to fire at the same offset, and two insertions at one
+   * position stack, so every file that began with `package` gained blank
+   * lines at the top on every format. `blankLines` decides the rest.
+   */
   fmtDocument(node) {
     const f = this.getNodeFormatter(node);
-    f.properties("elements").prepend(NL2);
+    const separator = Formatting.newLines(1 + this.active.blankLines);
+    for (let index = 0; index < node.elements.length; index++) {
+      f.property("elements", index).prepend(index === 0 ? NO_SPACE : separator);
+    }
   }
   fmtBlock(node, keyword) {
     const f = this.getNodeFormatter(node);
-    f.keyword(keyword).prepend(NL2).append(SPACE);
+    if (!isDocument(node.$container)) {
+      f.keyword(keyword).prepend(Formatting.newLines(1 + this.active.blankLines));
+    }
+    f.keyword(keyword).append(SPACE);
     this.fmtBraces(f);
   }
   // REQ-355 — Filtered imports keep the `[@Meta]` condition tight against the path
@@ -67431,7 +68274,9 @@ var SysmlFormatter = class extends AbstractFormatter {
   // REQ-258, REQ-260 — Format one element per line with canonical keyword spacing
   fmtElement(node, keyword) {
     const f = this.getNodeFormatter(node);
-    f.keyword(keyword).prepend(NL).append(SPACE);
+    if (!isDocument(node.$container))
+      f.keyword(keyword).prepend(NL);
+    f.keyword(keyword).append(SPACE);
     if (node.isDef) {
       f.keyword("def").prepend(SPACE).append(SPACE);
     }
@@ -67445,7 +68290,9 @@ var SysmlFormatter = class extends AbstractFormatter {
   // REQ-260 — Keep multi-word `verification case` keyword phrase together
   fmtVerificationCase(node) {
     const f = this.getNodeFormatter(node);
-    f.keyword("verification").prepend(NL).append(SPACE);
+    if (!isDocument(node.$container))
+      f.keyword("verification").prepend(NL);
+    f.keyword("verification").append(SPACE);
     f.keyword("case").append(SPACE);
     if (node.isDef)
       f.keyword("def").append(SPACE);
@@ -67456,7 +68303,9 @@ var SysmlFormatter = class extends AbstractFormatter {
   // REQ-260 — Keep multi-word `analysis case` keyword phrase together
   fmtAnalysisCase(node) {
     const f = this.getNodeFormatter(node);
-    f.keyword("analysis").prepend(NL).append(SPACE);
+    if (!isDocument(node.$container))
+      f.keyword("analysis").prepend(NL);
+    f.keyword("analysis").append(SPACE);
     f.keyword("case").append(SPACE);
     if (node.isDef)
       f.keyword("def").append(SPACE);
@@ -67467,7 +68316,9 @@ var SysmlFormatter = class extends AbstractFormatter {
   // REQ-260 — Keep multi-word `use case` keyword phrase together
   fmtUseCase(node) {
     const f = this.getNodeFormatter(node);
-    f.keyword("use").prepend(NL).append(SPACE);
+    if (!isDocument(node.$container))
+      f.keyword("use").prepend(NL);
+    f.keyword("use").append(SPACE);
     f.keyword("case").append(SPACE);
     if (node.isDef)
       f.keyword("def").append(SPACE);
@@ -67656,14 +68507,87 @@ function typeAnchor(node, refText) {
   }
   return void 0;
 }
+var EXPLICIT_SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([
+  ":>",
+  ":>>",
+  "::>",
+  "=>",
+  "specializes",
+  "subsets",
+  "redefines",
+  "references",
+  "crosses",
+  "conjugates"
+]);
+var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+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" }
+});
+function markdown(value) {
+  return { kind: import_vscode_languageserver20.MarkupKind.Markdown, value };
+}
+function allRelationships2(node) {
+  return [...node.preRelationships ?? [], ...node.relationships ?? []];
+}
+function hasExplicitSpecialization(node) {
+  if (node.typing?.type?.$refText)
+    return true;
+  return allRelationships2(node).some((rel) => rel.kind && EXPLICIT_SPECIALIZATION_KINDS.has(rel.kind));
+}
+function keywordLeaf(node, keyword) {
+  const cst = node.$cstNode;
+  if (!cst)
+    return void 0;
+  return cst_utils_exports.flattenCst(cst).find((leaf) => leaf.text === keyword && !leaf.hidden);
+}
+function descriptionRange(description) {
+  const segment = description.nameSegment ?? description.selectionSegment;
+  return segment?.range ?? { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } };
+}
 var SysmlInlayHintProvider = class {
+  services;
+  /**
+   * Resolved implicit bases, keyed by the qualified name in
+   * {@link IMPLICIT_BASES}. The standard library does not change once it is
+   * loaded, so this is built at most once for real; while it is still empty —
+   * before the library has been indexed — the rebuild is over a tiny index and
+   * costs nothing, which is what keeps the hint path free of a full index scan
+   * on every request.
+   */
+  baseCache = /* @__PURE__ */ new Map();
+  constructor(services) {
+    this.services = services;
+  }
   getInlayHints(document, _params) {
     const root3 = document.parseResult?.value;
-    if (!root3)
+    if (!root3 || !sysmlInlayHintSettings.enabled)
       return void 0;
+    const settings = sysmlInlayHintSettings;
     const hints = [];
     for (const node of allAstNodes(root3)) {
-      if ((isPartDecl(node) || isPortDecl(node) || isAttributeDecl(node)) && !node.isDef && !node.multiplicity && node.$cstNode && node.name) {
+      const decl = node;
+      if (settings.multiplicity && (isPartDecl(node) || isPortDecl(node) || isAttributeDecl(node)) && !decl.isDef && !decl.multiplicity && node.$cstNode && decl.name) {
         hints.push({
           position: multiplicityAnchor(node.$cstNode),
           label: " [1]",
@@ -67671,7 +68595,65 @@ var SysmlInlayHintProvider = class {
           paddingLeft: true
         });
       }
-      if (!sysmlInlayHintSettings.dimension)
+      if (settings.visibility && isImport(node) && !decl.visibility) {
+        const keyword = keywordLeaf(node, "import");
+        if (keyword) {
+          const at = keyword.range.start;
+          hints.push({
+            position: at,
+            label: "private",
+            kind: import_vscode_languageserver20.InlayHintKind.Type,
+            paddingRight: true,
+            tooltip: markdown("An `import` that declares no visibility is **private**: the names it brings in are not re-exported from this namespace."),
+            // Writing the modifier is mechanically safe — `private`
+            // is exactly what the grammar accepts here, and the text
+            // then says what it already meant.
+            textEdits: [{ range: { start: at, end: at }, newText: "private " }]
+          });
+        }
+      }
+      if (settings.modifiers && isAttributeDecl(node) && !decl.isDef && !(decl.modifiers ?? []).includes("ref")) {
+        const keyword = keywordLeaf(node, "attribute");
+        if (keyword) {
+          const at = keyword.range.start;
+          hints.push({
+            position: at,
+            label: "ref",
+            kind: import_vscode_languageserver20.InlayHintKind.Type,
+            paddingRight: true,
+            tooltip: markdown("An attribute usage is always referential (`ref`); it is never a composite feature of its owner."),
+            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) {
+        const effective = effectiveNameHint(decl);
+        if (effective)
+          hints.push(effective);
+      }
+      if (!settings.dimension)
         continue;
       if (isNumericPrimary(node)) {
         const symbol = node.unit?.$refText;
@@ -67687,7 +68669,7 @@ var SysmlInlayHintProvider = class {
         continue;
       }
       if (isAttributeDecl(node)) {
-        const refText = node.typing?.type?.$refText;
+        const refText = decl.typing?.type?.$refText;
         const label = refText ? quantityTypeDimensionLabel(refText) : void 0;
         const position = refText ? typeAnchor(node, refText) : void 0;
         if (label && position) {
@@ -67702,7 +68684,102 @@ var SysmlInlayHintProvider = class {
     }
     return hints;
   }
+  /**
+   * REQ-395 — Positional parameter correspondence.
+   *
+   * A usage typed by a definition redefines that definition's directed
+   * parameters by position ([OMG SysML v2 Part 1 §7.16.4] — the same rule
+   * `SSM025` checks). The definition has to be RESOLVED for the hint to exist,
+   * and a parameter that already redefines something explicitly is left alone.
+   */
+  parameterRedefinitionHints(node) {
+    const definition = node.typing?.type?.ref;
+    if (!definition || node.isDef)
+      return [];
+    const mine = directedParameters(node);
+    if (mine.length === 0)
+      return [];
+    const theirs = directedParameters(definition);
+    const hints = [];
+    for (let index = 0; index < mine.length && index < theirs.length; index++) {
+      const parameter = mine[index].node;
+      if (!parameter.name || !parameter.$cstNode)
+        continue;
+      if (allRelationships2(parameter).some((rel) => rel.kind && REDEFINITION_KINDS2.has(rel.kind)))
+        continue;
+      const target = theirs[index].node;
+      if (!target.name || target.name === parameter.name)
+        continue;
+      const uri = ast_utils_exports.getDocument(target).uri.toString();
+      const range = target.$cstNode?.range ?? { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } };
+      hints.push({
+        position: multiplicityAnchor(parameter.$cstNode),
+        label: [{ value: ` :>> ${target.name}`, location: { uri, range } }],
+        kind: import_vscode_languageserver20.InlayHintKind.Type,
+        paddingLeft: true,
+        tooltip: markdown(`Parameter ${index + 1} implicitly redefines \`${target.name}\` of \`${node.typing?.type?.$refText ?? "its definition"}\`.`)
+      });
+    }
+    return hints;
+  }
+  /**
+   * 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;
+    const index = this.services?.shared.workspace.IndexManager;
+    if (!index)
+      return void 0;
+    const simple = lastSegment3(qualified);
+    let fallback;
+    for (const description of index.allElements()) {
+      if (description.name === qualified) {
+        this.baseCache.set(qualified, description);
+        return description;
+      }
+      if (fallback || description.name !== simple)
+        continue;
+      const uri = description.documentUri instanceof URI2 ? description.documentUri : URI2.parse(String(description.documentUri));
+      if (!isStandardLibraryUri(uri))
+        continue;
+      if (description.isUsage === true !== wantUsage)
+        continue;
+      fallback = description;
+    }
+    if (fallback)
+      this.baseCache.set(qualified, fallback);
+    return fallback;
+  }
 };
+function effectiveNameHint(node) {
+  if (node.name || node.shortName?.name || !node.$cstNode)
+    return void 0;
+  const redefinition = allRelationships2(node).find((rel) => rel.kind && REDEFINITION_KINDS2.has(rel.kind) && (rel.targets?.length ?? 0) > 0);
+  const target = redefinition?.targets?.[0];
+  if (!target)
+    return void 0;
+  const effective = lastSegment3(target);
+  if (!effective)
+    return void 0;
+  const operator = cst_utils_exports.flattenCst(node.$cstNode).find((leaf) => !leaf.hidden && redefinition?.kind !== void 0 && leaf.text === redefinition.kind);
+  if (!operator)
+    return void 0;
+  return {
+    position: operator.range.start,
+    label: effective,
+    kind: import_vscode_languageserver20.InlayHintKind.Parameter,
+    paddingRight: true,
+    tooltip: markdown(`Effective name: \`${effective}\`, taken from the feature this one redefines.`)
+  };
+}
 
 // ../language-server/out/src/services/requirement-eval.js
 var UNRESOLVED = { kind: "unresolved" };
@@ -68911,9 +69988,13 @@ var SysmlLspModule = {
     // Epic G
     RenameProvider: (services) => new SysmlRenameProvider(services),
     CodeActionProvider: (services) => new SysmlCodeActionProvider(services),
-    Formatter: () => new SysmlFormatter(),
+    // REQ-393 — the formatter reads the grammar's keyword set for the
+    // quoted-name decision, so it is built with services.
+    Formatter: (services) => new SysmlFormatter(services),
     SemanticTokenProvider: (services) => new SysmlSemanticTokenProvider(services),
-    InlayHintProvider: () => new SysmlInlayHintProvider(),
+    // REQ-395 — the provider resolves implicit standard-library bases
+    // through the workspace/library index, so it is built with services.
+    InlayHintProvider: (services) => new SysmlInlayHintProvider(services),
     CodeLensProvider: (services) => new SysmlCodeLensProvider(services),
     DocumentHighlightProvider: (services) => new SysmlDocumentHighlightProvider(services),
     DefinitionProvider: (services) => new SysmlDefinitionProvider(services),
@@ -70012,7 +71093,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.15.7" : "dev";
+var VERSION2 = true ? "0.16.0" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {