sysml-validate 0.17.0 → 0.19.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);
@@ -58670,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
@@ -58923,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;
@@ -58978,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 };
@@ -59079,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 } : {}
     };
@@ -59154,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)
@@ -59467,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)));
@@ -59493,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) {
@@ -59877,7 +60526,7 @@ function evaluateRepresentation(parser, rep) {
 }
 
 // ../language-server/out/src/services/conformance.js
-var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([
+var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([
   ":>",
   ":>>",
   "specializes",
@@ -59909,7 +60558,7 @@ function specializedNamesOf(node) {
   const decl = node;
   const out = [];
   for (const rel of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
-    if (!rel.kind || !SPECIALIZATION_KINDS2.has(rel.kind))
+    if (!rel.kind || !SPECIALIZATION_KINDS3.has(rel.kind))
       continue;
     for (const target of rel.targets ?? []) {
       const text = target.trim();
@@ -60224,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",
@@ -60556,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 ?? ""}`;
@@ -61575,6 +62227,7 @@ ${baseIndent}}`;
     const index = this.buildIndex();
     const imports = [];
     const exposePaths = [];
+    const filterMembers = [];
     const decls = [];
     const verifyStmts = [];
     const satisfyStmts = [];
@@ -61588,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))
@@ -61604,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);
     }
@@ -62032,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`
@@ -62321,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.
@@ -62448,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;
@@ -62470,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;
@@ -62497,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))
@@ -62580,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" });
@@ -62592,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) {
@@ -62612,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;
@@ -62999,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;
@@ -63357,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,
@@ -63378,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;
@@ -63438,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;
@@ -63941,7 +64628,7 @@ function outlineGroupForType(astType) {
 }
 
 // ../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",
@@ -64006,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;
@@ -64129,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;
@@ -64734,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) {
@@ -64745,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) {
@@ -64759,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))
@@ -66897,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)) {
@@ -66957,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;
@@ -66979,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);
     }
   }
@@ -66998,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) {
@@ -67023,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)
@@ -67030,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;
@@ -67114,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))
@@ -67135,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);
@@ -67143,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;
@@ -67156,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))
@@ -67240,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.
@@ -67289,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 ?? []);
     }
   }
@@ -67634,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);
@@ -69164,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);
@@ -71476,7 +71845,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.17.0" : "dev";
+var VERSION2 = true ? "0.19.0" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {