sysml-validate 0.16.0 → 0.18.0

package/out/main.js

@@ -57816,229 +57816,640 @@ function asDiagnosticLevel(value, fallback = "off") {
   return value === "off" || value === "warning" || value === "error" ? value : fallback;
 }
 
-// ../language-server/out/src/services/import-visibility.js
-var GlobalDescriptionIndex = class _GlobalDescriptionIndex {
-  /** Reuse an existing index; wrap a plain list. */
-  static from(source) {
-    return source instanceof _GlobalDescriptionIndex ? source : new _GlobalDescriptionIndex(source);
+// ../language-server/out/src/services/requirement-eval.js
+var UNRESOLVED = { kind: "unresolved" };
+var INCONCLUSIVE = { kind: "inconclusive" };
+var NULL_VALUE = { kind: "null" };
+var REDEFINE_KINDS = /* @__PURE__ */ new Set([":>>", ":>", "redefines", "subsets"]);
+function declaresFeature(node, name) {
+  if (node.name === name)
+    return true;
+  for (const rel of [...node.preRelationships ?? [], ...node.relationships ?? []]) {
+    if (rel.kind && REDEFINE_KINDS.has(rel.kind) && (rel.targets ?? []).includes(name))
+      return true;
   }
-  /** Exact name → descriptions carrying it (qualified and simple names alike). */
-  byName = /* @__PURE__ */ new Map();
-  /** Namespace path → descriptions for its DIRECT members (`A::B` → `A::B::C`). */
-  directMembers = /* @__PURE__ */ new Map();
-  /** Namespace path → descriptions for all its descendants (`A` → `A::B::C`). */
-  nestedMembers = /* @__PURE__ */ new Map();
-  constructor(descriptions) {
-    for (const desc of descriptions) {
-      push(this.byName, desc.name, desc);
-      let sep2 = desc.name.indexOf("::");
-      while (sep2 >= 0) {
-        const prefix = desc.name.slice(0, sep2);
-        push(this.nestedMembers, prefix, desc);
-        const next = desc.name.indexOf("::", sep2 + 2);
-        if (next < 0)
-          push(this.directMembers, prefix, desc);
-        sep2 = next;
-      }
+  return false;
+}
+function evaluateExpr(node, scope, ext) {
+  if (!node)
+    return INCONCLUSIVE;
+  const extended = ext?.(node, (child) => evaluateExpr(child, scope, ext));
+  if (extended)
+    return extended;
+  const n = node;
+  switch (n.$type) {
+    case "NumericPrimary":
+      return typeof n.numVal === "number" ? { kind: "number", value: n.numVal } : INCONCLUSIVE;
+    case "LiteralBool":
+      return { kind: "boolean", value: n.value === "true" };
+    case "LiteralStr":
+      return { kind: "string", value: decodeStringLiteral(String(n.value ?? "")) };
+    case "LiteralNull":
+      return INCONCLUSIVE;
+    case "ParenExpr": {
+      const items = n.items ?? [];
+      return items.length === 1 ? evaluateExpr(items[0], scope, ext) : INCONCLUSIVE;
     }
+    case "UnaryMinusExpr": {
+      const v = evaluateExpr(n.operand, scope, ext);
+      return v.kind === "number" ? { kind: "number", value: -v.value } : passThrough(v);
+    }
+    case "UnaryPlusExpr":
+      return evaluateExpr(n.operand, scope, ext);
+    case "NotExpr": {
+      if (!n.operand)
+        return INCONCLUSIVE;
+      const v = evaluateExpr(n.operand, scope, ext);
+      return v.kind === "boolean" ? { kind: "boolean", value: !v.value } : passThrough(v);
+    }
+    case "PathExpr":
+      return scope(String(n.path).split("."));
+    case "IfExpr": {
+      const cond = evaluateExpr(n.cond, scope, ext);
+      if (cond.kind !== "boolean")
+        return passThrough(cond);
+      return cond.value ? evaluateExpr(n.thenExpr, scope, ext) : evaluateExpr(n.elseExpr, scope, ext);
+    }
+    case "PostfixOp": {
+      if (n.unit && n.unitValue)
+        return evaluateExpr(n.unitValue, scope, ext);
+      if (n.operand)
+        return evaluateExpr(n.operand, scope, ext);
+      return INCONCLUSIVE;
+    }
+    case "BinExpr":
+      return evaluateBin(n, scope, ext);
+    default:
+      return INCONCLUSIVE;
   }
-  named(name) {
-    return this.byName.get(name) ?? EMPTY_DESCRIPTIONS;
-  }
-  firstNamed(name) {
-    return this.byName.get(name)?.[0];
-  }
-  membersOf(path10, wildcard) {
-    const map3 = wildcard === "shallow" ? this.directMembers : this.nestedMembers;
-    return map3.get(path10) ?? EMPTY_DESCRIPTIONS;
-  }
-};
-var EMPTY_DESCRIPTIONS = [];
-function push(map3, key, desc) {
-  const list = map3.get(key);
-  if (list)
-    list.push(desc);
-  else
-    map3.set(key, [desc]);
 }
-function expandImportEntries(imp, globalDescriptions, options = {}) {
-  const out = [];
-  expandImportInto(imp, GlobalDescriptionIndex.from(globalDescriptions), out, options, /* @__PURE__ */ new Set());
-  return dedupeEntries(out);
+function passThrough(v) {
+  return v.kind === "unresolved" ? UNRESOLVED : INCONCLUSIVE;
 }
-function importedPath(imp) {
-  const segments = [imp.head];
-  for (const seg of imp.segs) {
-    if (seg.name)
-      segments.push(seg.name);
+function decodeStringLiteral(raw) {
+  let body = raw;
+  if (body.length >= 2 && body.startsWith('"') && body.endsWith('"')) {
+    body = body.slice(1, -1);
   }
-  return segments.length > 0 ? segments.join("::") : void 0;
+  return body.replace(/\\(.)/gu, (_m, ch) => {
+    switch (ch) {
+      case "n":
+        return "\n";
+      case "t":
+        return "	";
+      case "b":
+        return "\b";
+      case "f":
+        return "\f";
+      default:
+        return ch;
+    }
+  });
 }
-function importWildcard(imp) {
-  let wildcard = "none";
-  for (const seg of imp.segs) {
-    if (seg.recursive)
-      wildcard = "recursive";
-    else if (seg.star)
-      wildcard = "shallow";
+function evaluateBin(node, scope, ext) {
+  const op = String(node.op);
+  const left = evaluateExpr(node.left, scope, ext);
+  if (op === "and" || op === "&") {
+    if (left.kind === "boolean" && !left.value)
+      return { kind: "boolean", value: false };
+  } else if (op === "or" || op === "|") {
+    if (left.kind === "boolean" && left.value)
+      return { kind: "boolean", value: true };
+  } else if (op === "implies") {
+    if (left.kind === "boolean" && !left.value)
+      return { kind: "boolean", value: true };
   }
-  return wildcard;
-}
-function importVisibility(imp) {
-  return imp.visibility ?? "private";
-}
-function resolveDescription(name, globalDescriptions) {
-  const index = GlobalDescriptionIndex.from(globalDescriptions);
-  const normalized = name.trim();
-  const direct = index.firstNamed(normalized);
-  if (direct)
-    return direct;
-  const simple = normalized.split(/::|\./).pop();
-  return simple ? index.firstNamed(simple) : void 0;
-}
-function descriptionKey(description) {
-  return `${description.documentUri.toString()}#${description.path}`;
-}
-function namespaceMembers(node) {
-  const n = node;
-  return [...n?.elements ?? [], ...n?.members ?? []];
-}
-function expandImportInto(imp, globalDescriptions, out, options, visitedNamespaces) {
-  const path10 = importedPath(imp);
-  if (!path10)
-    return;
-  const start = out.length;
-  const namedSegments = path10.split("::");
-  const wildcard = importWildcard(imp);
-  if (wildcard === "none") {
-    const targetDesc = resolveImportedDescription(path10, globalDescriptions, options, visitedNamespaces);
-    if (targetDesc) {
-      const alias = imp.alias ?? namedSegments[namedSegments.length - 1];
-      if (alias)
-        out.push({ name: alias, targetName: targetDesc.name, description: targetDesc });
+  const right = evaluateExpr(node.right, scope, ext);
+  if (left.kind === "unresolved" || right.kind === "unresolved")
+    return UNRESOLVED;
+  if (left.kind === "inconclusive" || right.kind === "inconclusive")
+    return INCONCLUSIVE;
+  switch (op) {
+    case "+":
+    case "-":
+    case "*":
+    case "/":
+    case "%":
+    case "**":
+    case "^":
+      if (left.kind === "number" && right.kind === "number") {
+        return { kind: "number", value: arith(op, left.value, right.value) };
+      }
+      return INCONCLUSIVE;
+    case "<":
+    case ">":
+    case "<=":
+    case ">=":
+      if (left.kind === "number" && right.kind === "number") {
+        return { kind: "boolean", value: compare(op, left.value, right.value) };
+      }
+      return INCONCLUSIVE;
+    case "==":
+    case "!=":
+    case "===":
+    case "!==": {
+      const eq3 = valuesEqual(left, right);
+      if (eq3 === void 0)
+        return INCONCLUSIVE;
+      return { kind: "boolean", value: op.startsWith("!") ? !eq3 : eq3 };
     }
-  } else {
-    expandNamespaceMembers(path10, wildcard, globalDescriptions, out);
-    expandNamespaceImports(path10, globalDescriptions, out, options, visitedNamespaces);
+    case "and":
+    case "&":
+      return bothBool(left, right, (a2, b) => a2 && b);
+    case "or":
+    case "|":
+      return bothBool(left, right, (a2, b) => a2 || b);
+    case "xor":
+      return bothBool(left, right, (a2, b) => a2 !== b);
+    case "implies":
+      return bothBool(left, right, (a2, b) => !a2 || b);
+    default:
+      return INCONCLUSIVE;
   }
-  applyImportFilters(imp, out, start, options);
 }
-function applyImportFilters(imp, out, start, options) {
-  const filters = imp.filters;
-  if (!filters || filters.length === 0 || out.length === start)
-    return;
-  const resolveRefs = options.resolveReferences !== false;
-  const kept = [];
-  for (let i = start; i < out.length; i++) {
-    const entry = out[i];
-    const node = options.nodeOf?.(entry.description) ?? entry.description.node;
-    if (!node || entryMatchesAllFilters(node, filters, resolveRefs))
-      kept.push(entry);
+function arith(op, a2, b) {
+  switch (op) {
+    case "+":
+      return a2 + b;
+    case "-":
+      return a2 - b;
+    case "*":
+      return a2 * b;
+    case "/":
+      return a2 / b;
+    case "%":
+      return a2 % b;
+    case "**":
+    case "^":
+      return a2 ** b;
+    default:
+      return NaN;
   }
-  out.length = start;
-  out.push(...kept);
 }
-function entryMatchesAllFilters(node, filters, resolveRefs) {
-  const metadataTypes = attachedMetadataTypes(node, resolveRefs);
-  for (const filter3 of filters) {
-    const result = evaluateFilterCondition(filter3.condition, metadataTypes, resolveRefs);
-    if (result === false)
+function compare(op, a2, b) {
+  switch (op) {
+    case "<":
+      return a2 < b;
+    case ">":
+      return a2 > b;
+    case "<=":
+      return a2 <= b;
+    case ">=":
+      return a2 >= b;
+    default:
       return false;
   }
-  return true;
 }
-function evaluateFilterCondition(node, metadataTypes, resolveRefs) {
-  if (isSelfClassifyExpr(node)) {
-    if (node.op !== "@" && node.op !== "@@")
-      return void 0;
-    return metadataTypeMatches(node.type, metadataTypes, resolveRefs);
-  }
-  if (isNotExpr(node) && node.operand) {
-    const operand = evaluateFilterCondition(node.operand, metadataTypes, resolveRefs);
-    return operand === void 0 ? void 0 : !operand;
-  }
-  if (isParenExpr(node)) {
-    return node.items.length === 1 ? evaluateFilterCondition(node.items[0], metadataTypes, resolveRefs) : void 0;
-  }
-  if (isBinExpr(node)) {
-    if (CONJUNCTION_OPERATORS.has(node.op)) {
-      const left = evaluateFilterCondition(node.left, metadataTypes, resolveRefs);
-      const right = evaluateFilterCondition(node.right, metadataTypes, resolveRefs);
-      if (left === false || right === false)
-        return false;
-      return left === void 0 || right === void 0 ? void 0 : true;
-    }
-    if (DISJUNCTION_OPERATORS.has(node.op)) {
-      const left = evaluateFilterCondition(node.left, metadataTypes, resolveRefs);
-      const right = evaluateFilterCondition(node.right, metadataTypes, resolveRefs);
-      if (left === true || right === true)
-        return true;
-      return left === void 0 || right === void 0 ? void 0 : false;
+function valuesEqual(a2, b) {
+  if (a2.kind === "null" || b.kind === "null")
+    return a2.kind === b.kind;
+  if (a2.kind === "number" && b.kind === "number")
+    return a2.value === b.value;
+  if (a2.kind === "boolean" && b.kind === "boolean")
+    return a2.value === b.value;
+  if (a2.kind === "string" && b.kind === "string")
+    return a2.value === b.value;
+  return void 0;
+}
+function bothBool(a2, b, f) {
+  if (a2.kind === "boolean" && b.kind === "boolean")
+    return { kind: "boolean", value: f(a2.value, b.value) };
+  return INCONCLUSIVE;
+}
+function memberNamed(node, name, seen = /* @__PURE__ */ new Set()) {
+  if (!node || seen.has(node))
+    return void 0;
+  seen.add(node);
+  for (const member of node.members ?? []) {
+    if (member.value !== void 0 && declaresFeature(member, name))
+      return member;
+  }
+  for (const member of node.members ?? []) {
+    if (declaresFeature(member, name))
+      return member;
+  }
+  const typeRef = node.typing?.type?.ref;
+  return typeRef ? memberNamed(typeRef, name, seen) : void 0;
+}
+function resolveFeatureValue(root3, segments) {
+  let cur = root3;
+  for (const seg of segments) {
+    cur = memberNamed(cur, seg);
+    if (!cur)
+      return UNRESOLVED;
+  }
+  if (cur.value)
+    return evaluateExpr(cur.value, () => INCONCLUSIVE);
+  return INCONCLUSIVE;
+}
+function subjectScope(subjectName, subjectBinding) {
+  const binding = subjectBinding;
+  return (segments) => {
+    if (!binding)
+      return INCONCLUSIVE;
+    if (subjectName && segments[0] === subjectName) {
+      const rest = segments.slice(1);
+      if (rest.length === 0)
+        return INCONCLUSIVE;
+      return resolveFeatureValue(binding, rest);
+    }
+    return resolveFeatureValue(binding, segments);
+  };
+}
+function subjectNameOf(req) {
+  const subject = (req.members ?? []).find((m) => m.$type === "SubjectDecl");
+  return subject?.name;
+}
+function gatherConstraints(req) {
+  const out = [];
+  for (const member of req.members ?? []) {
+    if (member.$type === "RequireConstraintStmt" && member.body) {
+      out.push({ kind: "require", body: member.body, text: exprText(member.body) });
+    } else if (member.$type === "AssumeConstraintStmt" && member.body) {
+      out.push({ kind: "assume", body: member.body, text: exprText(member.body) });
     }
+  }
+  return out;
+}
+function exprText(node) {
+  return node.$cstNode?.text?.trim() ?? "";
+}
+function evaluateRequirement(req, subjectBinding) {
+  const requirement = req;
+  const subjectName = subjectNameOf(requirement);
+  const scope = subjectScope(subjectName, subjectBinding);
+  const constraints = gatherConstraints(requirement);
+  const details = [];
+  let sawInconclusive = false;
+  let sawUnresolved = false;
+  let failed = false;
+  for (const c of constraints) {
+    const v = evaluateExpr(c.body, scope);
+    let status2;
+    if (v.kind === "unresolved") {
+      status2 = "unresolved";
+      sawUnresolved = true;
+    } else if (v.kind !== "boolean") {
+      status2 = "inconclusive";
+      sawInconclusive = true;
+    } else if (v.value) {
+      status2 = "pass";
+    } else if (c.kind === "require") {
+      status2 = "fail";
+      failed = true;
+    } else {
+      status2 = "inconclusive";
+      sawInconclusive = true;
+    }
+    details.push({ kind: c.kind, status: status2, text: c.text });
+  }
+  let status;
+  if (constraints.length === 0)
+    status = "inconclusive";
+  else if (failed)
+    status = "fail";
+  else if (sawUnresolved)
+    status = "unresolved";
+  else if (sawInconclusive)
+    status = "inconclusive";
+  else
+    status = "pass";
+  return { status, details };
+}
+function bindingName(by) {
+  const n = by;
+  if (n?.$type !== "PathExpr")
     return void 0;
+  return n.path?.split(/::|\./).pop();
+}
+function evaluateVerificationCase(caseNode, resolveRequirement, resolvePart) {
+  const node = caseNode;
+  const subject = (node.members ?? []).find((m) => m.$type === "SubjectDecl");
+  const subjectBoundName = bindingName(subject?.value);
+  const subjectBinding = (subjectBoundName ? resolvePart(subjectBoundName) : void 0) ?? subject;
+  const verifies = [];
+  for (const member of node.members ?? []) {
+    if (member.$type !== "VerifyStmt")
+      continue;
+    const targetName = String(member.target ?? "").split(/::|\./).pop();
+    if (!targetName)
+      continue;
+    const req = resolveRequirement(targetName);
+    if (!req) {
+      verifies.push({ requirement: targetName, status: "unresolved" });
+      continue;
+    }
+    const boundName = bindingName(member.by);
+    const binding = (boundName ? resolvePart(boundName) : void 0) ?? subjectBinding;
+    verifies.push({ requirement: targetName, status: evaluateRequirement(req, binding).status });
   }
-  return void 0;
+  let status = "inconclusive";
+  if (verifies.length === 0)
+    status = "inconclusive";
+  else if (verifies.some((v) => v.status === "fail"))
+    status = "fail";
+  else if (verifies.some((v) => v.status === "unresolved"))
+    status = "error";
+  else if (verifies.some((v) => v.status === "inconclusive"))
+    status = "inconclusive";
+  else
+    status = "pass";
+  return { status, verifies };
 }
-var CONJUNCTION_OPERATORS = /* @__PURE__ */ new Set(["and", "&"]);
-var DISJUNCTION_OPERATORS = /* @__PURE__ */ new Set(["or", "|"]);
-function undecidableFilterCondition(condition) {
+
+// ../language-server/out/src/services/metadata-filter.js
+var INCONCLUSIVE2 = { kind: "inconclusive" };
+var SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([":>", "specializes", ":>>", "redefines", "subsets"]);
+var MAX_SPECIALIZATION_DEPTH = 32;
+var MAX_VALUE_DEPTH = 16;
+function evaluateFilterCondition(condition, element, options) {
   if (!condition)
     return void 0;
-  if (isSelfClassifyExpr(condition)) {
-    return condition.op === "@" || condition.op === "@@" ? void 0 : { node: condition, construct: `the '${condition.op}' classification operator` };
+  const ctx = {
+    element,
+    options,
+    metadata: attachedMetadata(element)
+  };
+  const value = evaluateExpr(condition, nameScope(ctx), extensionFor(ctx));
+  return value.kind === "boolean" ? value.value : void 0;
+}
+function extensionFor(ctx) {
+  const ext = (node, evaluate2) => {
+    switch (node.$type) {
+      case "SelfClassifyExpr":
+        return classify(node, ctx);
+      case "LiteralNull":
+        return NULL_VALUE;
+      case "PostfixOp":
+        return featureAccess(node, ctx, ext);
+      default:
+        return void 0;
+    }
+  };
+  return ext;
+}
+function classify(node, ctx) {
+  const op = node.op;
+  if (op === "@" || op === "@@" || op === "as" || op === "meta") {
+    const found = findMetadata(node.type, ctx);
+    return found === "unknown" ? INCONCLUSIVE2 : { kind: "boolean", value: found !== void 0 };
   }
-  if (isNotExpr(condition) && condition.operand) {
-    return undecidableFilterCondition(condition.operand);
+  if (op === "istype" || op === "hastype")
+    return classifyByType(op, node.type, ctx);
+  return INCONCLUSIVE2;
+}
+function featureAccess(node, ctx, ext) {
+  const segments = [];
+  let cur = node;
+  while (cur?.$type === "PostfixOp") {
+    const postfix = cur;
+    if (!(postfix.dot || postfix.select) || !postfix.field)
+      return void 0;
+    segments.unshift(postfix.field);
+    cur = postfix.target;
   }
-  if (condition.$type === "NotExpr")
+  const root3 = unwrapParen(cur);
+  const rootOp = root3?.op;
+  if (root3?.$type !== "SelfClassifyExpr" || !rootOp)
     return void 0;
-  if (isParenExpr(condition)) {
-    return condition.items.length === 1 ? undecidableFilterCondition(condition.items[0]) : { node: condition, construct: "a parenthesized expression list" };
+  if (rootOp !== "as" && rootOp !== "meta" && rootOp !== "@" && rootOp !== "@@")
+    return void 0;
+  const found = findMetadata(root3.type, ctx);
+  if (found === "unknown")
+    return INCONCLUSIVE2;
+  if (found === void 0)
+    return NULL_VALUE;
+  if (!found.annotation)
+    return INCONCLUSIVE2;
+  return metadataFeatureValue(found.annotation, segments, ctx, ext);
+}
+function metadataFeatureValue(annotation, segments, ctx, ext, depth = 0) {
+  if (segments.length === 0 || depth > MAX_VALUE_DEPTH)
+    return INCONCLUSIVE2;
+  const [head2, ...rest] = segments;
+  const definition = typeNodeOf(annotation, ctx);
+  const member = memberNamed2(annotation, head2, ctx) ?? memberNamed2(definition, head2, ctx);
+  if (!member)
+    return INCONCLUSIVE2;
+  if (rest.length > 0)
+    return metadataFeatureValue(member, rest, ctx, ext, depth + 1);
+  if (member.value)
+    return evaluateExpr(member.value, nameScope(ctx), ext);
+  return NULL_VALUE;
+}
+function memberNamed2(owner, name, ctx, depth = 0) {
+  if (!owner || depth > MAX_SPECIALIZATION_DEPTH)
+    return void 0;
+  const members = owner.members ?? [];
+  for (const member of members) {
+    if (member.value !== void 0 && declaresFeature2(member, name))
+      return member;
   }
-  if (isBinExpr(condition)) {
-    if (CONJUNCTION_OPERATORS.has(condition.op) || DISJUNCTION_OPERATORS.has(condition.op)) {
-      return undecidableFilterCondition(condition.left) ?? undecidableFilterCondition(condition.right);
-    }
-    return { node: condition, construct: `the '${condition.op}' operator` };
+  for (const member of members) {
+    if (declaresFeature2(member, name))
+      return member;
   }
-  return { node: condition, construct: describeFilterExpr(condition) };
+  for (const target of specializationTargets(owner)) {
+    const resolved = ctx.options.resolveName?.(target);
+    const inherited = memberNamed2(resolved, name, ctx, depth + 1);
+    if (inherited)
+      return inherited;
+  }
+  const typed = typeNodeOf(owner, ctx);
+  return typed ? memberNamed2(typed, name, ctx, depth + 1) : void 0;
 }
-function describeFilterExpr(node) {
-  if (isPostfixOp(node)) {
-    if ((node.dot || node.select) && node.field)
-      return `the '.${node.field}' feature access`;
-    if (node.arrow && node.invoke)
-      return `the '->${node.invoke}' invocation`;
-    return "this postfix expression";
+function declaresFeature2(node, name) {
+  if (node.name === name)
+    return true;
+  for (const rel of [...node.preRelationships ?? [], ...node.relationships ?? []]) {
+    if (rel.kind && SPECIALIZATION_KINDS.has(rel.kind) && (rel.targets ?? []).includes(name))
+      return true;
   }
-  if (isPathExpr(node))
-    return "a plain feature reference";
-  return "this expression form";
+  return false;
 }
-function attachedMetadataTypes(node, resolveRefs) {
-  const siblings = node.$container?.members;
-  if (!Array.isArray(siblings))
-    return [];
-  const index = siblings.indexOf(node);
-  if (index < 0)
+function attachedMetadata(node) {
+  if (!node)
     return [];
-  const types = [];
-  for (let i = index - 1; i >= 0; i--) {
-    const sibling = siblings[i];
-    if (sibling.$type !== "MetadataAnnotation")
-      break;
-    types.push({ ref: resolveRefs ? sibling.type?.ref : void 0, qname: sibling.type?.$refText });
+  const found = [];
+  for (const member of node.members ?? []) {
+    if (member.$type === "MetadataAnnotation")
+      addMetadata(found, member, member.type);
+  }
+  const container = node.$container;
+  if (container?.$type === "PrefixMetadataMember") {
+    for (const tag of container.tags ?? [])
+      addMetadata(found, void 0, tag.type);
   }
-  return types;
+  found.push(...container ? annotationsByMember(container).get(node) ?? [] : []);
+  return found;
 }
-function metadataTypeMatches(type, metadataTypes, resolveRefs) {
-  const filterRef = resolveRefs ? type.ref : void 0;
-  const filterName = type.$refText;
-  return metadataTypes.some((meta) => {
-    if (filterRef && meta.ref)
-      return meta.ref === filterRef;
-    return qualifiedNameMatches(filterName, meta.qname);
-  });
+function addMetadata(found, annotation, type) {
+  if (type)
+    found.push({ annotation, type });
+}
+var annotationsByContainer = /* @__PURE__ */ new WeakMap();
+function annotationsByMember(container) {
+  const cached = annotationsByContainer.get(container);
+  if (cached)
+    return cached;
+  const byMember = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  const attach = (member, entry) => {
+    const list = byMember.get(member);
+    if (list)
+      list.push(entry);
+    else
+      byMember.set(member, [entry]);
+  };
+  const members = container.members ?? [];
+  let pending = [];
+  for (const member of members) {
+    if (member.$type === "MetadataAnnotation" || member.$type === "MetadataDecl") {
+      const type = member.$type === "MetadataAnnotation" ? member.type : member.typing?.type;
+      if (!type)
+        continue;
+      const entry = { annotation: member, type };
+      const targets = member.targets ?? [];
+      if (targets.length > 0) {
+        for (const target of targets) {
+          const simple = target.split(/::|\./).pop();
+          if (!simple)
+            continue;
+          const list = byName.get(simple);
+          if (list)
+            list.push(entry);
+          else
+            byName.set(simple, [entry]);
+        }
+      } else if (member.$type === "MetadataAnnotation") {
+        pending.push(entry);
+      }
+      continue;
+    }
+    for (const entry of pending)
+      attach(member, entry);
+    pending = [];
+  }
+  if (byName.size > 0) {
+    for (const member of members) {
+      const entries = member.name ? byName.get(member.name) : void 0;
+      if (entries)
+        for (const entry of entries)
+          attach(member, entry);
+    }
+  }
+  annotationsByContainer.set(container, byMember);
+  return byMember;
+}
+function findMetadata(type, ctx) {
+  if (!type)
+    return "unknown";
+  for (const meta of ctx.metadata) {
+    if (metadataMatches(type, meta, ctx))
+      return meta;
+  }
+  if (metaclassMatches(type, ctx))
+    return { type };
+  return ctx.element ? void 0 : "unknown";
+}
+function metadataMatches(type, meta, ctx) {
+  const filterRef = ctx.options.resolveReferences ? type.ref : void 0;
+  const metaRef = ctx.options.resolveReferences ? meta.type.ref : void 0;
+  if (filterRef && metaRef && filterRef === metaRef)
+    return true;
+  const metaName = meta.type.$refText;
+  if (qualifiedNameMatches(type.$refText, metaName))
+    return true;
+  const metaDefinition = metaRef ?? (metaName ? ctx.options.resolveName?.(metaName) : void 0);
+  return specializes(metaDefinition, type, ctx);
+}
+function specializes(node, type, ctx, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (!node || depth > MAX_SPECIALIZATION_DEPTH || seen.has(node))
+    return false;
+  seen.add(node);
+  for (const target of specializationTargets(node)) {
+    if (qualifiedNameMatches(type.$refText, target))
+      return true;
+    const resolved = ctx.options.resolveName?.(target);
+    if (resolved && ctx.options.resolveReferences && resolved === type.ref)
+      return true;
+    if (specializes(resolved, type, ctx, depth + 1, seen))
+      return true;
+  }
+  return false;
+}
+function metaclassMatches(type, ctx) {
+  if (!ctx.element)
+    return false;
+  const metaclass = metaclassNameOf(ctx.element);
+  const written = type.$refText;
+  if (!written)
+    return false;
+  if (qualifiedNameMatches(written, metaclass))
+    return true;
+  const definition = ctx.options.resolveName?.(`SysML::${metaclass}`) ?? ctx.options.resolveName?.(metaclass);
+  return specializes(definition, type, ctx);
+}
+function metaclassNameOf(node) {
+  if (isPackage(node))
+    return "Package";
+  const type = node.$type.endsWith("Decl") ? node.$type.slice(0, -"Decl".length) : node.$type;
+  const isDef = node.isDef;
+  if (typeof isDef === "boolean")
+    return `${type}${isDef ? "Definition" : "Usage"}`;
+  return type;
+}
+function classifyByType(op, type, ctx) {
+  if (!type || !ctx.element)
+    return INCONCLUSIVE2;
+  const declared = ctx.element.typing?.type;
+  if (!declared)
+    return INCONCLUSIVE2;
+  if (qualifiedNameMatches(type.$refText, declared.$refText))
+    return { kind: "boolean", value: true };
+  if (ctx.options.resolveReferences && type.ref && declared.ref === type.ref)
+    return { kind: "boolean", value: true };
+  if (op === "hastype")
+    return { kind: "boolean", value: false };
+  const declaredNode = (ctx.options.resolveReferences ? declared.ref : void 0) ?? (declared.$refText ? ctx.options.resolveName?.(declared.$refText) : void 0);
+  if (!declaredNode)
+    return INCONCLUSIVE2;
+  return { kind: "boolean", value: specializes(declaredNode, type, ctx) };
+}
+function nameScope(ctx, depth = 0) {
+  return (segments) => {
+    if (depth > MAX_VALUE_DEPTH)
+      return INCONCLUSIVE2;
+    const resolved = ctx.options.resolveName?.(segments.join("::"));
+    if (!resolved?.value)
+      return INCONCLUSIVE2;
+    return evaluateExpr(resolved.value, nameScope(ctx, depth + 1), extensionFor(ctx));
+  };
+}
+function specializationTargets(node) {
+  const targets = [];
+  for (const rel of [...node.preRelationships ?? [], ...node.relationships ?? []]) {
+    if (rel.kind && SPECIALIZATION_KINDS.has(rel.kind))
+      targets.push(...rel.targets ?? []);
+  }
+  return targets;
+}
+function typeNodeOf(node, ctx) {
+  const type = node?.type ?? node?.typing?.type;
+  if (!type)
+    return void 0;
+  const ref = ctx.options.resolveReferences ? type.ref : void 0;
+  return ref ?? (type.$refText ? ctx.options.resolveName?.(type.$refText) : void 0);
+}
+function unwrapParen(node) {
+  let cur = node;
+  while (cur?.$type === "ParenExpr") {
+    const items = cur.items ?? [];
+    if (items.length !== 1)
+      return cur;
+    cur = items[0];
+  }
+  return cur;
 }
 function qualifiedNameMatches(a2, b) {
   if (!a2 || !b)
@@ -58054,32 +58465,253 @@ function qualifiedNameMatches(a2, b) {
   }
   return true;
 }
-function resolveImportedDescription(path10, globalDescriptions, options, visitedNamespaces) {
-  const direct = globalDescriptions.firstNamed(path10);
-  if (direct)
-    return direct;
-  const split = path10.lastIndexOf("::");
-  if (split < 0)
-    return void 0;
-  const ownerPath = path10.slice(0, split);
-  const simpleName2 = path10.slice(split + 2);
-  const exported = [];
-  expandNamespaceImports(ownerPath, globalDescriptions, exported, options, visitedNamespaces);
-  return exported.find((entry) => entry.name === simpleName2)?.description;
-}
-function expandNamespaceMembers(path10, wildcard, globalDescriptions, out) {
-  const prefixLength = path10.length + 2;
-  for (const desc of globalDescriptions.membersOf(path10, wildcard)) {
-    if (isPrivateDescription(desc))
-      continue;
-    const rest = desc.name.slice(prefixLength);
-    const simple = rest.includes("::") ? rest.slice(rest.lastIndexOf("::") + 2) : rest;
-    out.push({ name: simple, targetName: desc.name, description: desc });
-  }
-}
-function expandNamespaceImports(path10, globalDescriptions, out, options, visitedNamespaces) {
-  for (const namespaceDesc of globalDescriptions.named(path10)) {
-    const key = descriptionKey(namespaceDesc);
+
+// ../language-server/out/src/services/import-visibility.js
+var GlobalDescriptionIndex = class _GlobalDescriptionIndex {
+  /** Reuse an existing index; wrap a plain list. */
+  static from(source) {
+    return source instanceof _GlobalDescriptionIndex ? source : new _GlobalDescriptionIndex(source);
+  }
+  /** Exact name → descriptions carrying it (qualified and simple names alike). */
+  byName = /* @__PURE__ */ new Map();
+  /** Namespace path → descriptions for its DIRECT members (`A::B` → `A::B::C`). */
+  directMembers = /* @__PURE__ */ new Map();
+  /** Namespace path → descriptions for all its descendants (`A` → `A::B::C`). */
+  nestedMembers = /* @__PURE__ */ new Map();
+  constructor(descriptions) {
+    for (const desc of descriptions) {
+      push(this.byName, desc.name, desc);
+      let sep2 = desc.name.indexOf("::");
+      while (sep2 >= 0) {
+        const prefix = desc.name.slice(0, sep2);
+        push(this.nestedMembers, prefix, desc);
+        const next = desc.name.indexOf("::", sep2 + 2);
+        if (next < 0)
+          push(this.directMembers, prefix, desc);
+        sep2 = next;
+      }
+    }
+  }
+  named(name) {
+    return this.byName.get(name) ?? EMPTY_DESCRIPTIONS;
+  }
+  firstNamed(name) {
+    return this.byName.get(name)?.[0];
+  }
+  membersOf(path10, wildcard) {
+    const map3 = wildcard === "shallow" ? this.directMembers : this.nestedMembers;
+    return map3.get(path10) ?? EMPTY_DESCRIPTIONS;
+  }
+};
+var EMPTY_DESCRIPTIONS = [];
+function push(map3, key, desc) {
+  const list = map3.get(key);
+  if (list)
+    list.push(desc);
+  else
+    map3.set(key, [desc]);
+}
+function expandImportEntries(imp, globalDescriptions, options = {}) {
+  const out = [];
+  expandImportInto(imp, GlobalDescriptionIndex.from(globalDescriptions), out, options, /* @__PURE__ */ new Set());
+  return dedupeEntries(out);
+}
+function importedPath(imp) {
+  const segments = [imp.head];
+  for (const seg of imp.segs) {
+    if (seg.name)
+      segments.push(seg.name);
+  }
+  return segments.length > 0 ? segments.join("::") : void 0;
+}
+function importForm(imp) {
+  let wildcard = "none";
+  let includesSelf = false;
+  const importAll = imp.isImportAll === true;
+  for (const seg of imp.segs) {
+    if (seg.recursive) {
+      wildcard = "recursive";
+      includesSelf = !seg.star;
+    } else if (seg.star) {
+      wildcard = "shallow";
+      includesSelf = false;
+    }
+  }
+  return { wildcard, includesSelf, importAll };
+}
+function importWildcard(imp) {
+  return importForm(imp).wildcard;
+}
+function importVisibility(imp) {
+  return imp.visibility ?? "private";
+}
+function resolveDescription(name, globalDescriptions) {
+  const index = GlobalDescriptionIndex.from(globalDescriptions);
+  const normalized = name.trim();
+  const direct = index.firstNamed(normalized);
+  if (direct)
+    return direct;
+  const simple = normalized.split(/::|\./).pop();
+  return simple ? index.firstNamed(simple) : void 0;
+}
+function descriptionKey(description) {
+  return `${description.documentUri.toString()}#${description.path}`;
+}
+function namespaceMembers(node) {
+  const n = node;
+  return [...n?.elements ?? [], ...n?.members ?? []];
+}
+function expandImportInto(imp, globalDescriptions, out, options, visitedNamespaces) {
+  const path10 = importedPath(imp);
+  if (!path10)
+    return;
+  const start = out.length;
+  const namedSegments = path10.split("::");
+  const form = importForm(imp);
+  if (form.wildcard === "none") {
+    const targetDesc = resolveImportedDescription(path10, globalDescriptions, options, visitedNamespaces, form.importAll);
+    if (targetDesc) {
+      const alias = imp.alias ?? namedSegments[namedSegments.length - 1];
+      if (alias)
+        out.push({ name: alias, targetName: targetDesc.name, description: targetDesc });
+    }
+  } else {
+    out.push(...selectMemberships(path10, form, globalDescriptions));
+    expandNamespaceImports(path10, globalDescriptions, out, options, visitedNamespaces, form.importAll);
+  }
+  applyImportFilters(imp, out, start, options);
+}
+function applyImportFilters(imp, out, start, options) {
+  const conditions = filterConditionsFor(imp);
+  if (conditions.length === 0 || out.length === start)
+    return;
+  const kept = keepMatching(conditions, out.slice(start), options);
+  out.length = start;
+  out.push(...kept);
+}
+function applyFilters(imp, entries, options = {}) {
+  const conditions = filterConditionsFor(imp);
+  return conditions.length === 0 ? entries : keepMatching(conditions, entries, options);
+}
+function keepMatching(conditions, entries, options) {
+  const evalOptions = {
+    resolveReferences: options.resolveReferences !== false,
+    resolveName: options.resolveName
+  };
+  return entries.filter((entry) => {
+    const node = options.nodeOf?.(entry.description) ?? entry.description.node;
+    return !node || conditions.every((c) => evaluateFilterCondition(c, node, evalOptions) !== false);
+  });
+}
+function filterConditionsFor(imp) {
+  const conditions = [];
+  const owner = imp.$container;
+  if (governsImportFilters(owner)) {
+    for (const member of namespaceMembers(owner)) {
+      const condition = member.condition;
+      if (member.$type === "FilterMember" && condition)
+        conditions.push(condition);
+    }
+  }
+  for (const filter3 of imp.filters ?? []) {
+    if (filter3.condition)
+      conditions.push(filter3.condition);
+  }
+  return conditions;
+}
+function governsImportFilters(owner) {
+  return !!owner && (isPackage(owner) || owner.$type === "Document");
+}
+function undecidableFilterCondition(condition, resolveName) {
+  if (!condition)
+    return void 0;
+  if (isSelfClassifyExpr(condition))
+    return void 0;
+  if (isNotExpr(condition) && condition.operand) {
+    return undecidableFilterCondition(condition.operand, resolveName);
+  }
+  if (condition.$type === "NotExpr")
+    return void 0;
+  if (isParenExpr(condition)) {
+    return condition.items.length === 1 ? undecidableFilterCondition(condition.items[0], resolveName) : { node: condition, construct: "a parenthesized expression list" };
+  }
+  if (isBinExpr(condition)) {
+    return undecidableFilterCondition(condition.left, resolveName) ?? undecidableFilterCondition(condition.right, resolveName);
+  }
+  if (isPostfixOp(condition)) {
+    if ((condition.dot || condition.select) && condition.field) {
+      return undecidableFilterCondition(condition.target, resolveName);
+    }
+    if (condition.arrow && condition.invoke)
+      return { node: condition, construct: `the '->${condition.invoke}' invocation` };
+    return { node: condition, construct: "this postfix expression" };
+  }
+  if (isPathExpr(condition)) {
+    const target = resolveName?.(condition.path);
+    return target?.value !== void 0 ? void 0 : { node: condition, construct: "a plain feature reference" };
+  }
+  if (condition.$type === "IfExpr") {
+    const conditional = condition;
+    return undecidableFilterCondition(conditional.cond, resolveName) ?? undecidableFilterCondition(conditional.thenExpr, resolveName) ?? undecidableFilterCondition(conditional.elseExpr, resolveName);
+  }
+  if (DECIDABLE_LITERAL_TYPES.has(condition.$type))
+    return void 0;
+  return { node: condition, construct: "this expression form" };
+}
+var DECIDABLE_LITERAL_TYPES = /* @__PURE__ */ new Set([
+  "NumericPrimary",
+  "LiteralBool",
+  "LiteralStr",
+  "LiteralNull"
+]);
+function resolveImportedDescription(path10, globalDescriptions, options, visitedNamespaces, importAll = false) {
+  const direct = globalDescriptions.firstNamed(path10);
+  if (direct)
+    return direct;
+  const split = path10.lastIndexOf("::");
+  if (split < 0)
+    return void 0;
+  const ownerPath = path10.slice(0, split);
+  const simpleName2 = path10.slice(split + 2);
+  const exported = [];
+  expandNamespaceImports(ownerPath, globalDescriptions, exported, options, visitedNamespaces, importAll);
+  return exported.find((entry) => entry.name === simpleName2)?.description;
+}
+function selectMemberships(path10, form, globalDescriptions) {
+  if (form.wildcard === "none")
+    return [];
+  const index = GlobalDescriptionIndex.from(globalDescriptions);
+  const entries = [];
+  if (form.includesSelf) {
+    const simple = simpleNameOf(path10);
+    const self2 = index.named(path10).find((desc) => form.importAll || !isPrivateDescription(desc));
+    if (self2)
+      entries.push({ name: simple, targetName: self2.name, description: self2 });
+  }
+  const prefixLength = path10.length + 2;
+  for (const desc of index.membersOf(path10, form.wildcard)) {
+    if (!form.importAll && isPrivateDescription(desc))
+      continue;
+    const rest = desc.name.slice(prefixLength);
+    if (!rest)
+      continue;
+    const nested = rest.includes("::");
+    if (nested && !isOwnedMembership(desc))
+      continue;
+    entries.push({ name: nested ? rest.slice(rest.lastIndexOf("::") + 2) : rest, targetName: desc.name, description: desc });
+  }
+  return entries;
+}
+function simpleNameOf(path10) {
+  return path10.includes("::") ? path10.slice(path10.lastIndexOf("::") + 2) : path10;
+}
+function isOwnedMembership(desc) {
+  const kind = desc.derivedKind;
+  return kind !== "reexport" && kind !== "inherited";
+}
+function expandNamespaceImports(path10, globalDescriptions, out, options, visitedNamespaces, importAll = false) {
+  for (const namespaceDesc of globalDescriptions.named(path10)) {
+    const key = descriptionKey(namespaceDesc);
     if (visitedNamespaces.has(key))
       continue;
     visitedNamespaces.add(key);
@@ -58087,11 +58719,13 @@ function expandNamespaceImports(path10, globalDescriptions, out, options, visite
     for (const member of namespaceMembers(owner)) {
       if (!isImport(member))
         continue;
-      const visibility = importVisibility(member);
-      if (visibility === "private")
-        continue;
-      if (visibility === "protected" && !options.protectedNamespaceKeys?.has(key))
-        continue;
+      if (!importAll) {
+        const visibility = importVisibility(member);
+        if (visibility === "private")
+          continue;
+        if (visibility === "protected" && !options.protectedNamespaceKeys?.has(key))
+          continue;
+      }
       expandImportInto(member, globalDescriptions, out, options, visitedNamespaces);
     }
   }
@@ -58505,11 +59139,11 @@ function evaluate(node, mode, ctx) {
     return { kind: "unknown" };
   }
   if (isBinExpr(node)) {
-    return evaluateBin(node, mode, ctx);
+    return evaluateBin2(node, mode, ctx);
   }
   return { kind: "unknown" };
 }
-function evaluateBin(node, mode, ctx) {
+function evaluateBin2(node, mode, ctx) {
   const op = node.op;
   const left = evaluate(node.left, mode, ctx);
   const right = evaluate(node.right, mode, ctx);
@@ -58649,6 +59283,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
@@ -58658,13 +59304,26 @@ var DIAGNOSTIC_MESSAGES = {
   // implicit-redefinition resolution this validator does not yet model.
   RES017_DUPLICATE_MEMBER: (name) => `'${name}' is already declared in this namespace. Members must be distinguishable by name \u2014 rename or remove the duplicate.`,
   RES017_DUPLICATE_SHORT_NAME: (name) => `Short name '<${name}>' is already used in this namespace. Members must be distinguishable \u2014 rename the short name.`,
-  // issue #102 — REQ-387. The filter evaluator (`import-visibility.ts`,
-  // `evaluateFilterCondition`) decides metadata-presence tests and the Boolean
-  // operators over them; every other form fails OPEN, keeping the member. Failing
-  // open is the right default — under-importing would manufacture spurious
-  // RES001s — but an unevaluated filter produces a scope or view that looks
-  // authoritative and is not, so the fail-open is stated rather than assumed.
-  RES018_UNEVALUATED_FILTER: (subject, construct) => `${subject} filter is not evaluated: ${construct} is outside the metadata-filter evaluator, which decides '@'/'@@' metadata tests combined with 'not', 'and'/'&', and 'or'/'|'. The filter fails open \u2014 it is treated as pass-through and removes nothing.`,
+  // issue #102 — REQ-387. The filter evaluator (`metadata-filter.ts`,
+  // `evaluateFilterCondition`) decides the model-level predicate surface; the
+  // invocation and collection forms outside it fail OPEN, keeping the member.
+  // Failing open is the right default — under-importing would manufacture
+  // spurious RES001s — but an unevaluated filter produces a scope or view that
+  // looks authoritative and is not, so the fail-open is stated, not assumed.
+  RES018_UNEVALUATED_FILTER: (subject, construct) => `${subject} filter is not evaluated: ${construct} is outside the metadata-filter evaluator, which decides metadata tests, the classification operators, metadata feature access, and the Boolean, comparison and arithmetic operators over them. The filter fails open \u2014 it is treated as pass-through and removes nothing.`,
+  // issue #154 — OMG SysML v2 Part 1 §7.5.5 (Root Namespace). The root
+  // namespace of a file is anonymous and unnamed, so nothing can import it:
+  // a `public` or `protected` import owned directly by it claims a re-export
+  // no other namespace is able to consume. The Release BNF requires `private`
+  // there, and rewriting it is mechanical — the import keeps working exactly
+  // as it did, since a root import was never re-exported to begin with.
+  RES021_ROOT_IMPORT_VISIBILITY: (visibility) => `An import in a file's root namespace must be 'private' \u2014 nothing can import the root namespace, so '${visibility}' re-exports to no one.`,
+  // issue #153 — OMG SysML v2 Part 1 §7.5.4 (Filtered Packages) puts an element
+  // filter in a package, where it restricts that package's imported memberships;
+  // a view body is the one other place it is defined for (it restricts what the
+  // view exposes). Anywhere else the member parses but nothing consumes it, so
+  // it silently does nothing.
+  KSM012_FILTER_PLACEMENT: (owner) => `A 'filter' member is only meaningful in a package or a view \u2014 it has no effect in a ${owner} body.`,
   // REQ-389 — Namespace qualification versus feature chaining in every written path
   // issue #213 — the KerML textual BNF binds `::` tighter than `.`: each
   // dot-separated link of a FeatureChain is a complete QualifiedName, and only
@@ -58911,7 +59570,7 @@ function commentBody(text) {
     return text.slice(2, -2);
   return void 0;
 }
-function classify(text) {
+function classify2(text) {
   const body = commentBody(text);
   if (body === void 0)
     return void 0;
@@ -58966,7 +59625,7 @@ function scanFormatDirectives(document) {
     const leaf = leaves[index];
     if (!leaf.hidden)
       continue;
-    const classified = classify(leaf.text);
+    const classified = classify2(leaf.text);
     if (!classified)
       continue;
     const comment = { offset: leaf.offset, end: leaf.end };
@@ -59067,6 +59726,8 @@ var SysmlIndexManager = class extends DefaultIndexManager {
       // REQ-068 — preserve declared visibility for wildcard re-export.
       ...symbol.isPrivate ? { isPrivate: true } : {},
       ...symbol.visibility ? { visibility: symbol.visibility } : {},
+      // issue #152 — a re-exported alias is not owned nesting.
+      ...symbol.derivedKind ? { derivedKind: symbol.derivedKind } : {},
       // REQ-242 — issue #103 — keeps type completion to definitions.
       ...symbol.isUsage ? { isUsage: true } : {}
     };
@@ -59142,7 +59803,7 @@ function encodeUnrestrictedName(value) {
 }
 
 // ../language-server/out/src/services/feature-path-resolver.js
-var SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 function nameOf(node) {
   const name = node?.name;
   if (typeof name === "string" && name.length > 0)
@@ -59455,7 +60116,7 @@ var FeaturePathResolver = class {
     const relNode = node;
     const result = [];
     for (const relation of [...relNode.preRelationships ?? [], ...relNode.relationships ?? []]) {
-      if (!relation.kind || !SPECIALIZATION_KINDS.has(relation.kind))
+      if (!relation.kind || !SPECIALIZATION_KINDS2.has(relation.kind))
         continue;
       for (const target of relation.targets ?? []) {
         const description = this.pickDescription(snapshot.byName.get(target)) ?? this.pickDescription(snapshot.byName.get(lastSegment2(target)));
@@ -59481,7 +60142,7 @@ var FeaturePathResolver = class {
       const candidates = refText ? snapshot.byName.get(refText) ?? snapshot.byName.get(lastSegment2(refText)) : void 0;
       return candidates?.length === 1;
     }
-    const semanticRelationships = [...record.preRelationships ?? [], ...record.relationships ?? []].filter((relation) => relation.kind && SPECIALIZATION_KINDS.has(relation.kind));
+    const semanticRelationships = [...record.preRelationships ?? [], ...record.relationships ?? []].filter((relation) => relation.kind && SPECIALIZATION_KINDS2.has(relation.kind));
     return semanticRelationships.length > 0 && semanticRelationships.every((relation) => (relation.targets ?? []).every((target) => Boolean(this.nodeOf(this.pickDescription(snapshot.byName.get(target))) ?? this.nodeOf(this.pickDescription(snapshot.byName.get(lastSegment2(target)))))));
   }
   followAlias(target, snapshot) {
@@ -59596,84 +60257,352 @@ function isNamespaceOnlyDecl(node) {
   return node.isDef === true;
 }
 
-// ../language-server/out/src/services/conformance.js
-var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([
-  ":>",
-  ":>>",
-  "specializes",
-  "subsets",
-  "redefines"
-]);
-var COMPOSITION_KINDS = /* @__PURE__ */ new Set(["unions", "intersects", "differences"]);
-var MAX_CLOSURE_DEPTH = 32;
-function simpleTypeName(name) {
-  const last2 = name.trim().split(/::|\./u).pop() ?? name.trim();
-  return last2.replace(/^'(.*)'$/u, "$1");
+// ../language-server/out/src/services/comment-body.js
+function sourceOf(node) {
+  return node.$cstNode?.root.fullText;
 }
-function declaredTypesOf(node) {
-  const decl = node;
-  const out = [];
-  for (const typing of [decl.typing, ...decl.moreTypings ?? []]) {
-    if (!typing)
-      continue;
-    const conjugated = typing.conjugate === true;
-    for (const ref of [typing.type, ...typing.moreTypes ?? []]) {
-      const text = ref?.$refText?.trim();
-      if (text)
-        out.push({ text, simple: simpleTypeName(text), conjugated });
-    }
+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;
   }
-  return out;
-}
-function specializedNamesOf(node) {
-  const decl = node;
-  const out = [];
-  for (const rel of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
-    if (!rel.kind || !SPECIALIZATION_KINDS2.has(rel.kind))
-      continue;
-    for (const target of rel.targets ?? []) {
-      const text = target.trim();
-      if (text)
-        out.push(text);
-    }
+  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;
   }
-  return out;
-}
-function compositionGroupsOf(node) {
-  const decl = node;
-  const out = [];
-  for (const rel of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
-    if (!rel.kind || !COMPOSITION_KINDS.has(rel.kind))
-      continue;
-    const targets = (rel.targets ?? []).map((t) => t.trim()).filter((t) => t.length > 0);
-    if (targets.length > 0)
-      out.push({ kind: rel.kind, targets });
+  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 out;
+  return lines;
 }
-function isAbstractDecl(node) {
-  return (node.modifiers ?? []).includes("abstract");
+function cleanBlockBody(inner) {
+  return cleanBlockBodyLines(inner, 0).map((line) => line.text).join("\n");
 }
-var SCALAR_ROOT_KINDS = {
-  String: "string",
-  Boolean: "boolean",
-  NumericalValue: "number",
-  Number: "number",
-  Integer: "number",
-  Rational: "number",
-  Real: "number",
-  Complex: "number",
-  Natural: "number",
-  Positive: "number",
-  Cardinal: "number"
-};
-function literalKindOf(node) {
-  if (!node)
+function docCommentBody(node) {
+  const raw = node.doc;
+  if (typeof raw !== "string")
     return void 0;
-  switch (node.$type) {
-    case "LiteralStr":
-      return "string";
-    case "LiteralBool":
+  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_KINDS3 = /* @__PURE__ */ new Set([
+  ":>",
+  ":>>",
+  "specializes",
+  "subsets",
+  "redefines"
+]);
+var COMPOSITION_KINDS = /* @__PURE__ */ new Set(["unions", "intersects", "differences"]);
+var MAX_CLOSURE_DEPTH = 32;
+function simpleTypeName(name) {
+  const last2 = name.trim().split(/::|\./u).pop() ?? name.trim();
+  return last2.replace(/^'(.*)'$/u, "$1");
+}
+function declaredTypesOf(node) {
+  const decl = node;
+  const out = [];
+  for (const typing of [decl.typing, ...decl.moreTypings ?? []]) {
+    if (!typing)
+      continue;
+    const conjugated = typing.conjugate === true;
+    for (const ref of [typing.type, ...typing.moreTypes ?? []]) {
+      const text = ref?.$refText?.trim();
+      if (text)
+        out.push({ text, simple: simpleTypeName(text), conjugated });
+    }
+  }
+  return out;
+}
+function specializedNamesOf(node) {
+  const decl = node;
+  const out = [];
+  for (const rel of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
+    if (!rel.kind || !SPECIALIZATION_KINDS3.has(rel.kind))
+      continue;
+    for (const target of rel.targets ?? []) {
+      const text = target.trim();
+      if (text)
+        out.push(text);
+    }
+  }
+  return out;
+}
+function compositionGroupsOf(node) {
+  const decl = node;
+  const out = [];
+  for (const rel of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
+    if (!rel.kind || !COMPOSITION_KINDS.has(rel.kind))
+      continue;
+    const targets = (rel.targets ?? []).map((t) => t.trim()).filter((t) => t.length > 0);
+    if (targets.length > 0)
+      out.push({ kind: rel.kind, targets });
+  }
+  return out;
+}
+function isAbstractDecl(node) {
+  return (node.modifiers ?? []).includes("abstract");
+}
+var SCALAR_ROOT_KINDS = {
+  String: "string",
+  Boolean: "boolean",
+  NumericalValue: "number",
+  Number: "number",
+  Integer: "number",
+  Rational: "number",
+  Real: "number",
+  Complex: "number",
+  Natural: "number",
+  Positive: "number",
+  Cardinal: "number"
+};
+function literalKindOf(node) {
+  if (!node)
+    return void 0;
+  switch (node.$type) {
+    case "LiteralStr":
+      return "string";
+    case "LiteralBool":
       return "boolean";
     case "NumericPrimary":
       return "number";
@@ -59944,7 +60873,7 @@ function maskNonCode(text) {
   }
   return out.join("");
 }
-var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 var CONSTRAINT_SIDE_EFFECT_TYPES = /* @__PURE__ */ new Set([
   "AssignNode",
   "SendNode",
@@ -60034,7 +60963,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;
@@ -60050,23 +60986,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
@@ -60254,10 +61205,13 @@ var SysmlValidator = class _SysmlValidator {
     if (!node.visibility) {
       accept(severity("SYN067", "error"), "Import visibility is required by the Release syntax; use 'private import' unless re-export is intended.", { node, code: "SYN067" });
     }
+    if (node.visibility && node.visibility !== "private" && node.$container?.$type === "Document") {
+      accept(severity("RES021", "error"), DIAGNOSTIC_MESSAGES.RES021_ROOT_IMPORT_VISIBILITY(node.visibility), { node, property: "visibility", code: "RES021" });
+    }
     const headStr = node.head ?? "";
     const segsStr = node.segs.map((s) => {
       if (s.recursive)
-        return "::**";
+        return s.star ? "::*::**" : "::**";
       if (s.star)
         return "::*";
       return `::${s.name ?? ""}`;
@@ -60297,6 +61251,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);
@@ -60637,6 +61592,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;`).
@@ -61146,6 +62227,7 @@ ${baseIndent}}`;
     const index = this.buildIndex();
     const imports = [];
     const exposePaths = [];
+    const filterMembers = [];
     const decls = [];
     const verifyStmts = [];
     const satisfyStmts = [];
@@ -61159,6 +62241,8 @@ ${baseIndent}}`;
           aliasMap.set(alias, path10);
       } else if (isExposePath(child))
         exposePaths.push(child);
+      else if (child.$type === "FilterMember")
+        filterMembers.push(child);
       else if (isVerifyStmt(child))
         verifyStmts.push(child);
       else if (isSatisfyStmt(child))
@@ -61175,7 +62259,7 @@ ${baseIndent}}`;
     this.checkPrivateImports(imports, index, accept);
     this.checkPrivateWildcardReferences(node, imports, index, accept);
     this.checkImportCycles(imports, index, accept);
-    this.checkUnevaluatedFilters(imports, exposePaths, accept);
+    this.checkUnevaluatedFilters(imports, exposePaths, filterMembers, index, accept);
     if (sysmlDiagnosticSettings.unusedImports !== "off") {
       this.checkUnusedImports(node, imports, index, sysmlDiagnosticSettings.unusedImports, accept);
     }
@@ -61603,6 +62687,10 @@ ${baseIndent}}`;
       if (condition && isDefinitelyNonBoolean(condition)) {
         accept(severity("KSM008", "error"), "A filter condition must be a Boolean expression.", { node: child, code: "KSM008" });
       }
+      const owner = child.$container;
+      if (owner && !isFilterHost(owner)) {
+        accept(severity("KSM012", "error"), DIAGNOSTIC_MESSAGES.KSM012_FILTER_PLACEMENT(kindLabel(owner)), { node: child, code: "KSM012" });
+      }
     }
   }
   // REQ-328 — KSM006: a type-composition `unions`/`intersects`/`differences`
@@ -61892,7 +62980,8 @@ ${baseIndent}}`;
     const node = this.resolveUnique(nsName, index);
     const ownsNamespace = node !== void 0 && (isPackage(node) || node.$type === "NamespaceDecl" || (node.members?.length ?? 0) > 0);
     if (node && !ownsNamespace) {
-      accept(severity("RES007", "error"), `Recursive import '${nsName}::*::**' requires '${nsName}' to be a package, namespace, or usage that owns nested members.`, { node: imp, code: "RES007" });
+      const written = imp.segs.some((s) => s.recursive && s.star) ? `${nsName}::*::**` : `${nsName}::**`;
+      accept(severity("RES007", "error"), `Recursive import '${written}' requires '${nsName}' to be a package, namespace, or usage that owns nested members.`, { node: imp, code: "RES007" });
     }
   }
   // REQ-323 — RES008: an `alias … for X` whose target `X` does not resolve.
@@ -62019,6 +63108,8 @@ ${baseIndent}}`;
   // REQ-320 — RES004 importing a private element from outside its namespace
   checkPrivateImports(imports, index, accept) {
     for (const imp of imports) {
+      if (importForm(imp).importAll)
+        continue;
       const path10 = importedPath(imp);
       if (!path10)
         continue;
@@ -62041,13 +63132,15 @@ ${baseIndent}}`;
   // reference so the user learns why a `Pkg::*` did not bring it in.
   checkPrivateWildcardReferences(node, imports, index, accept) {
     const wildcards = [];
+    const importAllPaths = [];
     for (const imp of imports) {
-      const kind = importWildcard(imp);
-      if (kind === "none")
+      const form = importForm(imp);
+      if (form.wildcard === "none")
         continue;
       const path10 = importedPath(imp);
-      if (path10)
-        wildcards.push({ path: path10, recursive: kind === "recursive" });
+      if (!path10)
+        continue;
+      (form.importAll ? importAllPaths : wildcards).push({ path: path10, recursive: form.wildcard === "recursive" });
     }
     if (wildcards.length === 0)
       return;
@@ -62068,8 +63161,10 @@ ${baseIndent}}`;
       const ownerQn = ownerPkg ? qualifiedNameOf(ownerPkg) : void 0;
       if (!ownerQn)
         continue;
-      const reachedByWildcard = wildcards.some((w) => w.recursive ? ownerQn === w.path || ownerQn.startsWith(w.path + "::") : ownerQn === w.path);
-      if (!reachedByWildcard)
+      const reaches = (w) => w.recursive ? ownerQn === w.path || ownerQn.startsWith(w.path + "::") : ownerQn === w.path;
+      if (!wildcards.some(reaches))
+        continue;
+      if (importAllPaths.some(reaches))
         continue;
       const refNode = ref.$refNode?.astNode;
       if (refNode && isWithinNamespaceOf(refNode, target))
@@ -62151,9 +63246,10 @@ ${baseIndent}}`;
    * unevaluated filter to break a build raise it per code through
    * `sysml.validation.severities` (REQ-240).
    */
-  checkUnevaluatedFilters(imports, exposePaths, accept) {
+  checkUnevaluatedFilters(imports, exposePaths, filterMembers, index, accept) {
+    const resolveName = (name) => this.resolveUnique(name, index);
     const report = (condition, subject) => {
-      const undecidable = undecidableFilterCondition(condition);
+      const undecidable = undecidableFilterCondition(condition, resolveName);
       if (!undecidable)
         return;
       accept(severity("RES018", "info"), DIAGNOSTIC_MESSAGES.RES018_UNEVALUATED_FILTER(subject, undecidable.construct), { node: undecidable.node, code: "RES018" });
@@ -62163,6 +63259,11 @@ ${baseIndent}}`;
         report(filter3.condition, "Import");
     for (const path10 of exposePaths)
       report(path10.condition, "Expose");
+    for (const member of filterMembers) {
+      if (governsImportFilters(member.$container)) {
+        report(member.condition, "Package");
+      }
+    }
   }
   // REQ-324 — RES009 unused import (configurable, OFF by default)
   checkUnusedImports(root3, imports, index, level, accept) {
@@ -62183,7 +63284,7 @@ ${baseIndent}}`;
       return;
     const visited = /* @__PURE__ */ new Set();
     const reachesSelf = (node) => {
-      for (const targetName of specializationTargets(node)) {
+      for (const targetName of specializationTargets2(node)) {
         const target = this.resolve(targetName, index, node);
         if (!target)
           continue;
@@ -62570,14 +63671,14 @@ function shortNameOf(node) {
 function shortNameNodeOf(node) {
   return node.shortName;
 }
-function specializationTargets(node) {
+function specializationTargets2(node) {
   const out = [];
   const rels = [
     ...node.preRelationships ?? [],
     ...node.relationships ?? []
   ];
   for (const rel of rels) {
-    if (rel.kind && SPECIALIZATION_KINDS3.has(rel.kind))
+    if (rel.kind && SPECIALIZATION_KINDS4.has(rel.kind))
       out.push(...rel.targets);
   }
   return out;
@@ -62928,7 +64029,13 @@ function introducedNames(imp, index, nodeOf) {
   const protectedNamespaceKeys = protectedNamespaceKeysFor(imp.$container, globalDescs, nodeOf);
   return expandImportEntries(imp, globalDescs, {
     nodeOf,
-    protectedNamespaceKeys
+    protectedNamespaceKeys,
+    // issue #153 — filters may need a metadata definition's default value or
+    // a specialization chain; both are index lookups, not cross-references.
+    resolveName: (name) => {
+      const description = globalDescs.firstNamed(name);
+      return description ? nodeOf(description) : void 0;
+    }
   }).map((entry) => ({
     simple: entry.name,
     targetQn: entry.targetName,
@@ -62949,13 +64056,13 @@ function protectedNamespaceKeysFor(context, globalDescs, nodeOf) {
     const node = nodeOf(desc);
     if (!node || !isDeclLike(node))
       return;
-    for (const inherited of specializationTargets(node))
+    for (const inherited of specializationTargets2(node))
       collect(inherited);
   };
   let cur = context;
   while (cur) {
     if (isDeclLike(cur)) {
-      for (const target of specializationTargets(cur))
+      for (const target of specializationTargets2(cur))
         collect(target);
     }
     cur = cur.$container;
@@ -63009,6 +64116,15 @@ function importIsUsed(imp, index, usedFull, usedFirst, nodeOf) {
   }
   return false;
 }
+var FILTER_HOST_TYPES = /* @__PURE__ */ new Set([
+  "ViewDecl",
+  "ViewpointDecl",
+  "RenderingDecl",
+  "Document"
+]);
+function isFilterHost(owner) {
+  return isPackage(owner) || FILTER_HOST_TYPES.has(owner.$type);
+}
 function kindLabel(node) {
   const m = /^([A-Z][a-z]+)Decl$/.exec(node.$type);
   return m ? m[1].toLowerCase() : node.$type;
@@ -63511,54 +64627,8 @@ 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 SPECIALIZATION_KINDS5 = /* @__PURE__ */ new Set([":>", "specializes"]);
 var REDEFINITION_KINDS = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var INHERITABLE_FEATURE_TYPES = /* @__PURE__ */ new Set([
   "ActionDecl",
@@ -63623,11 +64693,11 @@ function buildLocalSymbolIndex(root3) {
   }
   return symbols;
 }
-function specializationTargets2(node) {
+function specializationTargets3(node) {
   const n = node;
   const out = [];
   for (const rel of [...n.preRelationships ?? [], ...n.relationships ?? []]) {
-    if (rel.kind && SPECIALIZATION_KINDS4.has(rel.kind))
+    if (rel.kind && SPECIALIZATION_KINDS5.has(rel.kind))
       out.push(...rel.targets ?? []);
   }
   return out;
@@ -63746,7 +64816,7 @@ function inheritedFeatureSymbols(node, inheritedRange, context, seen = /* @__PUR
     return [];
   seen.add(node);
   const symbols = [];
-  for (const targetName of specializationTargets2(node)) {
+  for (const targetName of specializationTargets3(node)) {
     const target = resolveLocalTarget(targetName, context);
     if (!target || seen.has(target))
       continue;
@@ -64351,7 +65421,7 @@ function nearestAncestor(node, types) {
   }
   return void 0;
 }
-function exprText(node) {
+function exprText2(node) {
   return node?.$cstNode?.text?.trim().replace(/\s+/gu, " ") ?? "";
 }
 function conditionTypeLabel(node) {
@@ -64362,7 +65432,7 @@ function conditionTypeLabel(node) {
   if (["AndExpr", "OrExpr", "XorExpr", "NotExpr", "CompareExpr", "ClassifyOp"].includes(node.$type)) {
     return "Boolean";
   }
-  const text = exprText(node);
+  const text = exprText2(node);
   return /\b(true|false)\b|[=!<>]=?|(?:\band\b|\bor\b|\bnot\b|\bxor\b)/u.test(text) ? "Boolean" : "Boolean (expected)";
 }
 function buildConditionalHover(node) {
@@ -64376,7 +65446,7 @@ function buildConditionalHover(node) {
     "",
     "Canonical form: `if condition ? thenExpression else elseExpression`",
     `Then marker: ${usesQuestion ? "canonical `?`" : "non-canonical `then`; use `?`"}`,
-    `Condition: \`${exprText(n.cond)}\``,
+    `Condition: \`${exprText2(n.cond)}\``,
     `Condition type: ${conditionTypeLabel(n.cond)}`,
     "",
     sourceFooter(nodeSource(node))
@@ -66514,7 +67584,15 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
       // metadata `.ref` here re-enters the linker (cyclic reference error,
       // and the reference is poisoned with a cached failure). Match filters
       // by textual name only on this path; the validator resolves refs.
-      resolveReferences: false
+      resolveReferences: false,
+      // issue #153 — the index lookup a filter needs for a metadata
+      // definition's default, a specialization chain or an enumeration
+      // member. It reads the symbol table rather than a cross-reference,
+      // so it is safe on this path where `.ref` is not.
+      resolveName: (name) => {
+        const description = globalDescs.firstNamed(name);
+        return description ? this.nodeOf(description) : void 0;
+      }
     };
     const result = [];
     for (const imp of this.visibleImportsFrom(contextNode)) {
@@ -66574,7 +67652,7 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
     const visitedTargets = /* @__PURE__ */ new Set();
     let cur = contextNode;
     while (cur) {
-      for (const target of specializationTargets3(cur)) {
+      for (const target of specializationTargets4(cur)) {
         this.collectProtectedNamespace(target, globalDescs, keys3, nodes, visitedTargets);
       }
       cur = cur.$container;
@@ -66596,7 +67674,7 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
       keys3.add(key);
       nodes.push(node);
     }
-    for (const inherited of specializationTargets3(node)) {
+    for (const inherited of specializationTargets4(node)) {
       this.collectProtectedNamespace(inherited, globalDescs, keys3, nodes, visitedTargets);
     }
   }
@@ -66615,16 +67693,7 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
   // every reference and re-expanded the whole standard library each time
   // (measured on a 1 500-line model: 226 misses over 349 references, 16 s).
   importContextKey(contextNode, protectedNamespaces) {
-    const parts = [];
-    let cur = contextNode;
-    while (cur) {
-      for (const member of namespaceMembers(cur)) {
-        if (isImport(member))
-          parts.push(importSignature(member));
-      }
-      cur = cur.$container;
-    }
-    const imports = parts.length > 0 ? parts.join(" ") : "root";
+    const imports = importContextSignature(contextNode);
     return protectedNamespaces.key ? `${imports} ${protectedNamespaces.key}` : imports;
   }
   nodeOf(desc) {
@@ -66640,6 +67709,23 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
 function ownsProtectedImport(node) {
   return namespaceMembers(node).some((member) => isImport(member) && importVisibility(member) === "protected");
 }
+function importContextSignature(contextNode) {
+  const parts = [];
+  let cur = contextNode;
+  while (cur) {
+    for (const member of namespaceMembers(cur)) {
+      if (isImport(member))
+        parts.push(importSignature(member));
+      else if (member.$type === "FilterMember")
+        parts.push(filterSignature(member));
+    }
+    cur = cur.$container;
+  }
+  return parts.length > 0 ? parts.join(" ") : "root";
+}
+function filterSignature(member) {
+  return `filter ${member.$cstNode?.text?.replace(/\s+/gu, " ").trim() ?? "?"}`;
+}
 function importSignature(imp) {
   const text = imp.$cstNode?.text;
   if (text)
@@ -66647,12 +67733,12 @@ function importSignature(imp) {
   const segments = imp.segs.map((seg) => `${seg.name ?? ""}${seg.star ? "*" : ""}${seg.recursive ? "**" : ""}`);
   return `${importVisibility(imp)} ${imp.head}::${segments.join("::")}${imp.alias ? ` as ${imp.alias}` : ""}`;
 }
-var SPECIALIZATION_KINDS5 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
-function specializationTargets3(node) {
+var SPECIALIZATION_KINDS6 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+function specializationTargets4(node) {
   const n = node;
   const out = [];
   for (const rel of [...n.preRelationships ?? [], ...n.relationships ?? []]) {
-    if (rel.kind && SPECIALIZATION_KINDS5.has(rel.kind))
+    if (rel.kind && SPECIALIZATION_KINDS6.has(rel.kind))
       out.push(...rel.targets ?? []);
   }
   return out;
@@ -66731,7 +67817,10 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
             const description = {
               ...entry.description,
               name: `${ownerAlias}::${entry.name}`,
-              isDerivedAlias: true
+              isDerivedAlias: true,
+              // issue #152 — a membership seen through a re-export,
+              // not one this namespace owns.
+              derivedKind: "reexport"
             };
             const key = exportAliasKey(description);
             if (seen.has(key))
@@ -66752,7 +67841,7 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
   // linker can resolve the qualified spelling without a full type evaluator.
   addInheritedQualifiedAliases(root3, exports2) {
     const seen = new Set(exports2.map(exportAliasKey));
-    const nodes = Array.from(ast_utils_exports.streamAllContents(root3)).filter((node) => specializationTargets4(node).length > 0);
+    const nodes = Array.from(ast_utils_exports.streamAllContents(root3)).filter((node) => specializationTargets5(node).length > 0);
     if (nodes.length === 0)
       return;
     const ownerAliases = aliasesByNode(exports2);
@@ -66760,7 +67849,7 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
       const sourceDescriptions = new GlobalDescriptionIndex(exports2);
       const additions = [];
       for (const node of nodes) {
-        const targets = specializationTargets4(node);
+        const targets = specializationTargets5(node);
         const aliases = ownerAliases.get(node) ?? [];
         if (aliases.length === 0)
           continue;
@@ -66773,7 +67862,9 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
               const description = {
                 ...inherited,
                 name: `${ownerAlias}::${suffix}`,
-                isDerivedAlias: true
+                isDerivedAlias: true,
+                // issue #152 — an implicit inherited membership.
+                derivedKind: "inherited"
               };
               const key = exportAliasKey(description);
               if (seen.has(key))
@@ -66857,7 +67948,7 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
       ...base,
       ...visibility ? { visibility } : {},
       ...visibility === "private" ? { isPrivate: true } : {},
-      ...alias.derived ? { isDerivedAlias: true } : {},
+      ...alias.derived ? { isDerivedAlias: true, derivedKind: "relative" } : {},
       // REQ-242 — issue #103 — mirrors what the precomputed library index
       // records, so consumers read def-ness the same way for workspace and
       // library symbols.
@@ -66906,39 +67997,26 @@ function directImportEntries(imp, descriptions) {
   const path10 = importedPath(imp);
   if (!path10)
     return [];
-  const wildcard = importWildcard(imp);
-  if (wildcard === "none") {
+  const form = importForm(imp);
+  const options = {
+    resolveReferences: false,
+    resolveName: (name) => descriptions.firstNamed(name)?.node
+  };
+  if (form.wildcard === "none") {
     const description = descriptions.firstNamed(path10);
     if (!description)
       return [];
-    return [{ name: imp.alias ?? path10.split("::").pop() ?? path10, description }];
-  }
-  const entries = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const description of descriptions.membersOf(path10, wildcard)) {
-    const visibility = description;
-    if (visibility.isPrivate || visibility.visibility === "private")
-      continue;
-    const rest = description.name.slice(path10.length + 2);
-    if (!rest)
-      continue;
-    const name = rest.split("::").pop();
-    if (!name)
-      continue;
-    const key = `${name}|${description.documentUri.toString()}|${description.path}`;
-    if (seen.has(key))
-      continue;
-    seen.add(key);
-    entries.push({ name, description });
+    const name = imp.alias ?? path10.split("::").pop() ?? path10;
+    return applyFilters(imp, [{ name, targetName: description.name, description }], options);
   }
-  return entries;
+  return applyFilters(imp, selectMemberships(path10, form, descriptions), options);
 }
-var SPECIALIZATION_KINDS6 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
-function specializationTargets4(node) {
+var SPECIALIZATION_KINDS7 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+function specializationTargets5(node) {
   const value = node;
   const targets = [];
   for (const relationship of [...value.preRelationships ?? [], ...value.relationships ?? []]) {
-    if (relationship.kind && SPECIALIZATION_KINDS6.has(relationship.kind)) {
+    if (relationship.kind && SPECIALIZATION_KINDS7.has(relationship.kind)) {
       targets.push(...relationship.targets ?? []);
     }
   }
@@ -67251,6 +68329,15 @@ var SysmlCodeActionProvider = class {
           });
         }
       }
+      if (code === "RES021") {
+        actions.push({
+          title: "Make this root import 'private'",
+          kind: import_vscode_languageserver18.CodeActionKind.QuickFix,
+          isPreferred: true,
+          diagnostics: [diagnostic],
+          edit: { changes: { [uri]: [import_vscode_languageserver18.TextEdit.replace(diagnostic.range, "private")] } }
+        });
+      }
       if (code === "RES015" && isImportFixData(diagnostic.data)) {
         const importPath = diagnostic.data.importPath;
         const pkg = nearestAncestor2(node, isPackage);
@@ -68781,341 +69868,6 @@ function effectiveNameHint(node) {
   };
 }
 
-// ../language-server/out/src/services/requirement-eval.js
-var UNRESOLVED = { kind: "unresolved" };
-var INCONCLUSIVE = { kind: "inconclusive" };
-var REDEFINE_KINDS = /* @__PURE__ */ new Set([":>>", ":>", "redefines", "subsets"]);
-function declaresFeature(node, name) {
-  if (node.name === name)
-    return true;
-  for (const rel of [...node.preRelationships ?? [], ...node.relationships ?? []]) {
-    if (rel.kind && REDEFINE_KINDS.has(rel.kind) && (rel.targets ?? []).includes(name))
-      return true;
-  }
-  return false;
-}
-function evaluateExpr(node, scope) {
-  if (!node)
-    return INCONCLUSIVE;
-  const n = node;
-  switch (n.$type) {
-    case "NumericPrimary":
-      return typeof n.numVal === "number" ? { kind: "number", value: n.numVal } : INCONCLUSIVE;
-    case "LiteralBool":
-      return { kind: "boolean", value: n.value === "true" };
-    case "LiteralStr":
-      return { kind: "string", value: decodeStringLiteral(String(n.value ?? "")) };
-    case "LiteralNull":
-      return INCONCLUSIVE;
-    case "ParenExpr": {
-      const items = n.items ?? [];
-      return items.length === 1 ? evaluateExpr(items[0], scope) : INCONCLUSIVE;
-    }
-    case "UnaryMinusExpr": {
-      const v = evaluateExpr(n.operand, scope);
-      return v.kind === "number" ? { kind: "number", value: -v.value } : passThrough(v);
-    }
-    case "UnaryPlusExpr":
-      return evaluateExpr(n.operand, scope);
-    case "NotExpr": {
-      if (!n.operand)
-        return INCONCLUSIVE;
-      const v = evaluateExpr(n.operand, scope);
-      return v.kind === "boolean" ? { kind: "boolean", value: !v.value } : passThrough(v);
-    }
-    case "PathExpr":
-      return scope(String(n.path).split("."));
-    case "IfExpr": {
-      const cond = evaluateExpr(n.cond, scope);
-      if (cond.kind !== "boolean")
-        return passThrough(cond);
-      return cond.value ? evaluateExpr(n.thenExpr, scope) : evaluateExpr(n.elseExpr, scope);
-    }
-    case "PostfixOp": {
-      if (n.unit && n.unitValue)
-        return evaluateExpr(n.unitValue, scope);
-      if (n.operand)
-        return evaluateExpr(n.operand, scope);
-      return INCONCLUSIVE;
-    }
-    case "BinExpr":
-      return evaluateBin2(n, scope);
-    default:
-      return INCONCLUSIVE;
-  }
-}
-function passThrough(v) {
-  return v.kind === "unresolved" ? UNRESOLVED : INCONCLUSIVE;
-}
-function decodeStringLiteral(raw) {
-  let body = raw;
-  if (body.length >= 2 && body.startsWith('"') && body.endsWith('"')) {
-    body = body.slice(1, -1);
-  }
-  return body.replace(/\\(.)/gu, (_m, ch) => {
-    switch (ch) {
-      case "n":
-        return "\n";
-      case "t":
-        return "	";
-      case "b":
-        return "\b";
-      case "f":
-        return "\f";
-      default:
-        return ch;
-    }
-  });
-}
-function evaluateBin2(node, scope) {
-  const op = String(node.op);
-  const left = evaluateExpr(node.left, scope);
-  if (op === "and" || op === "&") {
-    if (left.kind === "boolean" && !left.value)
-      return { kind: "boolean", value: false };
-  } else if (op === "or" || op === "|") {
-    if (left.kind === "boolean" && left.value)
-      return { kind: "boolean", value: true };
-  } else if (op === "implies") {
-    if (left.kind === "boolean" && !left.value)
-      return { kind: "boolean", value: true };
-  }
-  const right = evaluateExpr(node.right, scope);
-  if (left.kind === "unresolved" || right.kind === "unresolved")
-    return UNRESOLVED;
-  if (left.kind === "inconclusive" || right.kind === "inconclusive")
-    return INCONCLUSIVE;
-  switch (op) {
-    case "+":
-    case "-":
-    case "*":
-    case "/":
-    case "%":
-    case "**":
-    case "^":
-      if (left.kind === "number" && right.kind === "number") {
-        return { kind: "number", value: arith(op, left.value, right.value) };
-      }
-      return INCONCLUSIVE;
-    case "<":
-    case ">":
-    case "<=":
-    case ">=":
-      if (left.kind === "number" && right.kind === "number") {
-        return { kind: "boolean", value: compare(op, left.value, right.value) };
-      }
-      return INCONCLUSIVE;
-    case "==":
-    case "!=":
-    case "===":
-    case "!==": {
-      const eq3 = valuesEqual(left, right);
-      if (eq3 === void 0)
-        return INCONCLUSIVE;
-      return { kind: "boolean", value: op.startsWith("!") ? !eq3 : eq3 };
-    }
-    case "and":
-    case "&":
-      return bothBool(left, right, (a2, b) => a2 && b);
-    case "or":
-    case "|":
-      return bothBool(left, right, (a2, b) => a2 || b);
-    case "xor":
-      return bothBool(left, right, (a2, b) => a2 !== b);
-    case "implies":
-      return bothBool(left, right, (a2, b) => !a2 || b);
-    default:
-      return INCONCLUSIVE;
-  }
-}
-function arith(op, a2, b) {
-  switch (op) {
-    case "+":
-      return a2 + b;
-    case "-":
-      return a2 - b;
-    case "*":
-      return a2 * b;
-    case "/":
-      return a2 / b;
-    case "%":
-      return a2 % b;
-    case "**":
-    case "^":
-      return a2 ** b;
-    default:
-      return NaN;
-  }
-}
-function compare(op, a2, b) {
-  switch (op) {
-    case "<":
-      return a2 < b;
-    case ">":
-      return a2 > b;
-    case "<=":
-      return a2 <= b;
-    case ">=":
-      return a2 >= b;
-    default:
-      return false;
-  }
-}
-function valuesEqual(a2, b) {
-  if (a2.kind === "number" && b.kind === "number")
-    return a2.value === b.value;
-  if (a2.kind === "boolean" && b.kind === "boolean")
-    return a2.value === b.value;
-  if (a2.kind === "string" && b.kind === "string")
-    return a2.value === b.value;
-  return void 0;
-}
-function bothBool(a2, b, f) {
-  if (a2.kind === "boolean" && b.kind === "boolean")
-    return { kind: "boolean", value: f(a2.value, b.value) };
-  return INCONCLUSIVE;
-}
-function memberNamed(node, name, seen = /* @__PURE__ */ new Set()) {
-  if (!node || seen.has(node))
-    return void 0;
-  seen.add(node);
-  for (const member of node.members ?? []) {
-    if (member.value !== void 0 && declaresFeature(member, name))
-      return member;
-  }
-  for (const member of node.members ?? []) {
-    if (declaresFeature(member, name))
-      return member;
-  }
-  const typeRef = node.typing?.type?.ref;
-  return typeRef ? memberNamed(typeRef, name, seen) : void 0;
-}
-function resolveFeatureValue(root3, segments) {
-  let cur = root3;
-  for (const seg of segments) {
-    cur = memberNamed(cur, seg);
-    if (!cur)
-      return UNRESOLVED;
-  }
-  if (cur.value)
-    return evaluateExpr(cur.value, () => INCONCLUSIVE);
-  return INCONCLUSIVE;
-}
-function subjectScope(subjectName, subjectBinding) {
-  const binding = subjectBinding;
-  return (segments) => {
-    if (!binding)
-      return INCONCLUSIVE;
-    if (subjectName && segments[0] === subjectName) {
-      const rest = segments.slice(1);
-      if (rest.length === 0)
-        return INCONCLUSIVE;
-      return resolveFeatureValue(binding, rest);
-    }
-    return resolveFeatureValue(binding, segments);
-  };
-}
-function subjectNameOf(req) {
-  const subject = (req.members ?? []).find((m) => m.$type === "SubjectDecl");
-  return subject?.name;
-}
-function gatherConstraints(req) {
-  const out = [];
-  for (const member of req.members ?? []) {
-    if (member.$type === "RequireConstraintStmt" && member.body) {
-      out.push({ kind: "require", body: member.body, text: exprText2(member.body) });
-    } else if (member.$type === "AssumeConstraintStmt" && member.body) {
-      out.push({ kind: "assume", body: member.body, text: exprText2(member.body) });
-    }
-  }
-  return out;
-}
-function exprText2(node) {
-  return node.$cstNode?.text?.trim() ?? "";
-}
-function evaluateRequirement(req, subjectBinding) {
-  const requirement = req;
-  const subjectName = subjectNameOf(requirement);
-  const scope = subjectScope(subjectName, subjectBinding);
-  const constraints = gatherConstraints(requirement);
-  const details = [];
-  let sawInconclusive = false;
-  let sawUnresolved = false;
-  let failed = false;
-  for (const c of constraints) {
-    const v = evaluateExpr(c.body, scope);
-    let status2;
-    if (v.kind === "unresolved") {
-      status2 = "unresolved";
-      sawUnresolved = true;
-    } else if (v.kind !== "boolean") {
-      status2 = "inconclusive";
-      sawInconclusive = true;
-    } else if (v.value) {
-      status2 = "pass";
-    } else if (c.kind === "require") {
-      status2 = "fail";
-      failed = true;
-    } else {
-      status2 = "inconclusive";
-      sawInconclusive = true;
-    }
-    details.push({ kind: c.kind, status: status2, text: c.text });
-  }
-  let status;
-  if (constraints.length === 0)
-    status = "inconclusive";
-  else if (failed)
-    status = "fail";
-  else if (sawUnresolved)
-    status = "unresolved";
-  else if (sawInconclusive)
-    status = "inconclusive";
-  else
-    status = "pass";
-  return { status, details };
-}
-function bindingName(by) {
-  const n = by;
-  if (n?.$type !== "PathExpr")
-    return void 0;
-  return n.path?.split(/::|\./).pop();
-}
-function evaluateVerificationCase(caseNode, resolveRequirement, resolvePart) {
-  const node = caseNode;
-  const subject = (node.members ?? []).find((m) => m.$type === "SubjectDecl");
-  const subjectBoundName = bindingName(subject?.value);
-  const subjectBinding = (subjectBoundName ? resolvePart(subjectBoundName) : void 0) ?? subject;
-  const verifies = [];
-  for (const member of node.members ?? []) {
-    if (member.$type !== "VerifyStmt")
-      continue;
-    const targetName = String(member.target ?? "").split(/::|\./).pop();
-    if (!targetName)
-      continue;
-    const req = resolveRequirement(targetName);
-    if (!req) {
-      verifies.push({ requirement: targetName, status: "unresolved" });
-      continue;
-    }
-    const boundName = bindingName(member.by);
-    const binding = (boundName ? resolvePart(boundName) : void 0) ?? subjectBinding;
-    verifies.push({ requirement: targetName, status: evaluateRequirement(req, binding).status });
-  }
-  let status = "inconclusive";
-  if (verifies.length === 0)
-    status = "inconclusive";
-  else if (verifies.some((v) => v.status === "fail"))
-    status = "fail";
-  else if (verifies.some((v) => v.status === "unresolved"))
-    status = "error";
-  else if (verifies.some((v) => v.status === "inconclusive"))
-    status = "inconclusive";
-  else
-    status = "pass";
-  return { status, verifies };
-}
-
 // ../language-server/out/src/services/codelens-provider.js
 function walkAst(node, fn) {
   fn(node);
@@ -71093,7 +71845,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.16.0" : "dev";
+var VERSION2 = true ? "0.18.0" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {