sysml-diagram 0.35.0 → 0.36.0

package/out/main.js

@@ -115652,10 +115652,10 @@ function untilTokenToRegex(until) {
     lookahead: until.lookahead
   });
 }
-function negateTokenToRegex(negate2) {
-  return withCardinality(`(?!${abstractElementToRegex(negate2.terminal)})${WILDCARD}*?`, {
-    cardinality: negate2.cardinality,
-    lookahead: negate2.lookahead
+function negateTokenToRegex(negate3) {
+  return withCardinality(`(?!${abstractElementToRegex(negate3.terminal)})${WILDCARD}*?`, {
+    cardinality: negate3.cardinality,
+    lookahead: negate3.lookahead
   });
 }
 function characterRangeToRegex(range) {
@@ -161054,6 +161054,422 @@ var ANCHOR_KEYWORD = {
   bv: "package"
 };
 
+// ../language-server/out/src/services/requirement-semantics.js
+var DEFAULT_SUBJECT_TYPE = "Anything";
+var MAX_INHERITANCE_DEPTH = 16;
+var SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([
+  ":>",
+  ":>>",
+  "specializes",
+  "subsets",
+  "redefines"
+]);
+var REDEFINITION_KINDS = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var REQUIREMENT_SHAPED = /* @__PURE__ */ new Set([
+  "RequirementDecl",
+  "ConcernDecl",
+  "ObjectiveDecl",
+  "ViewpointDecl"
+]);
+var CONSTRAINT_SHAPED = /* @__PURE__ */ new Set([
+  "ConstraintDecl",
+  "InvShorthand",
+  "PredicateDecl",
+  "RequirementDecl",
+  "ConcernDecl",
+  "ObjectiveDecl"
+]);
+function simpleName(path10) {
+  const last2 = path10.trim().split(/::|\./u).pop() ?? path10.trim();
+  return last2.replace(/^'(.*)'$/u, "$1");
+}
+function* walkAll(node) {
+  for (const child of [...node.elements ?? [], ...node.members ?? []]) {
+    yield child;
+    yield* walkAll(child);
+  }
+}
+function rootOf(node) {
+  let current2 = node;
+  while (current2.$container)
+    current2 = current2.$container;
+  return current2;
+}
+function pathSegments(path10) {
+  return path10.trim().split(/::|\./u).map((segment) => segment.trim().replace(/^'(.*)'$/u, "$1")).filter((segment) => segment.length > 0);
+}
+function qualifierChain(node) {
+  const out = [];
+  let current2 = node;
+  while (current2) {
+    if (current2.name)
+      out.push(current2.name);
+    current2 = current2.$container;
+  }
+  return out;
+}
+function documentResolver(from) {
+  const root4 = rootOf(from);
+  return (name) => {
+    const segments = pathSegments(name);
+    if (segments.length === 0)
+      return void 0;
+    const wanted = segments[segments.length - 1];
+    const qualifiers = segments.slice(0, -1).reverse();
+    let fallback;
+    for (const candidate of walkAll(root4)) {
+      if (candidate.name !== wanted)
+        continue;
+      if (qualifiers.length === 0)
+        return candidate;
+      const chain = qualifierChain(candidate).slice(1);
+      let index2 = 0;
+      for (const link of chain) {
+        if (link === qualifiers[index2])
+          index2++;
+        if (index2 === qualifiers.length)
+          break;
+      }
+      if (index2 === qualifiers.length)
+        return candidate;
+      fallback ??= candidate;
+    }
+    return fallback;
+  };
+}
+function supertypesOf(node, resolve8) {
+  const out = [];
+  const add = (candidate) => {
+    if (candidate)
+      out.push(candidate);
+  };
+  for (const typing of [node.typing, ...node.moreTypings ?? []]) {
+    if (!typing)
+      continue;
+    for (const ref of [typing.type, ...typing.moreTypes ?? []]) {
+      if (!ref)
+        continue;
+      add(ref.ref ?? (ref.$refText ? resolve8(ref.$refText) : void 0));
+    }
+  }
+  for (const rel2 of [...node.preRelationships ?? [], ...node.relationships ?? []]) {
+    if (!rel2.kind || !SPECIALIZATION_KINDS.has(rel2.kind))
+      continue;
+    for (const target of rel2.targets ?? [])
+      add(resolve8(target));
+  }
+  return out;
+}
+function locallyRedefinedNames(node) {
+  const out = /* @__PURE__ */ new Set();
+  for (const member of node.members ?? []) {
+    for (const rel2 of [...member.preRelationships ?? [], ...member.relationships ?? []]) {
+      if (!rel2.kind || !REDEFINITION_KINDS.has(rel2.kind))
+        continue;
+      for (const target of rel2.targets ?? [])
+        out.add(simpleName(target));
+    }
+  }
+  return out;
+}
+function referencePathOf(member) {
+  const target = member.target;
+  if (typeof target === "string")
+    return target.trim() || void 0;
+  if (target && typeof target === "object") {
+    const text = target.$refText?.trim();
+    return text || void 0;
+  }
+  return void 0;
+}
+function referenceTargetOf(member, resolve8) {
+  const target = member.target;
+  if (target && typeof target === "object" && target.ref)
+    return target.ref;
+  const path10 = referencePathOf(member);
+  return path10 ? resolve8(path10) : void 0;
+}
+function constraintBodyOf(node, resolve8, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (!node || depth > MAX_INHERITANCE_DEPTH || seen.has(node))
+    return void 0;
+  seen.add(node);
+  if (node.body)
+    return node.body;
+  const resolver = resolve8 ?? documentResolver(node);
+  for (const supertype of supertypesOf(node, resolver)) {
+    const inherited = constraintBodyOf(supertype, resolver, depth + 1, seen);
+    if (inherited)
+      return inherited;
+  }
+  return void 0;
+}
+function exprText(node) {
+  return node?.$cstNode?.text?.trim() ?? "";
+}
+function labelOf(owner, kind, text) {
+  const prefix = owner?.name ? `${owner.name} / ` : "";
+  return `${prefix}${kind}: ${text}`;
+}
+function collect(node, origin, depth, walk) {
+  if (depth > MAX_INHERITANCE_DEPTH || walk.seen.has(node))
+    return;
+  walk.seen.add(node);
+  const redefined = locallyRedefinedNames(node);
+  for (const member of node.members ?? []) {
+    const kind = constraintKindOf(member);
+    if (kind) {
+      addConstraint(member, kind, origin, node, walk);
+      continue;
+    }
+    if (member.$type === "InvShorthand" && member.body) {
+      addBody(member, member.body, "require", origin, node, walk);
+    }
+  }
+  for (const supertype of supertypesOf(node, walk.resolve)) {
+    if (!REQUIREMENT_SHAPED.has(supertype.$type) && supertype.$type !== "ConstraintDecl")
+      continue;
+    const before = walk.out.length;
+    collect(supertype, origin === "own" ? "inherited" : origin, depth + 1, walk);
+    if (redefined.size === 0)
+      continue;
+    for (let i = walk.out.length - 1; i >= before; i--) {
+      const host = walk.out[i].host;
+      if (host.name && redefined.has(host.name))
+        walk.out.splice(i, 1);
+    }
+  }
+  for (const member of node.members ?? []) {
+    if (member.$type === "RequirementDecl") {
+      collect(member, origin === "own" ? "subrequirement" : origin, depth + 1, walk);
+    } else if (member.$type === "FrameMember") {
+      const concern = member.concernKw === true ? member : referenceTargetOf(member, walk.resolve);
+      if (concern && (REQUIREMENT_SHAPED.has(concern.$type) || concern.$type === "FrameMember")) {
+        collect(concern, origin === "own" ? "concern" : origin, depth + 1, walk);
+      }
+    }
+  }
+}
+function constraintKindOf(member) {
+  if (member.$type === "AssumeConstraintStmt")
+    return "assume";
+  if (member.$type === "RequireConstraintStmt" || member.$type === "AssertConstraintStmt")
+    return "require";
+  return void 0;
+}
+function addConstraint(member, kind, origin, owner, walk) {
+  const negated = member.isNegated === true;
+  if (member.body) {
+    addBody(member, member.body, kind, origin, owner, walk, negated);
+    return;
+  }
+  const path10 = referencePathOf(member);
+  if (!path10)
+    return;
+  const target = referenceTargetOf(member, walk.resolve);
+  const text = `${kind} ${negated ? "not " : ""}${path10}`;
+  if (!target || !CONSTRAINT_SHAPED.has(target.$type)) {
+    walk.out.push({
+      kind,
+      origin,
+      host: member,
+      text,
+      negated,
+      unresolved: true,
+      label: labelOf(owner, kind, text)
+    });
+    return;
+  }
+  const body = constraintBodyOf(target, walk.resolve);
+  if (!body) {
+    if (REQUIREMENT_SHAPED.has(target.$type)) {
+      collect(target, origin === "own" ? "subrequirement" : origin, 1, walk);
+      return;
+    }
+    walk.out.push({
+      kind,
+      origin,
+      host: member,
+      owner: target,
+      text,
+      negated,
+      unresolved: false,
+      label: labelOf(target, kind, text)
+    });
+    return;
+  }
+  if (walk.bodies.has(body))
+    return;
+  walk.bodies.add(body);
+  walk.out.push({
+    kind,
+    origin,
+    host: member,
+    owner: target,
+    body,
+    negated,
+    unresolved: false,
+    text,
+    label: labelOf(target, kind, exprText(body))
+  });
+}
+function addBody(host, body, kind, origin, owner, walk, negated = false) {
+  if (walk.bodies.has(body))
+    return;
+  walk.bodies.add(body);
+  const text = exprText(body);
+  walk.out.push({
+    kind,
+    origin,
+    host,
+    owner,
+    body,
+    text,
+    negated,
+    unresolved: false,
+    label: labelOf(owner, kind, text)
+  });
+}
+function effectiveConstraints(req, resolve8) {
+  const walk = {
+    resolve: resolve8 ?? documentResolver(req),
+    out: [],
+    seen: /* @__PURE__ */ new Set(),
+    bodies: /* @__PURE__ */ new Set()
+  };
+  collect(req, "own", 0, walk);
+  return walk.out;
+}
+function ownSubject(node) {
+  return (node.members ?? []).find((member) => member.$type === "SubjectDecl");
+}
+function subjectTypeName(subject) {
+  const ref = subject?.typing?.type;
+  const text = ref?.$refText?.trim() ?? ref?.ref?.name;
+  return text || void 0;
+}
+function subjectInfo(subject, owner, origin) {
+  return {
+    declaration: subject,
+    name: subject.name,
+    typeName: subjectTypeName(subject) ?? DEFAULT_SUBJECT_TYPE,
+    origin,
+    owner
+  };
+}
+function inheritedSubject(node, resolve8, depth, seen) {
+  if (depth > MAX_INHERITANCE_DEPTH || seen.has(node))
+    return void 0;
+  seen.add(node);
+  for (const supertype of supertypesOf(node, resolve8)) {
+    if (!REQUIREMENT_SHAPED.has(supertype.$type))
+      continue;
+    const own = ownSubject(supertype);
+    if (own)
+      return subjectInfo(own, supertype, "inherited");
+    const deeper = inheritedSubject(supertype, resolve8, depth + 1, seen);
+    if (deeper)
+      return deeper;
+  }
+  return void 0;
+}
+function effectiveSubject(req, resolve8) {
+  const node = req;
+  const resolver = resolve8 ?? documentResolver(req);
+  const own = ownSubject(node);
+  if (own)
+    return subjectInfo(own, node, "own");
+  const inherited = inheritedSubject(node, resolver, 0, /* @__PURE__ */ new Set());
+  if (inherited)
+    return inherited;
+  let container = node.$container;
+  while (container) {
+    if (REQUIREMENT_SHAPED.has(container.$type)) {
+      const enclosing = ownSubject(container);
+      if (enclosing)
+        return subjectInfo(enclosing, container, "enclosing");
+      const above = inheritedSubject(container, resolver, 0, /* @__PURE__ */ new Set());
+      if (above)
+        return { ...above, origin: "enclosing" };
+    }
+    container = container.$container;
+  }
+  return { typeName: DEFAULT_SUBJECT_TYPE, origin: "default" };
+}
+function effectiveRequirement(req, resolve8) {
+  const resolver = resolve8 ?? documentResolver(req);
+  return {
+    constraints: effectiveConstraints(req, resolver),
+    subject: effectiveSubject(req, resolver)
+  };
+}
+var SATISFIER_SHAPED = /* @__PURE__ */ new Set([
+  "PartDecl",
+  "ItemDecl",
+  "OccurrenceDecl",
+  "ActionDecl",
+  "StateDecl",
+  "PortDecl",
+  "AttributeDecl",
+  "EnumDecl",
+  "ConnectionDecl",
+  "InterfaceDecl",
+  "AllocationDecl",
+  "UseCaseDecl",
+  "CaseDecl",
+  "AnalysisCaseDecl",
+  "VerificationCaseDecl",
+  "ViewDecl",
+  "CalcDecl",
+  "ConstraintDecl",
+  "RequirementDecl",
+  "ConcernDecl",
+  "ObjectiveDecl",
+  "ViewpointDecl",
+  "RenderingDecl",
+  "EventDecl"
+]);
+function bindingSimpleName(by) {
+  const node = by;
+  if (!node)
+    return void 0;
+  if (node.$type === "ParenExpr") {
+    const items = node.items ?? [];
+    return items.length === 1 ? bindingSimpleName(items[0]) : void 0;
+  }
+  if (node.$type !== "PathExpr")
+    return void 0;
+  const last2 = node.path?.split(/::|\./u).pop();
+  return last2 || void 0;
+}
+function satisfyIntentOf(stmt) {
+  const node = stmt;
+  if (node.$type !== "SatisfyStmt")
+    return void 0;
+  const path10 = referencePathOf(node);
+  if (!path10)
+    return void 0;
+  const byName = bindingSimpleName(node.by);
+  let enclosing;
+  let container = node.$container;
+  while (container && !enclosing) {
+    if (SATISFIER_SHAPED.has(container.$type) && container.isDef !== true)
+      enclosing = container;
+    container = container.$container;
+  }
+  return {
+    path: path10,
+    simple: simpleName(path10),
+    negated: node.isNegated === true,
+    byName,
+    // The presence of a `by`, not whether its expression could be named,
+    // decides this. A `by` this reader cannot name is still a stated
+    // satisfier, and reading it as the enclosing usage would evaluate and
+    // check something the model never claimed.
+    enclosingSelf: node.by === void 0,
+    enclosing
+  };
+}
+
 // ../language-server/out/src/services/requirement-eval.js
 var UNRESOLVED = { kind: "unresolved" };
 var INCONCLUSIVE = { kind: "inconclusive" };
@@ -161294,36 +161710,40 @@ function subjectScope(subjectName, subjectBinding) {
     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) });
+function constraintScope(entry, evaluated, outer) {
+  const owners = [entry.host, evaluated, entry.owner];
+  return (segments, expression) => {
+    for (const owner of owners) {
+      if (!owner)
+        continue;
+      const value = resolveFeatureValue(owner, segments);
+      if (value.kind !== "unresolved" && value.kind !== "inconclusive")
+        return value;
     }
-  }
-  return out;
+    return outer(segments, expression);
+  };
 }
-function exprText(node) {
-  return node.$cstNode?.text?.trim() ?? "";
+function negate2(value, negated) {
+  if (!negated || value.kind !== "boolean")
+    return value;
+  return { kind: "boolean", value: !value.value };
 }
-function evaluateRequirement(req, subjectBinding) {
-  const requirement = req;
-  const subjectName = subjectNameOf(requirement);
-  const scope = subjectScope(subjectName, subjectBinding);
-  const constraints = gatherConstraints(requirement);
+function evaluateRequirement(req, subjectBinding, resolve8) {
+  const effective = effectiveRequirement(req, resolve8);
+  const scope = subjectScope(effective.subject.name, subjectBinding);
   const details = [];
   let sawInconclusive = false;
   let sawUnresolved = false;
   let failed = false;
-  for (const c of constraints) {
-    const v = evaluateExpr(c.body, scope);
+  for (const c of effective.constraints) {
     let status2;
+    if (c.unresolved) {
+      status2 = "unresolved";
+      sawUnresolved = true;
+      details.push({ kind: c.kind, status: status2, text: c.text, origin: c.origin, label: c.label });
+      continue;
+    }
+    const v = negate2(evaluateExpr(c.body, constraintScope(c, req, scope)), c.negated);
     if (v.kind === "unresolved") {
       status2 = "unresolved";
       sawUnresolved = true;
@@ -161339,10 +161759,10 @@ function evaluateRequirement(req, subjectBinding) {
       status2 = "inconclusive";
       sawInconclusive = true;
     }
-    details.push({ kind: c.kind, status: status2, text: c.text });
+    details.push({ kind: c.kind, status: status2, text: c.text, origin: c.origin, label: c.label });
   }
   let status;
-  if (constraints.length === 0)
+  if (effective.constraints.length === 0)
     status = "inconclusive";
   else if (failed)
     status = "fail";
@@ -161354,6 +161774,20 @@ function evaluateRequirement(req, subjectBinding) {
     status = "pass";
   return { status, details };
 }
+function evaluateSatisfy(stmt, resolveRequirement, resolvePart, resolve8) {
+  const intent = satisfyIntentOf(stmt);
+  if (!intent)
+    return { status: "unresolved" };
+  const requirement = resolveRequirement(intent.simple);
+  if (!requirement)
+    return { status: "unresolved" };
+  const satisfier = intent.enclosingSelf ? intent.enclosing : intent.byName ? resolvePart(intent.byName) : void 0;
+  const result = evaluateRequirement(requirement, satisfier, resolve8);
+  if (!intent.negated)
+    return { status: result.status, requirement, satisfier };
+  const status = result.status === "pass" ? "fail" : result.status === "fail" ? "pass" : result.status;
+  return { status, requirement, satisfier };
+}
 function bindingName(by) {
   const n2 = by;
   if (n2?.$type !== "PathExpr")
@@ -162533,14 +162967,14 @@ function isPublic(node) {
   }
   return true;
 }
-var SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 var inheritanceByNode = /* @__PURE__ */ new WeakMap();
 function inheritanceSyntax(node) {
   const cached = inheritanceByNode.get(node);
   if (cached)
     return cached;
   const shape = node;
-  const relationships = [...shape.preRelationships ?? [], ...shape.relationships ?? []].filter((relation) => relation.kind && SPECIALIZATION_KINDS.has(relation.kind));
+  const relationships = [...shape.preRelationships ?? [], ...shape.relationships ?? []].filter((relation) => relation.kind && SPECIALIZATION_KINDS2.has(relation.kind));
   const implicitVariant = implicitVariantSpecialization(node)?.target;
   const externalVariant = !!externalVariantPath(node);
   const enumUsage = node.$type === "EnumDecl" && shape.isDef !== true;
@@ -163162,7 +163596,7 @@ var FeaturePathResolver = class {
     const declared = [
       ...record.preRelationships ?? [],
       ...record.relationships ?? []
-    ].filter((relation) => relation !== under && relation.kind && SPECIALIZATION_KINDS.has(relation.kind));
+    ].filter((relation) => relation !== under && relation.kind && SPECIALIZATION_KINDS2.has(relation.kind));
     if (declared.length === 0)
       return true;
     const written = declared.reduce((total, relation) => total + (relation.targets?.length ?? 0), 0);
@@ -163557,7 +163991,7 @@ function memberSeparator(owner) {
 function unquoteName(name) {
   return name.replace(/^'(.*)'$/u, "$1");
 }
-function pathSegments(path10) {
+function pathSegments2(path10) {
   const segments = [];
   let current2 = "";
   let quoted = false;
@@ -163585,7 +164019,7 @@ function pathSegments(path10) {
   return segments;
 }
 function simpleNameOf(name) {
-  return pathSegments(name).at(-1) ?? name;
+  return pathSegments2(name).at(-1) ?? name;
 }
 var ELEMENT_SEPARATOR = "\0";
 function elementKey(description) {
@@ -163595,7 +164029,7 @@ function isDeclaredSpelling(description) {
   const kind = description.derivedKind;
   if (kind === "reexport" || kind === "inherited")
     return false;
-  return pathSegments(description.name).length === 1;
+  return pathSegments2(description.name).length === 1;
 }
 var SysmlNameLookup = class {
   shared;
@@ -163705,7 +164139,7 @@ function nameLookupFor(shared) {
 }
 
 // ../language-server/out/src/services/effective-name.js
-var REDEFINITION_KINDS = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var NO_CANDIDATES = [];
 var NO_RESOLVER = () => NO_CANDIDATES;
 var nameable = /* @__PURE__ */ new Map();
@@ -163739,7 +164173,7 @@ function firstRedefinitionPath(node) {
     for (const relationship of group) {
       if (typeof relationship?.kind !== "string")
         continue;
-      if (!REDEFINITION_KINDS.has(relationship.kind))
+      if (!REDEFINITION_KINDS2.has(relationship.kind))
         continue;
       const targets = relationship.targets;
       if (!Array.isArray(targets))
@@ -164784,7 +165218,7 @@ function nearestUnits(symbol, limit) {
 }
 
 // ../language-server/out/src/services/conformance.js
-var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([
+var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([
   ":>",
   ":>>",
   "specializes",
@@ -164816,7 +165250,7 @@ function specializedNamesOf(node) {
   const decl = node;
   const out = [];
   for (const rel2 of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
-    if (!rel2.kind || !SPECIALIZATION_KINDS2.has(rel2.kind))
+    if (!rel2.kind || !SPECIALIZATION_KINDS3.has(rel2.kind))
       continue;
     for (const target of rel2.targets ?? []) {
       const text = target.trim();
@@ -165491,7 +165925,7 @@ function owningOccurrenceOf(node) {
   return NON_OCCURRENCE_DECL_TYPES.has(owner.$type) ? void 0 : owner;
 }
 var MAX_ALIAS_HOPS = 8;
-var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([
+var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([
   ":>",
   "subsets",
   ":>>",
@@ -165503,7 +165937,7 @@ function specializationTargetsOf(node) {
   const decl = node;
   const out = [];
   for (const rel2 of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
-    if (!rel2.kind || !SPECIALIZATION_KINDS3.has(rel2.kind))
+    if (!rel2.kind || !SPECIALIZATION_KINDS4.has(rel2.kind))
       continue;
     for (const target of rel2.targets ?? []) {
       const text = target.trim();
@@ -168729,16 +169163,16 @@ ${node.id}`;
       };
       const performedActions = depth < 8 && !(typeQ !== void 0 && seenTypes.has(typeQ)) ? effectiveMembersOf(part).filter((m) => m.$type === "PerformStmt" && !!nameOf2(m)).map((act) => {
         const pinSource = this.performTargetOf(act, index2) ?? act;
-        const pathSegments3 = this.isAnonymousBehaviorReference(act) ? this.featurePaths.resolveDeclarationPath(act).segments.map((segment) => segment.text) : [nameOf2(act)];
+        const pathSegments4 = this.isAnonymousBehaviorReference(act) ? this.featurePaths.resolveDeclarationPath(act).segments.map((segment) => segment.text) : [nameOf2(act)];
         return {
           act,
           pinSource,
-          pathSegments: pathSegments3,
-          name: pathSegments3.at(-1) ?? nameOf2(act),
+          pathSegments: pathSegments4,
+          name: pathSegments4.at(-1) ?? nameOf2(act),
           key: concretePerformPath(act, pinSource)
         };
       }).filter((entry, i, list) => list.findIndex((other) => other.key === entry.key) === i) : [];
-      const performedActionInfos = performedActions.map(({ act, pinSource, pathSegments: pathSegments3, name, key: key2 }) => {
+      const performedActionInfos = performedActions.map(({ act, pinSource, pathSegments: pathSegments4, name, key: key2 }) => {
         const id2 = `${instanceId}::__perform_${key2}`;
         const inheritedFromDefinition = !!localUsage && !isAstDescendantOrSelf(act, localUsage);
         const syncDeclaration2 = this.synchronizationDeclarationOf(act, index2);
@@ -168746,7 +169180,7 @@ ${node.id}`;
           act,
           name,
           id: id2,
-          pathSegments: pathSegments3,
+          pathSegments: pathSegments4,
           pins: this.actionPinPorts(pinSource, id2, index2, uri),
           meta: {
             ...ivEditMeta(act, id2, void 0, localUsage, [...localPath, name], uri),
@@ -174869,8 +175303,8 @@ function outlineGroupForType(astType) {
 }
 
 // ../language-server/out/src/services/document-symbol-provider.js
-var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([":>", "specializes"]);
-var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var SPECIALIZATION_KINDS5 = /* @__PURE__ */ new Set([":>", "specializes"]);
+var REDEFINITION_KINDS3 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var INHERITABLE_FEATURE_TYPES = /* @__PURE__ */ new Set([
   "ActionDecl",
   "AttributeDecl",
@@ -174941,7 +175375,7 @@ function specializationTargets2(node) {
   const n2 = node;
   const out = [];
   for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
-    if (rel2.kind && SPECIALIZATION_KINDS4.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS5.has(rel2.kind))
       out.push(...rel2.targets ?? []);
   }
   return out;
@@ -174950,7 +175384,7 @@ function redefinitionTargets(node) {
   const n2 = node;
   const out = [];
   for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
-    if (rel2.kind && REDEFINITION_KINDS2.has(rel2.kind))
+    if (rel2.kind && REDEFINITION_KINDS3.has(rel2.kind))
       out.push(...rel2.targets ?? []);
   }
   return out;
@@ -175305,21 +175739,21 @@ var import_vscode_languageserver13 = __toESM(require_main4(), 1);
 function isRequirementNode(node) {
   return node?.$type === "RequirementDecl";
 }
-function ownSubject(node) {
+function ownSubject2(node) {
   return (node.members ?? []).find((member) => member.$type === "SubjectDecl");
 }
 function resolveEffectiveSubject(node) {
   if (!isRequirementNode(node))
     return void 0;
-  const own = ownSubject(node);
+  const own = ownSubject2(node);
   if (own)
     return { subject: own, owner: node, inherited: false };
   let container = node.$container;
   while (container) {
     if (isRequirementNode(container)) {
-      const inheritedSubject = ownSubject(container);
-      if (inheritedSubject) {
-        return { subject: inheritedSubject, owner: container, inherited: true };
+      const inheritedSubject2 = ownSubject2(container);
+      if (inheritedSubject2) {
+        return { subject: inheritedSubject2, owner: container, inherited: true };
       }
     }
     container = container.$container;
@@ -176096,6 +176530,11 @@ var DIAGNOSTIC_MESSAGES = {
   SSM040_INDIVIDUAL_NOT_OCCURRENCE: (name, kind) => `'individual' names one occurrence with an identity of its own, and ${name} is ${kind}, which has no life to identify. Remove 'individual', or move it to the occurrence this belongs to.`,
   SSM041_INDIVIDUAL_MULTIPLE_DEFINITIONS: (name, first2, second) => `${name} is typed by two individual definitions, '${first2}' and '${second}'. An individual usage names ONE life, so at most one of its types may be an 'individual def'.`,
   SSM042_INDIVIDUAL_WITHOUT_DEFINITION: (name) => `${name} is declared 'individual' but names no individual definition. An individual usage is typed by exactly one 'individual def' - the definition that carries the identity it names.`,
+  // issue #165 — a satisfaction binds a thing to the subject a requirement
+  // constrains, so the thing has to BE one of those (OMG SysML v2 Part 1
+  // §7.21.2). The message names both types because the fix is either to bind a
+  // different satisfier or to widen the requirement's subject.
+  SSM044_SATISFIER_SUBJECT_TYPE: (satisfier, satisfierType, requirement, subjectType) => `'${satisfier}' is a '${satisfierType}', but '${requirement}' constrains a subject of type '${subjectType}'. A satisfying element must conform to the requirement's subject.`,
   // REQ-392 — a `sysml-format` comment the formatter cannot act on. Advisory:
   // the directive is inert, and saying so beats leaving the author to wonder
   // why their layout was reformatted anyway.
@@ -177248,8 +177687,8 @@ var SysmlHoverProvider = class {
     return buildOperatorHover(token, details);
   }
   async resolveLibraryFunction(qualifiedName) {
-    const simpleName2 = relationshipTargetKey(qualifiedName);
-    const descriptions = this.indexManager.allElements().toArray().filter((d) => (d.type === "FunctionDecl" || d.type === "CalcDecl" || d.type === "PredicateDecl") && (d.name === qualifiedName || d.name === simpleName2)).sort((a2, b) => Number(b.name === qualifiedName) - Number(a2.name === qualifiedName));
+    const simpleName3 = relationshipTargetKey(qualifiedName);
+    const descriptions = this.indexManager.allElements().toArray().filter((d) => (d.type === "FunctionDecl" || d.type === "CalcDecl" || d.type === "PredicateDecl") && (d.name === qualifiedName || d.name === simpleName3)).sort((a2, b) => Number(b.name === qualifiedName) - Number(a2.name === qualifiedName));
     for (const desc of descriptions) {
       const node = await this.nodeFromDescription(desc);
       if (node)
@@ -178058,7 +178497,7 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
   itemForDescription(desc, document2, offset2) {
     const importPath = document2 && offset2 !== void 0 ? this.autoImportPath(desc, document2, offset2) : void 0;
     return {
-      label: simpleName(desc.name) ?? desc.name,
+      label: simpleName2(desc.name) ?? desc.name,
       kind: this.nodeKindProvider.getCompletionItemKind(desc),
       detail: desc.type,
       sortText: "0",
@@ -178084,7 +178523,7 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
     if (desc.name.includes("::"))
       return desc.name;
     const candidates = this.qualifiedNamesByElement().get(elementKey2(desc));
-    return candidates?.find((name) => simpleName(name) === desc.name);
+    return candidates?.find((name) => simpleName2(name) === desc.name);
   }
   // REQ-245, REQ-268 — An element's qualified names, shortest first, keyed by
   // the element. A type-context completion offers thousands of symbols and each
@@ -178474,7 +178913,7 @@ function nearestMemberOwner(node) {
   }
   return void 0;
 }
-function simpleName(name) {
+function simpleName2(name) {
   if (!name)
     return void 0;
   const parts = name.split(/::|\./u);
@@ -178674,7 +179113,7 @@ var import_vscode_languageserver16 = __toESM(require_main4(), 1);
 
 // ../language-server/out/src/services/metadata-filter.js
 var INCONCLUSIVE2 = { kind: "inconclusive" };
-var SPECIALIZATION_KINDS5 = /* @__PURE__ */ new Set([":>", "specializes", ":>>", "redefines", "subsets"]);
+var SPECIALIZATION_KINDS6 = /* @__PURE__ */ new Set([":>", "specializes", ":>>", "redefines", "subsets"]);
 var MAX_SPECIALIZATION_DEPTH = 32;
 var MAX_VALUE_DEPTH = 16;
 function evaluateFilterCondition(condition, element, options) {
@@ -178777,7 +179216,7 @@ function declaresFeature2(node, name) {
   if (node.name === name)
     return true;
   for (const rel2 of [...node.preRelationships ?? [], ...node.relationships ?? []]) {
-    if (rel2.kind && SPECIALIZATION_KINDS5.has(rel2.kind) && (rel2.targets ?? []).includes(name))
+    if (rel2.kind && SPECIALIZATION_KINDS6.has(rel2.kind) && (rel2.targets ?? []).includes(name))
       return true;
   }
   return false;
@@ -178944,7 +179383,7 @@ function nameScope(ctx, depth = 0) {
 function specializationTargets3(node) {
   const targets = [];
   for (const rel2 of [...node.preRelationships ?? [], ...node.relationships ?? []]) {
-    if (rel2.kind && SPECIALIZATION_KINDS5.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS6.has(rel2.kind))
       targets.push(...rel2.targets ?? []);
   }
   return targets;
@@ -179187,10 +179626,10 @@ function resolveImportedDescription(path10, globalDescriptions, options, visited
   if (split < 0)
     return void 0;
   const ownerPath = path10.slice(0, split);
-  const simpleName2 = path10.slice(split + 2);
+  const simpleName3 = path10.slice(split + 2);
   const exported = [];
   expandNamespaceImports(ownerPath, globalDescriptions, exported, options, visitedNamespaces, importAll);
-  return exported.find((entry) => entry.name === simpleName2)?.description;
+  return exported.find((entry) => entry.name === simpleName3)?.description;
 }
 function selectMemberships(path10, form, globalDescriptions) {
   if (form.wildcard === "none")
@@ -179641,7 +180080,7 @@ function compositionProblemsOf(node, resolve8) {
 }
 
 // ../language-server/out/src/services/validator.js
-var REDEFINITION_KINDS3 = /* @__PURE__ */ new Set([
+var REDEFINITION_KINDS4 = /* @__PURE__ */ new Set([
   ":>>",
   "redefines",
   ":>",
@@ -179735,7 +180174,7 @@ function maskNonCode(text) {
   }
   return out.join("");
 }
-var SPECIALIZATION_KINDS6 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS7 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 var CONSTRAINT_SIDE_EFFECT_TYPES = /* @__PURE__ */ new Set([
   "AssignNode",
   "SendNode",
@@ -179923,7 +180362,7 @@ var SysmlValidator = class _SysmlValidator {
   // inventory completely. A later segment depends on the KerML semantic model
   // this resolver does not evaluate.
   checkRelationshipTargets(node, accept) {
-    if (!node.kind || !REDEFINITION_KINDS3.has(node.kind))
+    if (!node.kind || !REDEFINITION_KINDS4.has(node.kind))
       return;
     for (let ordinal = 0; ordinal < node.targets.length; ordinal += 1) {
       const resolution = this.featurePaths.resolvePropertyPath(node, "targets", ordinal);
@@ -181199,7 +181638,7 @@ ${baseIndent}}`;
           accept(severity("SYN019", "error"), DIAGNOSTIC_MESSAGES.SYN019_ABSTRACT_VARIATION, { node: child, code: "SYN019" });
         }
         for (const relation of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
-          if (!relation.kind || !SPECIALIZATION_KINDS6.has(relation.kind))
+          if (!relation.kind || !SPECIALIZATION_KINDS7.has(relation.kind))
             continue;
           for (let index2 = 0; index2 < (relation.targets?.length ?? 0); index2 += 1) {
             const resolution = this.featurePaths.resolvePropertyPath(relation, "targets", index2);
@@ -181615,7 +182054,7 @@ ${baseIndent}}`;
       this.checkInverseOfTargets(decl, index2, accept);
       this.checkTypeComposition(decl, index2, accept);
     }
-    this.checkTypeConformance(decls, index2, accept);
+    this.checkTypeConformance(decls, satisfyStmts, index2, accept);
   }
   // ══════════════════════════════════════════════════════════════════════
   // REQ-390 — SSM017-SSM021: whole-model type conformance (issue #104)
@@ -181625,7 +182064,7 @@ ${baseIndent}}`;
   // the walk, so a type rooted in the unparsed standard library yields
   // `unknown` and no diagnostic. That is what keeps the OMG corpus clean while
   // still catching the workspace-local mistakes these codes exist for.
-  checkTypeConformance(decls, index2, accept) {
+  checkTypeConformance(decls, satisfyStmts, index2, accept) {
     const model = new ConformanceModel((name) => this.resolveUnique(name, index2), (node) => this.implicit?.closureOf(node) ?? { names: /* @__PURE__ */ new Set(), complete: true });
     for (const decl of decls) {
       this.checkRedefinitionTypeConformance(decl, model, index2, accept);
@@ -181641,6 +182080,40 @@ ${baseIndent}}`;
       this.checkInterfaceEndTypes(decl, model, index2, accept);
       this.checkIndividualDefinitions(decl, model, accept);
     }
+    for (const stmt of satisfyStmts)
+      this.checkSatisfierSubjectType(stmt, model, index2, accept);
+  }
+  // REQ-416 — SSM044: `satisfy MassReq by engine;` claims that `engine` is one
+  // of the things `MassReq` constrains, so `engine`'s type has to conform to
+  // the requirement's subject type (OMG SysML v2 Part 1 §7.21.2: the
+  // satisfying feature is bound to the requirement's subject parameter).
+  //
+  // The subject read here is the EFFECTIVE one (issue #165): a requirement
+  // usage inherits the subject its definition declares, and a subrequirement
+  // shares its parent's. A requirement that declares no subject at all
+  // constrains `Anything`, which every satisfier conforms to, so nothing is
+  // reported for one. Like every SSM01x check this stays silent unless the
+  // closure was walked COMPLETELY.
+  checkSatisfierSubjectType(stmt, model, index2, accept) {
+    const intent = satisfyIntentOf(stmt);
+    if (!intent)
+      return;
+    const requirement = this.resolveUnique(intent.path, index2);
+    if (!requirement || requirement.$type !== "RequirementDecl")
+      return;
+    const subject = effectiveSubject(requirement, (name) => this.resolveUnique(name, index2));
+    if (subject.origin === "default" || subject.typeName === DEFAULT_SUBJECT_TYPE)
+      return;
+    const satisfier = intent.enclosingSelf ? intent.enclosing : intent.byName ? this.resolveUnique(intent.byName, index2) : void 0;
+    if (!satisfier)
+      return;
+    const declared = soleDeclaredType(satisfier);
+    if (!declared || declared.conjugated)
+      return;
+    if (model.conforms(declared.text, subject.typeName) !== "unrelated")
+      return;
+    const label = intent.byName ?? satisfier.name ?? "this usage";
+    accept(severity("SSM044", "error"), DIAGNOSTIC_MESSAGES.SSM044_SATISFIER_SUBJECT_TYPE(label, declared.text, intent.path, subject.typeName), { node: stmt, code: "SSM044" });
   }
   // issue #162 — SSM041 / SSM042: the identity an individual usage names.
   //
@@ -183105,7 +183578,7 @@ function specializationTargets4(node) {
     ...node.relationships ?? []
   ];
   for (const rel2 of rels) {
-    if (rel2.kind && SPECIALIZATION_KINDS6.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS7.has(rel2.kind))
       out.push(...rel2.targets);
   }
   return out;
@@ -183222,6 +183695,12 @@ var USAGE_DEFINITION_DOMAINS = {
   AllocationDecl: { keyword: "allocation", expected: "an 'allocation def' (a 'connection def' is one)", allowed: /* @__PURE__ */ new Set(["AllocationDecl", "ConnectionDecl"]) },
   ViewDecl: { keyword: "view", expected: "a 'view def'", allowed: /* @__PURE__ */ new Set(["ViewDecl", "PartDecl"]) },
   ViewpointDecl: { keyword: "viewpoint", expected: "a 'viewpoint def' (a 'requirement def' is one)", allowed: /* @__PURE__ */ new Set(["ViewpointDecl", "RequirementDecl", "ConcernDecl"]) },
+  // issue #165 — OMG SysML v2 Part 1 §7.21.1 types `actorParameter` and
+  // `stakeholderParameter` as PART usages: an actor is a part that plays a
+  // role, and a stakeholder is a part that holds an interest. So each names a
+  // part definition, exactly as a `part` usage does.
+  ActorDecl: { keyword: "actor", expected: "a 'part def' (or the 'item def' / 'occurrence def' it specializes)", allowed: /* @__PURE__ */ new Set(["PartDecl", "ItemDecl", "OccurrenceDecl"]) },
+  StakeholderDecl: { keyword: "stakeholder", expected: "a 'part def' (or the 'item def' / 'occurrence def' it specializes)", allowed: /* @__PURE__ */ new Set(["PartDecl", "ItemDecl", "OccurrenceDecl"]) },
   RenderingDecl: { keyword: "rendering", expected: "a 'rendering def'", allowed: /* @__PURE__ */ new Set(["RenderingDecl", "PartDecl"]) },
   MetadataDecl: { keyword: "metadata", expected: "a 'metadata def'", allowed: /* @__PURE__ */ new Set(["MetadataDecl"]) }
 };
@@ -183479,7 +183958,7 @@ function introducedNames(imp, index2, nodeOf) {
 function protectedNamespaceKeysFor(context, globalDescs, nodeOf) {
   const keys3 = /* @__PURE__ */ new Set();
   const visitedTargets = /* @__PURE__ */ new Set();
-  const collect = (targetName) => {
+  const collect2 = (targetName) => {
     if (visitedTargets.has(targetName))
       return;
     visitedTargets.add(targetName);
@@ -183491,13 +183970,13 @@ function protectedNamespaceKeysFor(context, globalDescs, nodeOf) {
     if (!node || !isDeclLike(node))
       return;
     for (const inherited of specializationTargets4(node))
-      collect(inherited);
+      collect2(inherited);
   };
   let cur = context;
   while (cur) {
     if (isDeclLike(cur)) {
       for (const target of specializationTargets4(cur))
-        collect(target);
+        collect2(target);
     }
     cur = cur.$container;
   }
@@ -183881,12 +184360,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_KINDS7 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS8 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 function specializationTargets5(node) {
   const n2 = node;
   const out = [];
   for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
-    if (rel2.kind && SPECIALIZATION_KINDS7.has(rel2.kind))
+    if (rel2.kind && SPECIALIZATION_KINDS8.has(rel2.kind))
       out.push(...rel2.targets ?? []);
   }
   return out;
@@ -184174,12 +184653,12 @@ function directImportEntries(imp, descriptions) {
   }
   return applyFilters(imp, selectMemberships(path10, form, descriptions), options);
 }
-var SPECIALIZATION_KINDS8 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS9 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 function specializationTargets6(node) {
   const value = node;
   const targets = [];
   for (const relationship of [...value.preRelationships ?? [], ...value.relationships ?? []]) {
-    if (relationship.kind && SPECIALIZATION_KINDS8.has(relationship.kind)) {
+    if (relationship.kind && SPECIALIZATION_KINDS9.has(relationship.kind)) {
       targets.push(...relationship.targets ?? []);
     }
   }
@@ -184348,7 +184827,7 @@ var SysmlRenameProvider = class extends DefaultRenameProvider {
   // comparison is against `oldName` directly.
   *writtenPathSegments(root4, oldName) {
     const matching = (segments) => segments.filter((segment) => segment.text === oldName);
-    const spellsName = (path10) => !!path10 && pathSegments2(path10).some((step) => canonicalEscapedName(step) === oldName);
+    const spellsName = (path10) => !!path10 && pathSegments3(path10).some((step) => canonicalEscapedName(step) === oldName);
     for (const node of [root4, ...ast_utils_exports.streamAllContents(root4)]) {
       if (isPathExpr(node)) {
         if (!spellsName(node.path))
@@ -184423,7 +184902,7 @@ var SysmlRenameProvider = class extends DefaultRenameProvider {
     return this.references.findDeclaration(leafNode);
   }
 };
-function pathSegments2(path10) {
+function pathSegments3(path10) {
   const out = [];
   let current2 = "";
   let quoted = false;
@@ -186213,7 +186692,7 @@ function typeAnchor(node, refText) {
   }
   return void 0;
 }
-var REDEFINITION_KINDS4 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var REDEFINITION_KINDS5 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var CONSTANT_CARRYING_KINDS = /* @__PURE__ */ new Set([
   ":>",
   "subsets",
@@ -186602,7 +187081,7 @@ var SysmlInlayHintProvider = class {
       const parameter = mine[index2].node;
       if (!parameter.name || !parameter.$cstNode)
         continue;
-      if (allRelationships3(parameter).some((rel2) => rel2.kind && REDEFINITION_KINDS4.has(rel2.kind)))
+      if (allRelationships3(parameter).some((rel2) => rel2.kind && REDEFINITION_KINDS5.has(rel2.kind)))
         continue;
       const target = theirs[index2].node;
       if (!target.name || target.name === parameter.name)
@@ -186845,7 +187324,7 @@ var SysmlInlayHintProvider = class {
 function effectiveNameHint(node, resolver) {
   if (node.name || node.shortName?.name || !node.$cstNode)
     return void 0;
-  const redefinition = allRelationships3(node).find((rel2) => rel2.kind && REDEFINITION_KINDS4.has(rel2.kind) && (rel2.targets?.length ?? 0) > 0);
+  const redefinition = allRelationships3(node).find((rel2) => rel2.kind && REDEFINITION_KINDS5.has(rel2.kind) && (rel2.targets?.length ?? 0) > 0);
   if (!redefinition?.targets?.[0])
     return void 0;
   const names = effectiveNamesOf(node, resolver);
@@ -186878,6 +187357,12 @@ var EVAL_LABEL = {
   inconclusive: "$(question) Requirement: inconclusive (values unavailable)",
   unresolved: "$(warning) Requirement: unresolved reference"
 };
+var NEGATED_EVAL_LABEL = {
+  pass: "$(pass) Requirement not satisfied, as claimed",
+  fail: "$(error) Requirement satisfied, against the claim",
+  inconclusive: EVAL_LABEL.inconclusive,
+  unresolved: EVAL_LABEL.unresolved
+};
 function indexByName(root4, type) {
   const map3 = /* @__PURE__ */ new Map();
   walkAst(root4, (n2) => {
@@ -186887,11 +187372,6 @@ function indexByName(root4, type) {
   });
   return map3;
 }
-function lastSegment4(path10) {
-  if (!path10)
-    return void 0;
-  return path10.split(/::|\./).pop();
-}
 function qualifiedNameOf2(node) {
   const parts = [];
   let cur = node;
@@ -186977,16 +187457,13 @@ var SysmlCodeLensProvider = class {
         return;
       const range = cst.range;
       if (isSatisfyStmt(node)) {
-        const reqName = lastSegment4(node.target);
-        const req = reqName ? requirements.get(reqName) : void 0;
-        if (req) {
-          const bound = bindingName(node.by);
-          const subject = bound ? parts.get(bound) : void 0;
-          const result = evaluateRequirement(req, subject);
+        const result = evaluateSatisfy(node, (name) => requirements.get(name), (name) => parts.get(name));
+        if (result.requirement) {
+          const labels = node.isNegated ? NEGATED_EVAL_LABEL : EVAL_LABEL;
           lenses.push({
             range,
             command: {
-              title: EVAL_LABEL[result.status],
+              title: labels[result.status],
               command: "editor.action.findReferences",
               arguments: [uri, range.start]
             }
@@ -190435,7 +190912,7 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
     frames.filter((f) => framePresentationEnabled(hiddenInternals, f) && isHost(f)).map((f) => f.id)
   );
   if (requested.size === 0) return model;
-  const rootOf = (id2) => {
+  const rootOf2 = (id2) => {
     let root4;
     const seen = /* @__PURE__ */ new Set();
     for (let cur = id2; cur !== void 0 && !seen.has(cur); cur = frameById.get(cur)?.parent) {
@@ -190444,13 +190921,13 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
     }
     return root4;
   };
-  const roots = new Set([...requested].filter((id2) => rootOf(frameById.get(id2)?.parent) === void 0));
+  const roots = new Set([...requested].filter((id2) => rootOf2(frameById.get(id2)?.parent) === void 0));
   const dockOf = /* @__PURE__ */ new Map();
   const proxyHost = /* @__PURE__ */ new Map();
   const ownerOfHiddenPort = /* @__PURE__ */ new Map();
   const hiddenFrameIds = /* @__PURE__ */ new Set();
   for (const f of frames) {
-    const root4 = roots.has(f.id) ? rootOf(f.parent) : rootOf(f.id);
+    const root4 = roots.has(f.id) ? rootOf2(f.parent) : rootOf2(f.id);
     if (root4 === void 0) continue;
     hiddenFrameIds.add(f.id);
     dockOf.set(f.id, root4);
@@ -190461,7 +190938,7 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
   }
   const hiddenNodeIds = /* @__PURE__ */ new Set();
   for (const n2 of model.nodes) {
-    const root4 = rootOf(n2.frame);
+    const root4 = rootOf2(n2.frame);
     if (root4 === void 0) continue;
     hiddenNodeIds.add(n2.id);
     dockOf.set(n2.id, root4);
@@ -210783,7 +211260,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.35.0" : "dev";
+var VERSION2 = true ? "0.36.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;