sysml-validate 0.15.8 → 0.17.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;
@@ -58642,6 +58649,18 @@ var DIAGNOSTIC_MESSAGES = {
   // `first a then b;` and the `then` occurrence shorthand in a part), so the
   // message names the construct it means rather than "action language".
   SEM011_ACTION_ONLY_CONSTRUCT: (construct, clause, owner) => `${construct} may only be declared in the body of an action definition or usage (OMG SysML v2 Part 1 \xA7${clause}), not in ${owner}.`,
+  // REQ-392 — issue #150. A `rep … language "sysml"` body is a legal representation
+  // of the element it annotates (OMG KerML §7.4.3), so the two faults are "this is
+  // not SysML" and "this is not THIS element". The parser's own wording is carried
+  // through verbatim, because it names the token the reader has to go and fix.
+  SYN076_EMBEDDED_REPRESENTATION_SYNTAX: (language, detail) => `This representation declares language "${language}", so its body must be valid ${language}: ${detail}`,
+  SEM012_REPRESENTATION_WRONG_KIND: (expected, actual) => `A textual representation must represent the element it annotates. This body represents '${actual}', but it annotates '${expected}'.`,
+  // REQ-392 — The body is resolved in the represented element's own context, so an
+  // unresolvable name there is the same defect it would be in ordinary code. It is
+  // reported under its own code so a team can tune representations separately.
+  RES020_REPRESENTATION_UNRESOLVED: (name, language) => `'${name}' cannot be resolved from here, so this ${language} representation is not a valid representation of the element it annotates.`,
+  RES020_REPRESENTATION_PATH_SEGMENT: (segment, owner, language) => `Feature path segment '${segment}' does not exist on '${owner}', so this ${language} representation is not a valid representation of the element it annotates.`,
+  SEM012_REPRESENTATION_WRONG_NAME: (expected, actual) => `A textual representation must represent the element it annotates. This body represents '${actual}', but it annotates '${expected}'.`,
   RES016_LIBRARY_SHADOWING: (name) => `'${name}' shadows a standard-library element of the same name; the library symbol is hidden in this scope.`,
   // issue #183 — KerML namespace distinguishability (validateNamespaceDistinguishability).
   // Owned siblings sharing a name/short name (or an alias clashing with an owned
@@ -58685,7 +58704,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 +58910,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'." },
@@ -59479,6 +59608,274 @@ function isNamespaceOnlyDecl(node) {
   return node.isDef === true;
 }
 
+// ../language-server/out/src/services/comment-body.js
+function sourceOf(node) {
+  return node.$cstNode?.root.fullText;
+}
+function cleanBlockBodyLines(raw, rawOffset) {
+  let cut = raw.length - raw.trimStart().length;
+  let body = raw.slice(cut).trimEnd();
+  if (body.startsWith("/*")) {
+    body = body.slice(2);
+    cut += 2;
+  }
+  if (body.endsWith("*/"))
+    body = body.slice(0, -2);
+  const lines = [];
+  let cursor = cut;
+  for (const rawLine of body.split("\n")) {
+    const gutter = /^\s*\*+ ?/u.exec(rawLine);
+    const skip = gutter ? gutter[0].length : 0;
+    lines.push({
+      text: rawLine.slice(skip).replace(/\s+$/u, ""),
+      offset: rawOffset + cursor + skip
+    });
+    cursor += rawLine.length + 1;
+  }
+  while (lines.length > 0 && lines[0].text.trim() === "")
+    lines.shift();
+  while (lines.length > 0 && lines[lines.length - 1].text.trim() === "")
+    lines.pop();
+  if (lines.length > 0) {
+    const lead = lines[0].text.length - lines[0].text.trimStart().length;
+    if (lead > 0)
+      lines[0] = { text: lines[0].text.slice(lead), offset: lines[0].offset + lead };
+  }
+  return lines;
+}
+function cleanBlockBody(inner) {
+  return cleanBlockBodyLines(inner, 0).map((line) => line.text).join("\n");
+}
+function docCommentBody(node) {
+  const raw = node.doc;
+  if (typeof raw !== "string")
+    return void 0;
+  const start = raw.indexOf("/*");
+  const end = raw.lastIndexOf("*/");
+  if (start < 0 || end < start)
+    return void 0;
+  const body = cleanBlockBody(raw.slice(start, end + 2));
+  return body.length > 0 ? body : void 0;
+}
+function trailingBlockBodySpan(node) {
+  const cst = node.$cstNode;
+  const text = sourceOf(node);
+  if (!cst || text === void 0)
+    return void 0;
+  const rest = text.slice(cst.end);
+  const open = rest.indexOf("/*");
+  if (open < 0)
+    return void 0;
+  if (rest.slice(0, open).trim() !== "")
+    return void 0;
+  const close = rest.indexOf("*/", open + 2);
+  if (close < 0)
+    return void 0;
+  const raw = rest.slice(open, close + 2);
+  const lines = cleanBlockBodyLines(raw, cst.end + open);
+  const body = lines.map((line) => line.text).join("\n");
+  if (body.length === 0)
+    return void 0;
+  return { text: body, lines, open: cst.end + open, close: cst.end + close + 2 };
+}
+function trailingBlockBody(node) {
+  return trailingBlockBodySpan(node)?.text;
+}
+function bodyOffsetAt(span, line, character) {
+  const entry = Number.isInteger(line) ? span.lines[line] : void 0;
+  if (!entry)
+    return span.open;
+  const column = Number.isFinite(character) ? character : 0;
+  return entry.offset + Math.max(0, Math.min(column, entry.text.length));
+}
+
+// ../language-server/out/src/services/embedded-representation.js
+var EMBEDDED_LANGUAGES = /* @__PURE__ */ new Set(["sysml", "kerml"]);
+var EXPRESSION_VALUED_OWNERS = /* @__PURE__ */ new Set([
+  "AssertConstraintStmt",
+  "AssumeConstraintStmt",
+  "RequireConstraintStmt",
+  "ConstraintDecl",
+  "InvShorthand",
+  "CalcDecl",
+  "ExpressionDecl"
+]);
+function isEmbeddedLanguage(raw) {
+  if (typeof raw !== "string")
+    return false;
+  return EMBEDDED_LANGUAGES.has(raw.replace(/^"|"$/gu, "").trim().toLowerCase());
+}
+function bareName(node) {
+  const name = node?.name;
+  return typeof name === "string" && name.length > 0 ? name.replace(/^'|'$/gu, "") : void 0;
+}
+function kindOf(node) {
+  const decl = /^([A-Z][a-z]+)Decl$/.exec(node.$type);
+  if (decl) {
+    const base = decl[1].toLowerCase();
+    return node.isDef ? `${base} def` : base;
+  }
+  switch (node.$type) {
+    case "Package":
+      return "package";
+    case "InvShorthand":
+      return "inv";
+    case "AssertConstraintStmt":
+      return "assert constraint";
+    case "AssumeConstraintStmt":
+      return "assume constraint";
+    case "RequireConstraintStmt":
+      return "require constraint";
+    default:
+      return node.$type;
+  }
+}
+function hasErrors(result) {
+  return result.lexerErrors.length > 0 || result.parserErrors.length > 0;
+}
+function describeParserError(error) {
+  const image = error.token?.image ?? "";
+  const expecting = /Expecting token of type '([^']+)'/u.exec(error.message ?? "");
+  if (image === "") {
+    return expecting ? `the body ends while '${expecting[1]}' is still expected.` : "the body ends before it is complete.";
+  }
+  if (error.name === "NotAllInputParsedException") {
+    return `'${image}' is left over after the representation is already complete.`;
+  }
+  if (expecting)
+    return `expected '${expecting[1]}' but found '${image}'.`;
+  return `unexpected '${image}'.`;
+}
+function describeLexerError(error) {
+  const character = /unexpected character: ->(.*?)<-/u.exec(error.message ?? "");
+  return character ? `unexpected character '${character[1]}'.` : error.message ?? "the body cannot be read.";
+}
+function failureOf(result, span) {
+  const endLine = Math.max(0, span.lines.length - 1);
+  const end = { line: endLine, character: span.lines[endLine]?.text.length ?? 0 };
+  const lexical = result.lexerErrors[0];
+  const syntactic = result.parserErrors[0];
+  if (lexical && Number.isFinite(lexical.line)) {
+    return {
+      line: lexical.line - 1,
+      character: Math.max(0, (Number.isFinite(lexical.column) ? lexical.column : 1) - 1),
+      message: describeLexerError(lexical)
+    };
+  }
+  if (syntactic) {
+    const token = syntactic.token;
+    const message = describeParserError(syntactic);
+    if (Number.isFinite(token?.startLine) && Number.isFinite(token?.startColumn)) {
+      return { line: token.startLine - 1, character: token.startColumn - 1, message };
+    }
+    return { ...end, message };
+  }
+  return { ...end, message: lexical ? describeLexerError(lexical) : "the body is not valid SysML." };
+}
+function conformance(parsed, owner) {
+  if (!parsed || !owner || owner.$type === "Document")
+    return { status: "ok" };
+  const sameKind = parsed.$type === owner.$type && Boolean(parsed.isDef) === Boolean(owner.isDef);
+  if (!sameKind) {
+    return { status: "mismatch", mismatch: { reason: "kind", expected: kindOf(owner), actual: kindOf(parsed) } };
+  }
+  const expected = bareName(owner);
+  const actual = bareName(parsed);
+  if (expected && actual && expected !== actual) {
+    return { status: "mismatch", mismatch: { reason: "name", expected, actual } };
+  }
+  return { status: "ok" };
+}
+function nodesOf(root3) {
+  return [root3, ...ast_utils_exports.streamAllContents(root3)];
+}
+function declaredNames(root3) {
+  const names = /* @__PURE__ */ new Set();
+  for (const node of nodesOf(root3)) {
+    const name = node.name;
+    if (typeof name === "string" && name.length > 0)
+      names.add(name.replace(/^'|'$/gu, ""));
+  }
+  return names;
+}
+function graftInto(fragment, owner) {
+  const mutable = fragment;
+  mutable.$container = owner;
+  mutable.$containerProperty = "members";
+}
+function firstSegment(refText) {
+  return (refText.split("::")[0] ?? refText).replace(/^'|'$/gu, "").trim();
+}
+function unresolvedReferences(fragment, owner) {
+  graftInto(fragment, owner);
+  const own = declaredNames(fragment);
+  const out = [];
+  for (const node of nodesOf(fragment)) {
+    for (const [property3, value] of Object.entries(node)) {
+      if (property3.startsWith("$"))
+        continue;
+      for (const candidate of Array.isArray(value) ? value : [value]) {
+        if (!isReference(candidate))
+          continue;
+        const reference = candidate;
+        const refText = reference.$refText;
+        if (!refText || own.has(firstSegment(refText)))
+          continue;
+        let resolved;
+        try {
+          resolved = reference.ref;
+        } catch {
+          return [];
+        }
+        if (resolved)
+          continue;
+        const range = reference.$refNode?.range;
+        if (!range)
+          continue;
+        out.push({
+          refText,
+          line: range.start.line,
+          character: range.start.character,
+          length: Math.max(1, range.end.character - range.start.character)
+        });
+      }
+    }
+  }
+  return out;
+}
+function evaluateRepresentation(parser, rep) {
+  if (!isEmbeddedLanguage(rep.language))
+    return void 0;
+  const span = trailingBlockBodySpan(rep);
+  if (!span)
+    return void 0;
+  const owner = rep.$container;
+  const context = owner && owner.$type !== "Document" ? owner : void 0;
+  const declaration = parser.parse(span.text, { rule: "NamespaceElement" });
+  if (!hasErrors(declaration)) {
+    return {
+      span,
+      verdict: conformance(declaration.value, owner),
+      unresolved: context ? unresolvedReferences(declaration.value, context) : [],
+      fragment: declaration.value,
+      tier: "declaration"
+    };
+  }
+  if (owner && EXPRESSION_VALUED_OWNERS.has(owner.$type)) {
+    const expression = parser.parse(span.text, { rule: "Expr" });
+    if (!hasErrors(expression)) {
+      return {
+        span,
+        verdict: { status: "ok" },
+        unresolved: context ? unresolvedReferences(expression.value, context) : [],
+        fragment: expression.value,
+        tier: "expression"
+      };
+    }
+  }
+  return { span, verdict: { status: "unparsed", failure: failureOf(declaration, span) }, unresolved: [] };
+}
+
 // ../language-server/out/src/services/conformance.js
 var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([
   ":>",
@@ -59917,7 +60314,14 @@ var SysmlValidator = class _SysmlValidator {
   langiumDocuments;
   astNodeLocator;
   featurePaths;
+  // REQ-396 — One SysmlValidator instance is registered against BOTH the SysML and
+  // the KerML services (sysml-module.ts), so the parser used to read an embedded
+  // representation is looked up from the document being validated rather than
+  // captured here. The two share one grammar today; this keeps that from becoming
+  // load-bearing.
+  serviceRegistry;
   constructor(services) {
+    this.serviceRegistry = services.shared.ServiceRegistry;
     this.indexManager = services.shared.workspace.IndexManager;
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
     this.astNodeLocator = services.workspace.AstNodeLocator;
@@ -59933,23 +60337,38 @@ var SysmlValidator = class _SysmlValidator {
   // Langium linker cannot diagnose a missing intermediate feature. Resolve the
   // chain here and underline only the first invalid segment.
   checkPathExpr(node, accept) {
+    const fault = this.featurePathFault(node);
+    if (!fault)
+      return;
+    accept(severity("RES001", "error"), DIAGNOSTIC_MESSAGES.RES001_FEATURE_PATH_SEGMENT(fault.segment, fault.owner), {
+      node,
+      range: fault.range,
+      code: "RES001",
+      data: { featurePathSegment: true }
+    });
+  }
+  // REQ-317, REQ-396 — The one place that decides whether a written feature path
+  // has a provably absent segment. Extracted so an embedded representation body is
+  // judged by exactly this rule (issue #150 review): a body is grafted onto the
+  // element it represents and is therefore unreachable from the document walk that
+  // dispatches `checkPathExpr`, so without a shared decision the two would drift
+  // and a body would quietly escape a diagnostic the surrounding model receives.
+  featurePathFault(node) {
     let declaration = node.$container;
     while (declaration && !isPartDecl(declaration))
       declaration = declaration.$container;
     const modifiers2 = declaration?.modifiers ?? [];
     if (!declaration || !modifiers2.includes("ref"))
-      return;
+      return void 0;
     const resolution = this.featurePaths.resolve(node);
     if (resolution.unresolvedIndex === void 0)
-      return;
+      return void 0;
     const invalid = resolution.segments[resolution.unresolvedIndex];
-    const owner = resolution.unresolvedIndex > 0 ? resolution.segments[resolution.unresolvedIndex - 1].text : "the current scope";
-    accept(severity("RES001", "error"), DIAGNOSTIC_MESSAGES.RES001_FEATURE_PATH_SEGMENT(invalid.text, owner), {
-      node,
-      range: invalid.cst.range,
-      code: "RES001",
-      data: { featurePathSegment: true }
-    });
+    return {
+      segment: invalid.text,
+      owner: resolution.unresolvedIndex > 0 ? resolution.segments[resolution.unresolvedIndex - 1].text : "the current scope",
+      range: invalid.cst.range
+    };
   }
   // REQ-389 — Namespace qualification versus feature chaining in every written path
   // issue #213 — RES019: `::` binds tighter than `.`. Each dot-separated link of
@@ -60180,6 +60599,7 @@ var SysmlValidator = class _SysmlValidator {
     this.checkConnectorForms(node, accept);
     this.checkActionStartSuccessions(node, accept);
     this.checkAnnotationForms(node, accept);
+    this.checkEmbeddedRepresentations(node, accept);
     this.checkLanguageDisjointness(node, accept);
     this.checkKermlWellFormedness(node, accept);
     this.checkFilterExpressions(node, accept);
@@ -60268,6 +60688,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) {
@@ -60503,6 +60940,132 @@ ${baseIndent}}`;
       }
     }
   }
+  // REQ-396 — SYN076/SEM012 embedded textual representations (issue #150).
+  // A `rep … language "sysml"` (or `"kerml"`, matched case-insensitively) is not
+  // opaque content: OMG KerML §7.4.3 requires its body to be a legal representation
+  // of the element it annotates. So the body is processed by the comment-body rules,
+  // parsed, and compared against that element:
+  //   SYN076 — the body is not valid SysML, reported ON the offending character
+  //            inside the body rather than on the `rep` keyword.
+  //   SEM012 — the body parses but represents a different element (wrong kind, or
+  //            the right kind under a different name).
+  // Every other language stays opaque and is never parsed — an `alf`, `ocl` or
+  // `yaml` body is content, and the vendored OMG corpus holds only those.
+  checkEmbeddedRepresentations(node, accept) {
+    const doc = ast_utils_exports.getDocument(node);
+    if (!doc?.textDocument)
+      return;
+    let parser;
+    for (const child of ast_utils_exports.streamAllContents(node)) {
+      if (child.$type !== "RepStmt")
+        continue;
+      if (!isEmbeddedLanguage(child.language))
+        continue;
+      parser ??= this.serviceRegistry.getServices(doc.uri).parser.LangiumParser;
+      const evaluated = evaluateRepresentation(parser, child);
+      if (!evaluated)
+        continue;
+      const { span, verdict } = evaluated;
+      const language = String(child.language ?? "").replace(/^"|"$/gu, "");
+      if (verdict.status === "unparsed") {
+        const { line, character, message } = verdict.failure;
+        const anchor = bodyOffsetAt(span, line, character);
+        const after = bodyOffsetAt(span, line, character + 1);
+        const from = after > anchor ? anchor : bodyOffsetAt(span, line, Math.max(0, character - 1));
+        accept(severity("SYN076", "error"), DIAGNOSTIC_MESSAGES.SYN076_EMBEDDED_REPRESENTATION_SYNTAX(language, message), {
+          node: child,
+          range: {
+            start: doc.textDocument.positionAt(from),
+            end: doc.textDocument.positionAt(Math.max(after, anchor))
+          },
+          code: "SYN076"
+        });
+        continue;
+      }
+      for (const reference of evaluated.unresolved) {
+        accept(severity("RES020", "warning"), DIAGNOSTIC_MESSAGES.RES020_REPRESENTATION_UNRESOLVED(reference.refText, language), {
+          node: child,
+          range: {
+            start: doc.textDocument.positionAt(bodyOffsetAt(span, reference.line, reference.character)),
+            end: doc.textDocument.positionAt(bodyOffsetAt(span, reference.line, reference.character + reference.length))
+          },
+          code: "RES020"
+        });
+      }
+      if (evaluated.fragment) {
+        this.checkEmbeddedDialect(child, evaluated.fragment, language, span, doc, accept);
+        this.checkEmbeddedFeaturePaths(child, evaluated.fragment, language, span, doc, accept);
+      }
+      if (verdict.status === "ok")
+        continue;
+      const { reason, expected, actual } = verdict.mismatch;
+      const owner = child.$container;
+      accept(severity("SEM012", "warning"), reason === "kind" ? DIAGNOSTIC_MESSAGES.SEM012_REPRESENTATION_WRONG_KIND(expected, actual) : DIAGNOSTIC_MESSAGES.SEM012_REPRESENTATION_WRONG_NAME(expected, actual), {
+        node: child,
+        range: {
+          start: doc.textDocument.positionAt(bodyOffsetAt(span, 0, 0)),
+          end: doc.textDocument.positionAt(bodyOffsetAt(span, 0, span.lines[0]?.text.length ?? 0))
+        },
+        code: "SEM012",
+        relatedInformation: owner ? [relatedInfo(owner, "The element this representation annotates.")].filter((info) => info !== void 0) : void 0
+      });
+    }
+  }
+  // REQ-396 — SYN100/SYN101 inside a representation body (issue #150 review).
+  // The normative rule is that the body is legal in the language the representation
+  // NAMES, which is not the language of the file it sits in: a `.sysml` file may
+  // carry a `language "kerml"` representation, and its body may then use no
+  // SysML-only construct. `checkLanguageDisjointness` answers a different question
+  // — what may this FILE contain — from the host URI, so the same tables are read
+  // here against the declared language instead.
+  checkEmbeddedDialect(rep, fragment, language, span, doc, accept) {
+    const dialect = language.trim().toLowerCase();
+    const isKerml = dialect === "kerml";
+    const forbidden = isKerml ? SYSML_ONLY_TYPES : KERML_ONLY_TYPES;
+    const code = isKerml ? "SYN100" : "SYN101";
+    for (const node of [fragment, ...ast_utils_exports.streamAllContents(fragment)]) {
+      if (!forbidden.has(node.$type))
+        continue;
+      const range = node.$cstNode?.range;
+      if (!range)
+        continue;
+      accept(severity(code, "error"), isKerml ? `'${declKeyword(node)}' is a SysML construct and is not available in a "${language}" representation.` : `'${declKeyword(node)}' is a KerML-only construct \u2014 use the SysML form in a "${language}" representation.`, {
+        node: rep,
+        range: this.bodyRange(span, doc, range),
+        code
+      });
+    }
+  }
+  // REQ-396 — RES020 for a written feature path with a provably absent segment
+  // (issue #150 review). `checkPathExpr` is registered as a node-level check, so
+  // Langium dispatches it by walking the document AST and never reaches the grafted
+  // fragment. The decision itself is shared with it through `featurePathFault`, so
+  // a body is held to the same rule as the model around it rather than a parallel
+  // one that could drift; only the code differs, keeping every fault found IN a
+  // representation body under the one severity a team can tune.
+  checkEmbeddedFeaturePaths(rep, fragment, language, span, doc, accept) {
+    for (const node of [fragment, ...ast_utils_exports.streamAllContents(fragment)]) {
+      if (!this.featurePaths.isPathExpr(node))
+        continue;
+      const fault = this.featurePathFault(node);
+      if (!fault)
+        continue;
+      accept(severity("RES020", "warning"), DIAGNOSTIC_MESSAGES.RES020_REPRESENTATION_PATH_SEGMENT(fault.segment, fault.owner, language), {
+        node: rep,
+        range: this.bodyRange(span, doc, fault.range),
+        code: "RES020"
+      });
+    }
+  }
+  // REQ-396 — A range inside a parsed body, expressed in document coordinates.
+  // Fragment CST positions are line/character within the PROCESSED body, which is
+  // exactly what the span's line table converts.
+  bodyRange(span, doc, range) {
+    return {
+      start: doc.textDocument.positionAt(bodyOffsetAt(span, range.start.line, range.start.character)),
+      end: doc.textDocument.positionAt(bodyOffsetAt(span, range.end.line, range.end.character))
+    };
+  }
   // REQ-311 — SYN050/051 connector syntax, with a specific message in place of
   // the grammar's generic parse error:
   //   SYN050 — `connect a with b;` (use `connect a to b;`).
@@ -62910,6 +63473,7 @@ var STYLE_ADVISORY_CODES = /* @__PURE__ */ new Set([
   "STYL005",
   "STYL006",
   "STYL007",
+  "STYL008",
   "LEX009",
   // trailing whitespace
   "SYN024",
@@ -63376,52 +63940,6 @@ function outlineGroupForType(astType) {
   return CATEGORY_TO_OUTLINE_GROUP[categoryForType(astType)] ?? "structure";
 }
 
-// ../language-server/out/src/services/comment-body.js
-function sourceOf(node) {
-  return node.$cstNode?.root.fullText;
-}
-function cleanBlockBody(inner) {
-  let body = inner.trim();
-  if (body.startsWith("/*"))
-    body = body.slice(2);
-  if (body.endsWith("*/"))
-    body = body.slice(0, -2);
-  const lines = body.split("\n").map((line) => line.replace(/^\s*\*+ ?/u, "").replace(/\s+$/u, ""));
-  while (lines.length > 0 && lines[0].trim() === "")
-    lines.shift();
-  while (lines.length > 0 && lines[lines.length - 1].trim() === "")
-    lines.pop();
-  return lines.join("\n").trim();
-}
-function docCommentBody(node) {
-  const raw = node.doc;
-  if (typeof raw !== "string")
-    return void 0;
-  const start = raw.indexOf("/*");
-  const end = raw.lastIndexOf("*/");
-  if (start < 0 || end < start)
-    return void 0;
-  const body = cleanBlockBody(raw.slice(start, end + 2));
-  return body.length > 0 ? body : void 0;
-}
-function trailingBlockBody(node) {
-  const cst = node.$cstNode;
-  const text = sourceOf(node);
-  if (!cst || text === void 0)
-    return void 0;
-  const rest = text.slice(cst.end);
-  const open = rest.indexOf("/*");
-  if (open < 0)
-    return void 0;
-  if (rest.slice(0, open).trim() !== "")
-    return void 0;
-  const close = rest.indexOf("*/", open + 2);
-  if (close < 0)
-    return void 0;
-  const body = cleanBlockBody(rest.slice(open, close + 2));
-  return body.length > 0 ? body : void 0;
-}
-
 // ../language-server/out/src/services/document-symbol-provider.js
 var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([":>", "specializes"]);
 var REDEFINITION_KINDS = /* @__PURE__ */ new Set([":>>", "redefines"]);
@@ -63988,6 +64506,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;
@@ -64142,22 +64672,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;
@@ -64303,13 +64837,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);
@@ -64318,7 +64906,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) {
@@ -64671,11 +65259,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) {
@@ -64749,7 +65340,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];
@@ -64799,6 +65433,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)
@@ -66671,6 +67345,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. */
@@ -67302,14 +67989,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)) {
@@ -67417,13 +68616,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
@@ -67443,7 +68657,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);
     }
@@ -67457,7 +68673,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);
@@ -67468,7 +68686,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);
@@ -67479,7 +68699,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);
@@ -67668,14 +68890,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]",
@@ -67683,7 +68978,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;
@@ -67699,7 +69052,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) {
@@ -67714,7 +69067,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" };
@@ -68923,9 +70371,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),
@@ -70024,7 +71476,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.15.8" : "dev";
+var VERSION2 = true ? "0.17.0" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {