sysml-diagram 0.36.0 → 0.38.0

package/out/main.js

@@ -161054,6 +161054,125 @@ var ANCHOR_KEYWORD = {
   bv: "package"
 };
 
+// ../language-server/out/src/services/constraint-reference.js
+var REFERENCE_KEYWORDS = {
+  AssertConstraintStmt: "assert",
+  RequireConstraintStmt: "require",
+  AssumeConstraintStmt: "assume"
+};
+function constraintReferenceOf(node) {
+  const kind = REFERENCE_KEYWORDS[node.$type];
+  if (!kind)
+    return void 0;
+  const shape = node;
+  if (shape.constraintKw)
+    return void 0;
+  const negated = shape.isNegated === true;
+  if (kind === "assert") {
+    if (!shape.name)
+      return void 0;
+    const links = [shape.name, ...shape.chainSegs ?? []];
+    return { kind, negated, path: links.join("::"), simpleName: links[links.length - 1] };
+  }
+  const target = shape.target;
+  if (typeof target !== "string" || target.length === 0)
+    return void 0;
+  return {
+    kind,
+    negated,
+    property: "target",
+    path: target,
+    simpleName: lastLink(target)
+  };
+}
+function lastLink(path10) {
+  return path10.split(/::|\./u).filter(Boolean).pop() ?? path10;
+}
+var NON_CONSTRAINT_DECL_TYPES = /* @__PURE__ */ new Set([
+  "Package",
+  "NamespaceDecl",
+  "Document",
+  "Import",
+  "PartDecl",
+  "ItemDecl",
+  "AttributeDecl",
+  "PortDecl",
+  "OccurrenceDecl",
+  "InterfaceDecl",
+  "ConnectionDecl",
+  "AllocationDecl",
+  "ConnectorDecl",
+  "EnumDecl",
+  "EnumValueDecl",
+  "MetadataDecl",
+  "MultiplicityDecl",
+  "ActionDecl",
+  "StateDecl",
+  "CalcDecl",
+  "CaseDecl",
+  "UseCaseDecl",
+  "AnalysisCaseDecl",
+  "VerificationCaseDecl",
+  "ViewDecl",
+  "ViewpointDecl",
+  "RenderingDecl",
+  "ActorDecl",
+  "StakeholderDecl",
+  "StructDecl",
+  "ClassDecl",
+  "DatatypeDecl",
+  "AssociationDecl",
+  "MetaclassDecl",
+  "BehaviorDecl",
+  "FunctionDecl",
+  "InteractionDecl"
+]);
+var NON_CONSTRAINT_LABELS = {
+  Package: "a package",
+  NamespaceDecl: "a namespace",
+  Document: "a file root namespace",
+  Import: "an import",
+  PartDecl: "a part",
+  ItemDecl: "an item",
+  AttributeDecl: "an attribute",
+  PortDecl: "a port",
+  OccurrenceDecl: "an occurrence",
+  InterfaceDecl: "an interface",
+  ConnectionDecl: "a connection",
+  AllocationDecl: "an allocation",
+  ConnectorDecl: "a connector",
+  EnumDecl: "an enumeration",
+  EnumValueDecl: "an enumeration value",
+  MetadataDecl: "a metadata usage",
+  MultiplicityDecl: "a multiplicity",
+  ActionDecl: "an action",
+  StateDecl: "a state",
+  CalcDecl: "a calculation",
+  CaseDecl: "a case",
+  UseCaseDecl: "a use case",
+  AnalysisCaseDecl: "an analysis case",
+  VerificationCaseDecl: "a verification case",
+  ViewDecl: "a view",
+  ViewpointDecl: "a viewpoint",
+  RenderingDecl: "a rendering",
+  ActorDecl: "an actor",
+  StakeholderDecl: "a stakeholder",
+  StructDecl: "a structure",
+  ClassDecl: "a class",
+  DatatypeDecl: "a datatype",
+  AssociationDecl: "an association",
+  MetaclassDecl: "a metaclass",
+  BehaviorDecl: "a behavior",
+  FunctionDecl: "a function",
+  InteractionDecl: "an interaction"
+};
+function isWrongKindConstraintTarget(node) {
+  return NON_CONSTRAINT_DECL_TYPES.has(node.$type);
+}
+function wrongKindLabel(node) {
+  return NON_CONSTRAINT_LABELS[node.$type] ?? "not a constraint";
+}
+
 // ../language-server/out/src/services/requirement-semantics.js
 var DEFAULT_SUBJECT_TYPE = "Anything";
 var MAX_INHERITANCE_DEPTH = 16;
@@ -161071,6 +161190,16 @@ var REQUIREMENT_SHAPED = /* @__PURE__ */ new Set([
   "ObjectiveDecl",
   "ViewpointDecl"
 ]);
+var CASE_SHAPED = /* @__PURE__ */ new Set([
+  "CaseDecl",
+  "AnalysisCaseDecl",
+  "VerificationCaseDecl",
+  "UseCaseDecl"
+]);
+var SUBJECT_SHAPED = /* @__PURE__ */ new Set([
+  ...REQUIREMENT_SHAPED,
+  ...CASE_SHAPED
+]);
 var CONSTRAINT_SHAPED = /* @__PURE__ */ new Set([
   "ConstraintDecl",
   "InvShorthand",
@@ -161178,9 +161307,10 @@ function referencePathOf(member) {
     return target.trim() || void 0;
   if (target && typeof target === "object") {
     const text = target.$refText?.trim();
-    return text || void 0;
+    if (text)
+      return text;
   }
-  return void 0;
+  return constraintReferenceOf(member)?.path;
 }
 function referenceTargetOf(member, resolve8) {
   const target = member.target;
@@ -161361,7 +161491,7 @@ function inheritedSubject(node, resolve8, depth, seen) {
     return void 0;
   seen.add(node);
   for (const supertype of supertypesOf(node, resolve8)) {
-    if (!REQUIREMENT_SHAPED.has(supertype.$type))
+    if (!SUBJECT_SHAPED.has(supertype.$type))
       continue;
     const own = ownSubject(supertype);
     if (own)
@@ -161685,7 +161815,7 @@ function memberNamed(node, name, seen = /* @__PURE__ */ new Set()) {
   const typeRef = node.typing?.type?.ref;
   return typeRef ? memberNamed(typeRef, name, seen) : void 0;
 }
-function resolveFeatureValue(root4, segments) {
+function resolveFeatureValue(root4, segments, ext) {
   let cur = root4;
   for (const seg of segments) {
     cur = memberNamed(cur, seg);
@@ -161693,7 +161823,7 @@ function resolveFeatureValue(root4, segments) {
       return UNRESOLVED;
   }
   if (cur.value)
-    return evaluateExpr(cur.value, () => INCONCLUSIVE);
+    return evaluateExpr(cur.value, () => INCONCLUSIVE, ext);
   return INCONCLUSIVE;
 }
 function subjectScope(subjectName, subjectBinding) {
@@ -161788,6 +161918,83 @@ function evaluateSatisfy(stmt, resolveRequirement, resolvePart, resolve8) {
   const status = result.status === "pass" ? "fail" : result.status === "fail" ? "pass" : result.status;
   return { status, requirement, satisfier };
 }
+var CONSTRAINT_SHAPED_TYPES = /* @__PURE__ */ new Set([
+  "ConstraintDecl",
+  "InvShorthand",
+  "RequirementDecl",
+  "ConcernDecl",
+  "PredicateDecl",
+  "AssertConstraintStmt",
+  "RequireConstraintStmt",
+  "AssumeConstraintStmt"
+]);
+function exprText2(node) {
+  return node?.$cstNode?.text?.trim() ?? "";
+}
+function rootOf2(node) {
+  let current2 = node;
+  while (current2.$container)
+    current2 = current2.$container;
+  return current2;
+}
+function* walkMembers(node) {
+  for (const member of [...node.elements ?? [], ...node.members ?? []]) {
+    yield member;
+    yield* walkMembers(member);
+  }
+}
+function documentConstraintResolver() {
+  return (reference, member) => {
+    for (const candidate of walkMembers(rootOf2(member))) {
+      if (candidate.name === reference.simpleName && CONSTRAINT_SHAPED_TYPES.has(candidate.$type)) {
+        return candidate;
+      }
+    }
+    return void 0;
+  };
+}
+var assertionExpression = (node) => {
+  const expr = node;
+  return (expr.$type === "NumericPrimary" || expr.$type === "PostfixOp") && expr.unit ? INCONCLUSIVE : void 0;
+};
+function evaluateAssertion(node, resolveConstraint = documentConstraintResolver()) {
+  const member = node;
+  if (member.$type !== "AssertConstraintStmt")
+    return void 0;
+  const reference = constraintReferenceOf(member);
+  const negated = reference?.negated ?? member.isNegated === true;
+  let body;
+  let text;
+  let target;
+  if (reference) {
+    text = `${reference.kind}${reference.negated ? " not" : ""} ${reference.path}`;
+    target = resolveConstraint(reference, member);
+    if (!target)
+      return { status: "unresolved", text };
+    body = member.body ?? constraintBodyOf(target, documentResolver(member));
+  } else {
+    body = member.body;
+    text = exprText2(member.body);
+  }
+  if (!body)
+    return { status: "inconclusive", text };
+  const scope = (segments) => {
+    for (const owner of [member, target]) {
+      if (!owner)
+        continue;
+      if (memberNamed(owner, segments[0])) {
+        return resolveFeatureValue(owner, segments, assertionExpression);
+      }
+    }
+    return INCONCLUSIVE;
+  };
+  const value = negate2(evaluateExpr(body, scope, assertionExpression), negated);
+  if (value.kind === "unresolved")
+    return { status: "unresolved", text };
+  if (value.kind !== "boolean")
+    return { status: "inconclusive", text };
+  return { status: value.value ? "pass" : "fail", text };
+}
 function bindingName(by) {
   const n2 = by;
   if (n2?.$type !== "PathExpr")
@@ -163036,6 +163243,21 @@ function unwrap(node) {
 }
 var namedChildrenByNode = /* @__PURE__ */ new WeakMap();
 var childrenByName = /* @__PURE__ */ new WeakMap();
+var REFERENCE_FORM_DECLARATIONS = {
+  PerformStmt: "actionKw",
+  EntryAction: "actionKw",
+  DoAction: "actionKw",
+  ExitAction: "actionKw",
+  ExhibitStateDecl: "stateKw",
+  AssertConstraintStmt: "constraintKw",
+  EventDecl: "isOccurrence"
+};
+function isReferenceFormDeclaration(node) {
+  const keyword = REFERENCE_FORM_DECLARATIONS[node.$type];
+  if (!keyword)
+    return false;
+  return node[keyword] !== true;
+}
 function directNamedChildren(node) {
   const cached = namedChildrenByNode.get(node);
   if (cached)
@@ -163044,6 +163266,8 @@ function directNamedChildren(node) {
   const seen = /* @__PURE__ */ new Set();
   for (const raw of ast_utils_exports.streamContents(node)) {
     const child = unwrap(raw);
+    if (isReferenceFormDeclaration(child))
+      continue;
     if (!nameOf(child) || seen.has(child))
       continue;
     seen.add(child);
@@ -163525,7 +163749,7 @@ var FeaturePathResolver = class {
     }
     for (let owner = node.$container; owner; owner = owner.$container) {
       const declaredName3 = owner.name;
-      if (typeof declaredName3 === "string" && canonicalEscapedName(declaredName3) === name && !isSelfReference(owner, node)) {
+      if (typeof declaredName3 === "string" && canonicalEscapedName(declaredName3) === name && !isReferenceFormDeclaration(owner) && !isSelfReference(owner, node)) {
         return this.targetForNode(owner, this.memberInventoryKnown(owner, snapshot));
       }
       if (boundVariableName(owner) === name) {
@@ -166341,6 +166565,16 @@ var directionOf = (node) => {
     return void 0;
   return mods.find((m) => m === "in" || m === "out" || m === "inout");
 };
+function parameterKeyword(node) {
+  const direction = directionOf(node);
+  if (!direction)
+    return void 0;
+  let owner = node.$container;
+  while (owner?.$type === "PrefixMetadataMember" || owner?.$type === "MemberPrefixDecl") {
+    owner = owner.$container;
+  }
+  return owner && (isConstraintDecl(owner) || isCalcDecl(owner)) ? `${direction} parameter` : void 0;
+}
 function keywordFor(node) {
   const n2 = node;
   if (node.$type === "VariantReference")
@@ -166402,6 +166636,9 @@ function keywordFor(node) {
     DoAction: "do action",
     ExitAction: "exit action"
   };
+  const parameter = parameterKeyword(node);
+  if (parameter)
+    return parameter;
   if (t === "ActionDecl" && n2.inlineBody?.$type === "AcceptNode") {
     return "accept action";
   }
@@ -167879,6 +168116,19 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const all = [...ast_utils_exports.streamAllContents(scope)];
     const annotationNodes = all.filter(isGvAnnotationNode);
     const annotationNodeSet = new Set(annotationNodes);
+    const declaredOwnerOf = (node) => {
+      let owner = node.$container;
+      while (owner?.$type === "PrefixMetadataMember" || owner?.$type === "MemberPrefixDecl") {
+        owner = owner.$container;
+      }
+      return owner;
+    };
+    const isDefinitionParameter = (node) => {
+      if (directionOf(node) === void 0)
+        return false;
+      const owner = declaredOwnerOf(node);
+      return !!owner && owner.isDef === true && (isConstraintDecl(owner) || isCalcDecl(owner));
+    };
     const usageNodes = all.filter(isGvExplicitUsage);
     const usageNodeSet = new Set(usageNodes);
     const usageDefinitions = new Map(usageNodes.map((node) => [
@@ -167917,7 +168167,20 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         semanticOwners.set(member, found);
       return found;
     };
+    const readsAsAttribute = (node) => isAttributeDecl(node) || isAttributeDecl(this.resolveType(node, index2));
+    const implicitlyRedefined = (node) => {
+      const name = nameOf2(node);
+      const owner = semanticOwner(node);
+      if (!name || !owner || owner.isDef === true)
+        return void 0;
+      const definition = usageDefinitions.get(owner);
+      if (!definition)
+        return void 0;
+      return membersOf(definition).find((member) => nameOf2(member) === name);
+    };
     const attributeUsages = new Set(usageNodes.filter((node) => {
+      if (isDefinitionParameter(node))
+        return false;
       if (isAttributeDecl(node))
         return true;
       const owner = semanticOwner(node);
@@ -167928,12 +168191,23 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const definition = usageDefinitions.get(node);
       if (definition && isAttributeDecl(definition))
         return true;
-      return redefinitionTargetsOf(node).some((target) => {
+      if (redefinitionTargetsOf(node).some((target) => {
         const inherited = this.resolveFeatureInheritanceTarget(node, target, index2, /* @__PURE__ */ new Set());
         return inherited && isAttributeDecl(inherited);
-      });
+      }))
+        return true;
+      const implicit = implicitlyRedefined(node);
+      return !!implicit && readsAsAttribute(implicit);
     }));
     const attributeValue = (node) => valueTextOf(node) ?? node.default?.value?.$cstNode?.text ?? "";
+    const returnMemberOf = (node) => membersOf(node).find((m) => m.$type === "ReturnDecl");
+    const expressionBody = (node) => {
+      const ret = isCalcDecl(node) ? returnMemberOf(node) : void 0;
+      const text = ret ? valueTextOf(ret) ?? "" : node.body?.$cstNode?.text ?? "";
+      return text.replace(/\s+/g, " ").trim();
+    };
+    const declaresExpression = (node) => node.body !== void 0 || isCalcDecl(node) && valueTextOf(returnMemberOf(node)) !== void 0;
+    const showsExpressionField = (node) => (isConstraintDecl(node) || isCalcDecl(node)) && (node.isDef === true || declaresExpression(node));
     const ids = /* @__PURE__ */ new Map();
     const unnamedOrdinals = /* @__PURE__ */ new Map();
     const semanticId = (node) => {
@@ -167989,6 +168263,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         multiplicity: this.multText(n2),
         type: typeText(n2) ?? (usageDefinitions.get(n2) ? nameOf2(usageDefinitions.get(n2)) : void 0),
         ...attributeUsages.has(n2) ? { value: attributeValue(n2) } : {},
+        // REQ-208/209 — the constraint or calculation expression field.
+        ...showsExpressionField(n2) ? { value: expressionBody(n2) } : {},
         compartments: extra?.compartments ?? this.compartmentsFor(n2, uri, index2, shape === "box"),
         ...packageOf2(n2),
         source: sourceOf2(n2, uri),
@@ -168003,9 +168279,60 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     for (const usage of usageNodes) {
       pushNode(usage, "box", false, {
         compartments: this.compartmentsFor(usage, uri, index2, true, false),
-        ...attributeUsages.has(usage) ? { keyword: "attribute" } : {}
+        // REQ-376 — a parameter keeps its own banner; only an ordinary
+        // attribute usage is relabelled by its value-carrying role.
+        ...attributeUsages.has(usage) && !parameterKeyword(usage) ? { keyword: "attribute" } : {}
       });
     }
+    for (const usage of usageNodes) {
+      if (!isConstraintDecl(usage) || usage.isDef === true)
+        continue;
+      const definition = usageDefinitions.get(usage);
+      if (!definition || !isConstraintDecl(definition))
+        continue;
+      const usageId = semanticId(usage);
+      const local = new Set(membersOf(usage).flatMap((member) => [nameOf2(member), ...redefinitionTargetsOf(member)]).filter((name) => !!name));
+      for (const member of membersOf(definition)) {
+        const name = nameOf2(member);
+        if (!name || local.has(name))
+          continue;
+        if (directionOf(member) === void 0 && !isAttributeDecl(member))
+          continue;
+        const id2 = `${usageId}::${name}`;
+        if (nodes.some((existing) => existing.id === id2))
+          continue;
+        nodes.push({
+          id: id2,
+          name: effectiveNameOf(member) ?? name,
+          keyword: "attribute",
+          isDef: false,
+          shape: "box",
+          multiplicity: this.multText(member),
+          type: typeText(member),
+          value: attributeValue(member),
+          compartments: [],
+          parent: usageId,
+          // Navigation lands on the declaration the member comes from.
+          source: sourceOf2(member, uri),
+          meta: {
+            gvUsage: true,
+            gvOwnerId: usageId,
+            gvExplicit: true,
+            gvDeclaredName: name,
+            gvDeclaredType: typeText(member) ?? "",
+            // REQ-364 — the concrete usage that owns a local edit, plus
+            // the relative redefinition path to write inside it.
+            localUsageId: usageId,
+            localUsageName: nameOf2(usage),
+            localUsageSource: sourceOf2(usage, uri),
+            localUsagePath: [name],
+            expandedFromDefinition: true,
+            declarationId: qnameOf(member),
+            declarationSource: sourceOf2(member, uri)
+          }
+        });
+      }
+    }
     for (const p of packageNodes) {
       const pn = p;
       pushNode(p, "package", false, {
@@ -168322,6 +168649,28 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         }
       }
     }
+    const CLAIM_EDGE_KINDS = {
+      AssertConstraintStmt: "assert",
+      AssumeConstraintStmt: "assume",
+      RequireConstraintStmt: "require"
+    };
+    for (const owner of [...defNodes, ...usageNodes]) {
+      for (const m of membersOf(owner)) {
+        const claim = CLAIM_EDGE_KINDS[m.$type];
+        if (!claim)
+          continue;
+        const negated = m.isNegated === true;
+        const label = `\xAB${claim}${negated ? " not" : ""}\xBB`;
+        const reference = constraintReferenceOf(m);
+        if (reference) {
+          linkByName(claim, owner, reference.path, label, m);
+          continue;
+        }
+        const typed = typeText(m);
+        if (typed)
+          linkByName(claim, owner, typed, label, m);
+      }
+    }
     const allocPairs = [
       ...all.filter((m) => m.$type === "AllocateStmt").map((a2) => ({
         from: String(a2.source ?? ""),
@@ -172388,7 +172737,12 @@ ${node.id}`;
       idOf.set(n2, id2);
       nodes.push({
         id: id2,
-        name: nameOf2(n2) ?? lastSeg(typeText(n2) ?? "subject"),
+        // REQ-404 — a redeclaration (`actor :>> driver = …`) writes no name
+        // of its own; the name it is KNOWN BY is the one it redefines, which
+        // is the same derivation the rest of the model is labelled by. The
+        // last-resort fallback is the SHAPE, never the literal 'subject':
+        // that string labelled every unnamed actor "subject" on the card.
+        name: effectiveNameOf(n2) ?? lastSeg(typeText(n2) ?? shape),
         keyword: keywordFor(n2),
         isDef: n2.isDef === true,
         shape,
@@ -172432,14 +172786,15 @@ ${node.id}`;
     const declarationKey = (subject) => {
       const type = this.resolveType(subject, index2);
       const typeKey = (type ? qnameOf(type) : void 0) || typeText(subject) || "";
-      const name = nameOf2(subject) ?? "";
+      const name = effectiveNameOf(subject) ?? "";
       return name || typeKey ? `subject:${name}|${typeKey}` : "";
     };
     const declarationText = (subject) => {
       const value = subjectValuePath(subject);
       const type = typeText(subject);
-      return [nameOf2(subject), type ? `: ${type}` : void 0, value ? `= ${value}` : void 0].filter((part) => !!part).join(" ");
+      return [effectiveNameOf(subject), type ? `: ${type}` : void 0, value ? `= ${value}` : void 0].filter((part) => !!part).join(" ");
     };
+    const boundKeysOfDeclaration = /* @__PURE__ */ new Map();
     const subjectKey = (subject, seen = /* @__PURE__ */ new Set()) => {
       const canonical = canonicalSubjectTarget(subject);
       if (canonical && isSubjectDecl(canonical) && canonical !== subject && !seen.has(canonical)) {
@@ -172448,7 +172803,14 @@ ${node.id}`;
       }
       const canonicalQName = canonical && !isSubjectDecl(canonical) ? qnameOf(canonical) : "";
       const value = subjectValuePath(subject);
-      return canonicalQName ? `target:${canonicalQName}` : value ? `value:${value}` : declarationKey(subject) || `decl:${qnameOf(subject) || `${subject.$cstNode?.offset ?? 0}:subject`}`;
+      if (canonicalQName)
+        return `target:${canonicalQName}`;
+      if (value)
+        return `value:${value}`;
+      const adopted = boundKeysOfDeclaration.get(subject);
+      if (adopted?.size === 1)
+        return [...adopted][0];
+      return declarationKey(subject) || `decl:${qnameOf(subject) || `${subject.$cstNode?.offset ?? 0}:subject`}`;
     };
     const subjectIdByKey = /* @__PURE__ */ new Map();
     const subjectOfCase = /* @__PURE__ */ new Map();
@@ -172459,7 +172821,7 @@ ${node.id}`;
       const key2 = subjectKey(subject);
       let sid = subjectIdByKey.get(key2);
       if (!sid) {
-        const label = nameOf2(identity6) ?? lastSeg(value || typeText(identity6) || "subject");
+        const label = effectiveNameOf(identity6) ?? lastSeg(value || typeText(identity6) || "subject");
         add(identity6, "subject", {
           id: `${scopeId}::__cv_subject__::${key2}`,
           name: label,
@@ -172471,6 +172833,26 @@ ${node.id}`;
       idOf.set(subject, sid);
       return sid;
     };
+    for (const c of displayedCases) {
+      const declared = declaredMembers(c).filter(isSubjectDecl);
+      for (const bound of declared) {
+        if (!subjectValuePath(bound))
+          continue;
+        const name = effectiveNameOf(bound);
+        if (!name)
+          continue;
+        for (const target of declared) {
+          if (target === bound || subjectValuePath(target))
+            continue;
+          if (effectiveNameOf(target) !== name)
+            continue;
+          let keys3 = boundKeysOfDeclaration.get(target);
+          if (!keys3)
+            boundKeysOfDeclaration.set(target, keys3 = /* @__PURE__ */ new Set());
+          keys3.add(subjectKey(bound));
+        }
+      }
+    }
     const denotesSubject = (s) => !!(nameOf2(s) || typeText(s) || subjectValuePath(s));
     for (const c of displayedCases) {
       const declared = declaredMembers(c).filter(isSubjectDecl);
@@ -172513,16 +172895,47 @@ ${node.id}`;
     };
     const actorOfCase = [];
     const actorCasePairs = /* @__PURE__ */ new Set();
-    const anonymousActorId = (actor) => nameOf2(actor) ? void 0 : `${scopeId}::__cv_actor__::${qnameOf(actor)}:${actor.$cstNode?.offset ?? 0}`;
+    const actorTypeKey = (actor) => {
+      const type = this.resolveType(actor, index2);
+      return (type ? qnameOf(type) : void 0) || typeText(actor) || "";
+    };
+    const actorTypeSource = (actor, siblings) => {
+      if (actorTypeKey(actor))
+        return actor;
+      const name = effectiveNameOf(actor);
+      if (!name)
+        return void 0;
+      return siblings.find((sibling) => sibling !== actor && effectiveNameOf(sibling) === name && !!actorTypeKey(sibling));
+    };
+    const actorDeclarationKey = (actor, siblings) => {
+      const name = effectiveNameOf(actor) ?? "";
+      const typeKey = actorTypeKey(actorTypeSource(actor, siblings) ?? actor);
+      return name || typeKey ? `actor:${name}|${typeKey}` : "";
+    };
+    const actorKey = (actor, siblings) => actorDeclarationKey(actor, siblings) || `decl:${qnameOf(actor) || ""}:${actor.$cstNode?.offset ?? 0}`;
+    const actorIdByKey = /* @__PURE__ */ new Map();
+    const addActor = (actor, siblings) => {
+      const canonical = actorCanonical(actor);
+      const key2 = actorKey(canonical, siblings);
+      let aid = actorIdByKey.get(key2);
+      if (aid === void 0) {
+        const typeSource = actorTypeSource(canonical, siblings);
+        add(canonical, "actor", {
+          id: `${scopeId}::__cv_actor__::${key2}`,
+          ...typeSource && typeSource !== canonical ? { type: typeText(typeSource) } : {},
+          meta: { cvAuxiliary: true }
+        });
+        aid = idOf.get(canonical);
+        actorIdByKey.set(key2, aid);
+      }
+      idOf.set(actor, aid);
+      return aid;
+    };
     for (const c of displayedCases) {
-      for (const a2 of declaredMembers(c)) {
-        if (!isActorDecl(a2))
-          continue;
-        const canonical = actorCanonical(a2);
-        if (!idOf.has(canonical))
-          add(canonical, "actor", { id: anonymousActorId(canonical), meta: { cvAuxiliary: true } });
-        const actorId = idOf.get(canonical);
-        idOf.set(a2, actorId);
+      const siblings = declaredMembers(c).filter(isActorDecl);
+      const typeSources = siblings.some((a2) => !actorTypeKey(a2)) ? [...siblings, ...this.inheritedTypesOf(c, index2).flatMap((t) => membersOf(t).filter(isActorDecl))] : siblings;
+      for (const a2 of siblings) {
+        const actorId = addActor(a2, typeSources);
         const pair = `${actorId}\0${qnameOf(c) ?? nameOf2(c) ?? ""}`;
         if (!actorCasePairs.has(pair)) {
           actorCasePairs.add(pair);
@@ -174271,7 +174684,7 @@ ${node.id}`;
     const inherited = includeInherited ? this.inheritedItems(node, index2, uri) : [];
     const inheritedRows = (predicate, text = (member) => this.featureText(member)) => inherited.filter(({ member }) => predicate(member)).map(({ member, source }) => ({ text: `^${text(member)}`, source }));
     const usages = (guard) => members.filter((m) => guard(m) && m.isDef !== true && nameOf2(m) && isOrdinaryMember(m));
-    const exprText3 = (m) => (m.body?.$cstNode?.text ?? "").replace(/\s+/g, " ").trim();
+    const exprText4 = (m) => (m.body?.$cstNode?.text ?? "").replace(/\s+/g, " ").trim();
     const statementText = (m) => (m.$cstNode?.text ?? this.featureText(m)).replace(/\s+/g, " ").replace(/;$/, "").trim();
     const canonicalFeatureText = (m) => m.$type === "FeatureShorthand" || m.$type === "FeatureRedefinitionShorthand" ? statementText(m) : this.featureText(m);
     const out = [];
@@ -174323,8 +174736,8 @@ ${node.id}`;
     add("occurrences", members.map((m) => this.thenActionMemberNode(m) ?? m).filter(isNonVariantMember).filter((m) => isEventDecl(m) && m.isOccurrence === true && nameOf2(m)).map((m) => item(m)));
     add("calcs", undirected(isCalcDecl).map((m) => item(m)));
     add("constraints", undirected(isConstraintDecl).map((m) => item(m)));
-    add("assume constraints", members.filter((m) => m.$type === "AssumeConstraintStmt").map((m) => item(m, exprText3(m) || "assume constraint")));
-    add("require constraints", members.filter((m) => m.$type === "RequireConstraintStmt").map((m) => item(m, exprText3(m) || `require ${this.featurePath(m.target) ?? ""}`.trim())));
+    add("assume constraints", members.filter((m) => m.$type === "AssumeConstraintStmt").map((m) => item(m, exprText4(m) || "assume constraint")));
+    add("require constraints", members.filter((m) => m.$type === "RequireConstraintStmt").map((m) => item(m, exprText4(m) || `require ${this.featurePath(m.target) ?? ""}`.trim())));
     add("actors", members.filter(isActorDecl).filter(isNonVariantMember).map((m) => item(m)));
     add("stakeholders", members.filter(isStakeholderDecl).filter(isNonVariantMember).map((m) => item(m)));
     add("frames", members.filter((m) => m.$type === "FrameMember").map((m) => item(m, this.refText(m.target) ?? "concern")));
@@ -174353,7 +174766,7 @@ ${node.id}`;
     ]);
     add("result", members.filter((m) => m.$type === "ReturnDecl").map((m) => item(m, `return${nameOf2(m) ? ` ${nameOf2(m)}` : ""}${typeText(m) ? ` : ${typeText(m)}` : ""}`)));
     if (isConstraintDecl(node))
-      add("expression", exprText3(node) ? [{ text: exprText3(node), source: sourceOf2(node, uri) }] : []);
+      add("expression", exprText4(node) ? [{ text: exprText4(node), source: sourceOf2(node, uri) }] : []);
     const enumValueMembers = isEnumDecl(node) ? members.filter(isOwnedEnumerationValue) : members.filter((m) => isNonVariantMember(m) && m.$type === "EnumValueDecl" && !m.typing);
     add("enums", enumValueMembers.map((m) => {
       const nm = nameOf2(m);
@@ -174382,11 +174795,11 @@ ${node.id}`;
     add("state transition", members.filter((m) => m.$type === "TransitionDecl").map((m) => item(m, `${m.from ?? ""} \u2192 ${m.to ?? ""}`)));
     const successionText = (m) => (m.$cstNode?.text ?? "").replace(/\s+/g, " ").replace(/;$/, "").trim();
     add("successions", members.filter((m) => m.$type === "FirstThenChain" || m.$type === "SuccessionStmt" || m.$type === "ThenActionMember" && typeof m.target === "string" || m.$type === "ElseSuccessionMember" || (m.$type === "AcceptNode" || m.$type === "IfActionNode") && typeof m.thenTarget === "string").map((m) => item(m, successionText(m))).filter((row) => !!row.text));
-    add("assert constraints", members.filter((m) => m.$type === "AssertConstraintStmt").map((m) => item(m, exprText3(m) || nameOf2(m) || "assert constraint")));
+    add("assert constraints", members.filter((m) => m.$type === "AssertConstraintStmt").map((m) => item(m, exprText4(m) || nameOf2(m) || "assert constraint")));
     add("invariants", members.filter((m) => m.$type === "InvShorthand").map((m) => {
       const inv = m;
       const head2 = `inv${inv.isNegated ? " false" : ""}${nameOf2(m) ? ` ${nameOf2(m)}` : ""}`;
-      const expr = exprText3(m);
+      const expr = exprText4(m);
       return item(m, `${head2} { ${expr} }`.replace(/\s+/g, " ").trim());
     }));
     add("actions", usages(isActionDecl).map((m) => item(m)));
@@ -174643,8 +175056,12 @@ function projectGvCompartments(input) {
       continue;
     visible.add(node.id);
     const key2 = gvElementKey(node);
-    const open = gvElementIsExpanded(node, expanded2);
-    expandable.add(key2);
+    const children2 = (index2.children.get(node.id) ?? []).filter(
+      (child) => child.meta?.gvDerived !== true && child.meta?.connectionDefinitionHub !== true
+    );
+    const canExpand = children2.length > 0;
+    const open = canExpand && gvElementIsExpanded(node, expanded2);
+    if (canExpand) expandable.add(key2);
     nodes.push({
       ...node,
       parent,
@@ -174663,7 +175080,7 @@ function projectGvCompartments(input) {
         ...node.meta,
         gvMode: "group",
         gvExpansionKey: key2,
-        gvCanExpand: true,
+        gvCanExpand: canExpand,
         gvExpanded: open,
         gvOpenContainer: open,
         internalsHidden: !open,
@@ -174671,7 +175088,7 @@ function projectGvCompartments(input) {
       }
     });
     if (open) {
-      for (const child of index2.children.get(node.id) ?? []) {
+      for (const child of children2) {
         queue.push({ node: child, parent: node.id });
       }
     }
@@ -174707,10 +175124,10 @@ function projectGvTree(input) {
     visible.add(node.id);
     const isPackage2 = node.shape === "package";
     const children2 = (index2.children.get(node.id) ?? []).filter(
-      (child) => isPackage2 || isGvPartUsage(child)
+      (child) => child.meta?.gvTreeExcluded !== true && !isDerivedHub(child) && (isPackage2 || isGvPartUsage(child))
     );
     const key2 = gvElementKey(node);
-    const canExpand = isPackage2 || children2.length > 0 || /\bpart\b/.test(node.keyword);
+    const canExpand = children2.length > 0;
     const open = canExpand && gvElementIsExpanded(node, expanded2, true);
     if (canExpand) expandable.add(key2);
     nodes.push({
@@ -175761,6 +176178,283 @@ function resolveEffectiveSubject(node) {
   return void 0;
 }
 
+// ../language-server/out/src/services/case-semantics.js
+var CASE_KIND_BY_TYPE = /* @__PURE__ */ new Map([
+  ["CaseDecl", "case"],
+  ["AnalysisCaseDecl", "analysis"],
+  ["VerificationCaseDecl", "verification"],
+  ["UseCaseDecl", "use-case"]
+]);
+var MAX_INHERITANCE_DEPTH2 = 16;
+function caseKindOf(node) {
+  return node ? CASE_KIND_BY_TYPE.get(node.$type) : void 0;
+}
+function enclosingCase(node) {
+  let current2 = node;
+  while (current2) {
+    if (CASE_SHAPED.has(current2.$type))
+      return current2;
+    current2 = current2.$container;
+  }
+  return void 0;
+}
+function writtenTypes(node, resolve8) {
+  const out = [];
+  for (const typing of [node.typing, ...node.moreTypings ?? []]) {
+    if (!typing)
+      continue;
+    for (const ref of [typing.type, ...typing.moreTypes ?? []]) {
+      if (!ref)
+        continue;
+      const name = ref.$refText?.trim() ?? ref.ref?.name;
+      if (!name)
+        continue;
+      out.push({ name, node: ref.ref ?? resolve8(name) });
+    }
+  }
+  return out;
+}
+function effectiveCaseDefinition(node, resolve8) {
+  const kind = caseKindOf(node);
+  if (!kind)
+    return void 0;
+  const decl = node;
+  const resolver = resolve8 ?? documentResolver(node);
+  const definitions = writtenTypes(decl, resolver).filter((type) => type.node === void 0 || CASE_SHAPED.has(type.node.$type));
+  return {
+    kind,
+    isDefinition: decl.isDef === true,
+    definitions,
+    sole: definitions.length === 1 ? definitions[0] : void 0
+  };
+}
+function hasAmbiguousDefinition(node, resolve8) {
+  const effective = effectiveCaseDefinition(node, resolve8);
+  if (!effective || effective.isDefinition)
+    return false;
+  return effective.definitions.filter((type) => type.node !== void 0).length > 1;
+}
+function isDecidedSubject(subject) {
+  if (!subject)
+    return false;
+  return subject.origin !== "default" && subject.origin !== "ambiguous" && subject.typeName !== DEFAULT_SUBJECT_TYPE;
+}
+function effectiveCaseSubject(node, resolve8) {
+  const resolver = resolve8 ?? documentResolver(node);
+  if (hasAmbiguousDefinition(node, resolver)) {
+    const own = ownSubject(node);
+    return own ? subjectInfo(own, node, "own") : { typeName: DEFAULT_SUBJECT_TYPE, origin: "ambiguous" };
+  }
+  return effectiveSubject(node, resolver);
+}
+function ownActors(node) {
+  return (node.members ?? []).filter((member) => member.$type === "ActorDecl");
+}
+function effectiveActors(node, resolve8) {
+  const resolver = resolve8 ?? documentResolver(node);
+  const ambiguous = hasAmbiguousDefinition(node, resolver);
+  const out = [];
+  const seenNodes = /* @__PURE__ */ new Set();
+  const seenNames = /* @__PURE__ */ new Set();
+  const walk = (current2, origin, depth) => {
+    if (depth > MAX_INHERITANCE_DEPTH2 || seenNodes.has(current2))
+      return;
+    seenNodes.add(current2);
+    for (const actor of ownActors(current2)) {
+      if (actor.name && seenNames.has(actor.name))
+        continue;
+      if (actor.name)
+        seenNames.add(actor.name);
+      out.push({
+        declaration: actor,
+        name: actor.name,
+        typeName: subjectTypeName(actor),
+        origin,
+        owner: current2
+      });
+    }
+    if (ambiguous)
+      return;
+    for (const supertype of supertypesOf(current2, resolver)) {
+      if (!CASE_SHAPED.has(supertype.$type))
+        continue;
+      walk(supertype, "inherited", depth + 1);
+    }
+  };
+  walk(node, "own", 0);
+  return out;
+}
+function caseResult(node, resolve8) {
+  const resolver = resolve8 ?? documentResolver(node);
+  const ambiguous = hasAmbiguousDefinition(node, resolver);
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (current2, origin, depth) => {
+    if (depth > MAX_INHERITANCE_DEPTH2 || seen.has(current2))
+      return void 0;
+    seen.add(current2);
+    const own = (current2.members ?? []).find((member) => member.$type === "ReturnDecl");
+    if (own) {
+      return {
+        declaration: own,
+        name: own.name,
+        typeName: subjectTypeName(own),
+        origin,
+        owner: current2
+      };
+    }
+    if (ambiguous)
+      return void 0;
+    for (const supertype of supertypesOf(current2, resolver)) {
+      if (!CASE_SHAPED.has(supertype.$type))
+        continue;
+      const inherited = walk(supertype, "inherited", depth + 1);
+      if (inherited)
+        return inherited;
+    }
+    return void 0;
+  };
+  return walk(node, "own", 0);
+}
+function objectiveBindingOf(objective, resolve8) {
+  if (objective.$type !== "ObjectiveDecl")
+    return void 0;
+  const caseNode = enclosingCase(objective.$container);
+  const caseKind = caseKindOf(caseNode);
+  if (!caseNode || !caseKind)
+    return void 0;
+  const resolver = resolve8 ?? documentResolver(objective);
+  const own = ownSubject(objective);
+  const bindsSubject = caseKind === "verification" || caseKind === "use-case";
+  if (bindsSubject) {
+    const subject = effectiveCaseSubject(caseNode, resolver);
+    return {
+      objective,
+      caseNode,
+      caseKind,
+      target: "case-subject",
+      strength: "bind",
+      boundTo: subject.declaration,
+      // An undecided subject names no type: the case still binds its
+      // objective to whatever its subject is, but neither hover nor
+      // `SSM046` may say what that is.
+      typeName: isDecidedSubject(subject) ? subject.typeName : void 0,
+      own
+    };
+  }
+  const result = caseResult(caseNode, resolver);
+  return {
+    objective,
+    caseNode,
+    caseKind,
+    target: "case-result",
+    strength: "default",
+    boundTo: result?.declaration,
+    typeName: result?.typeName,
+    own
+  };
+}
+function effectiveObjectiveSubject(objective, resolve8) {
+  const resolver = resolve8 ?? documentResolver(objective);
+  const binding = objectiveBindingOf(objective, resolver);
+  const own = ownSubject(objective);
+  if (!binding) {
+    return own ? { declaration: own, name: own.name, typeName: subjectTypeName(own) ?? DEFAULT_SUBJECT_TYPE, origin: "own", owner: objective } : { typeName: DEFAULT_SUBJECT_TYPE, origin: "default" };
+  }
+  if (own && binding.strength === "default") {
+    return {
+      declaration: own,
+      name: own.name,
+      typeName: subjectTypeName(own) ?? DEFAULT_SUBJECT_TYPE,
+      origin: "own",
+      owner: objective
+    };
+  }
+  return {
+    declaration: binding.boundTo,
+    typeName: binding.typeName ?? DEFAULT_SUBJECT_TYPE,
+    origin: "enclosing",
+    owner: binding.caseNode
+  };
+}
+function objectiveSubrequirements(objective, resolve8) {
+  if (objective.$type !== "ObjectiveDecl")
+    return [];
+  const resolver = resolve8 ?? documentResolver(objective);
+  const subjectTypeName2 = effectiveObjectiveSubject(objective, resolver).typeName;
+  const out = [];
+  for (const member of objective.members ?? []) {
+    if (member.$type === "VerifyStmt") {
+      const path10 = referencePathOf(member);
+      out.push({
+        declaration: member,
+        kind: "verify",
+        path: path10,
+        target: referenceTargetOf(member, resolver),
+        subjectTypeName: subjectTypeName2
+      });
+    } else if (member.$type === "RequirementDecl") {
+      out.push({ declaration: member, kind: "requirement", subjectTypeName: subjectTypeName2 });
+    }
+  }
+  return out;
+}
+function valueSimpleName(value) {
+  const node = value;
+  if (!node)
+    return void 0;
+  if (node.$type === "ParenExpr") {
+    const items = node.items ?? [];
+    return items.length === 1 ? valueSimpleName(items[0]) : void 0;
+  }
+  if (node.$type !== "PathExpr")
+    return void 0;
+  return node.path ? simpleName(node.path) : void 0;
+}
+function includeBindingOf(stmt, resolve8) {
+  if (stmt.$type !== "IncludeStmt")
+    return void 0;
+  const node = stmt;
+  const resolver = resolve8 ?? documentResolver(stmt);
+  const isUseCase = (candidate) => candidate !== void 0 && candidate.$type === "UseCaseDecl";
+  const typed = writtenTypes(node, resolver).find((type) => type.node === void 0 || isUseCase(type.node));
+  const path10 = referencePathOf(node);
+  const named2 = typed?.node ?? (typed ? void 0 : referenceTargetOf(node, resolver));
+  const target = isUseCase(named2) ? named2 : void 0;
+  const form = node.useCaseKw === true || typed !== void 0 ? "declaration" : "reference";
+  const containing = enclosingCase(node.$container);
+  const parameters = target ? effectiveActors(target, resolver) : [];
+  const actors = [];
+  for (const member of node.members ?? []) {
+    if (member.$type !== "ActorDecl")
+      continue;
+    const name = member.name;
+    actors.push({
+      declaration: member,
+      name,
+      valueName: valueSimpleName(member.value),
+      typeName: subjectTypeName(member),
+      parameter: name ? parameters.find((parameter) => parameter.name === name) : void 0
+    });
+  }
+  const containingSubject = containing ? effectiveCaseSubject(containing, resolver) : void 0;
+  const includedSubject = target ? effectiveCaseSubject(target, resolver) : void 0;
+  const subjectOrigin = isDecidedSubject(includedSubject) ? "included" : isDecidedSubject(containingSubject) ? "containing" : "default";
+  const subjectTypeName2 = subjectOrigin === "included" ? includedSubject.typeName : subjectOrigin === "containing" ? containingSubject.typeName : DEFAULT_SUBJECT_TYPE;
+  return {
+    statement: stmt,
+    form,
+    path: typed ? typed.name : path10,
+    target,
+    containing,
+    containingSubject,
+    includedSubject,
+    subjectOrigin,
+    subjectTypeName: subjectTypeName2,
+    parameters,
+    actors
+  };
+}
+
 // ../language-server/out/src/services/implicit-specialization.js
 var EXPLICIT_SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([
   ":>",
@@ -176530,11 +177224,64 @@ 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.`,
+  // REQ-415 — issue #164. `assert c`, `require c` and `assume c` all reach their
+  // constraint through the same OwnedReferenceSubsetting, so one message covers
+  // the three. The kind is named because the fix depends on it: a part or an
+  // action is not something that can be true or false.
+  SSM043_CONSTRAINT_REFERENCE_KIND: (keyword, path10, kind) => `'${keyword} ${path10}' must name a constraint, but '${path10}' is ${kind}. The '${keyword}' shorthand asserts the referenced constraint's Boolean body, so write 'assert constraint { \u2026 }' to state a condition here instead.`,
+  // REQ-415 — the reference resolves and its constraint evaluates to a definite
+  // false, so the model states something against itself. A warning, never an
+  // error: the text is well formed, and only a closed constant expression is
+  // decided at all - anything that depends on a binding stays silent.
+  SEM014_ASSERTION_VIOLATED: (text) => `Asserted constraint '${text}' evaluates to false, so this model is inconsistent as written.`,
+  // REQ-131 — a constraint is a predicate: `BooleanEvaluation` returns
+  // `Boolean[1]` (Kernel Semantic Library, `Performances.kerml`). A body that is
+  // demonstrably some other type can never be true or false. Only a body the
+  // checker can PROVE is not Boolean is reported, so an expression whose type it
+  // cannot settle stays silent.
+  SEM015_CONSTRAINT_BODY_NOT_BOOLEAN: (text, kind) => `A constraint body must be a Boolean expression, but '${text}' is ${kind}. A constraint is a predicate, so its body has to be able to come out true or false.`,
+  // REQ-209 — a usage inherits its definition's expression. Replacing it hides
+  // what the definition says while every other usage still reads the original.
+  // Advisory: the language permits the redefinition, the modelling idiom does not
+  // use it, and no model in the OMG corpus does.
+  STYL012_CONSTRAINT_BODY_OVERRIDES_DEFINITION: (usage, definition) => `'${usage}' replaces the expression it inherits from '${definition}', so the definition's expression no longer applies here. Bind the parameters instead, or give this usage its own constraint definition.`,
+  /* REQ-376 — a parameter of a constraint or a calculation is an INPUT.
+   *
+   * A constraint is a predicate: its one output is its Boolean result, which
+   * comes from the body, never from a parameter. A calculation produces its
+   * value through `return`. Neither has anything to send back out through a
+   * parameter, and the OMG corpus bears that out: 40 `in` parameters on
+   * constraints and 44 on calculations, and not one `out` or `inout` on either.
+   *
+   * A constraint is also ACAUSAL — `StraightLineDynamicsEquations` declares even
+   * the quantities it would be solved for (`x_f`, `v_f`, `a`) as `in`, because
+   * which parameter is the unknown is the binding's business, not the
+   * constraint's. Fixing a direction would bake in one solving order. */
+  STYL014_PARAMETER_DIRECTION: (parameter, direction, kind, owner) => kind === "constraint" ? `Parameter '${parameter}' is '${direction}' on constraint '${owner}'. A constraint's only output is true or false, so everything it relates is an input: declare the parameter 'in'. Which parameter is the unknown is decided where the constraint is bound.` : `Parameter '${parameter}' is '${direction}' on calculation '${owner}'. A calculation produces its value through 'return', so declare the parameter 'in' and return the result.`,
+  // REQ-376 — a directed parameter is an input to be bound by a usage, not a
+  // value slot. OMG declares parameters bare on a definition and puts values on
+  // `attribute` members (`StraightLineDynamicsEquations`).
+  STYL013_PARAMETER_DEFAULT_ON_DEFINITION: (parameter, owner) => `Parameter '${parameter}' carries a value on the definition '${owner}'. A parameter is an input a usage binds, so declare it without a value and put the value on an attribute, or bind it where the definition is used.`,
   // 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.`,
+  // issue #166 — a case usage performs ONE case (OMG SysML v2 Part 1 §7.22.2),
+  // and every effective binding this extension derives reads through that one:
+  // the subject, the actor parameters and the objective. Two definitions leave
+  // all three undecided, so the message names them and asks for one.
+  SSM045_CASE_MULTIPLE_DEFINITIONS: (name, first2, second) => `Case '${name}' names more than one case definition ('${first2}' and '${second}'). A case usage performs exactly one case, so keep one and subset the other.`,
+  // issue #166 — an `objective` written inside a verification case or a use
+  // case has its subject BOUND to the case's subject, so a `subject` of an
+  // unrelated type on the objective states something the case has already
+  // decided otherwise.
+  SSM046_OBJECTIVE_SUBJECT_TYPE: (caseName, objectiveType, subjectType) => `This objective declares a subject of type '${objectiveType}', but '${caseName}' binds its objective's subject to its own subject of type '${subjectType}'. Remove the subject or widen the case's.`,
+  // issue #166 — an `include` investigates the included use case on the
+  // including case's subject (§7.25), and an `actor` written inside the
+  // include binds one of the included use case's actor parameters.
+  SSM047_INCLUDE_SUBJECT_TYPE: (included, includedType, containerType) => `Included use case '${included}' has a subject of type '${includedType}', which does not conform to the including case's subject of type '${containerType}'. An included use case is investigated on the same subject.`,
+  SSM048_INCLUDE_ACTOR_BINDING: (actor, included, known2) => `'${actor}' is not an actor parameter of the included use case '${included}'. It declares ${known2}.`,
   // 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.
@@ -176997,7 +177744,7 @@ function nearestAncestor(node, types) {
   }
   return void 0;
 }
-function exprText2(node) {
+function exprText3(node) {
   return node?.$cstNode?.text?.trim().replace(/\s+/gu, " ") ?? "";
 }
 function conditionTypeLabel(node) {
@@ -177008,7 +177755,7 @@ function conditionTypeLabel(node) {
   if (["AndExpr", "OrExpr", "XorExpr", "NotExpr", "CompareExpr", "ClassifyOp"].includes(node.$type)) {
     return "Boolean";
   }
-  const text = exprText2(node);
+  const text = exprText3(node);
   return /\b(true|false)\b|[=!<>]=?|(?:\band\b|\bor\b|\bnot\b|\bxor\b)/u.test(text) ? "Boolean" : "Boolean (expected)";
 }
 function buildConditionalHover(node) {
@@ -177022,7 +177769,7 @@ function buildConditionalHover(node) {
     "",
     "Canonical form: `if condition ? thenExpression else elseExpression`",
     `Then marker: ${usesQuestion ? "canonical `?`" : "non-canonical `then`; use `?`"}`,
-    `Condition: \`${exprText2(n2.cond)}\``,
+    `Condition: \`${exprText3(n2.cond)}\``,
     `Condition type: ${conditionTypeLabel(n2.cond)}`,
     "",
     sourceFooter(nodeSource(node))
@@ -177194,6 +177941,8 @@ ${headerLines.join("\n")}
   const subject = subjectInheritanceSection(node);
   if (subject)
     parts.push(subject);
+  for (const section of caseBindingSections(node))
+    parts.push(section);
   if (relationshipDetails)
     parts.push(relationshipDetails);
   const flip = conjugationFlipSection(node);
@@ -177230,6 +177979,62 @@ function subjectInheritanceSection(node) {
   const ownerName = effective.owner.name ?? "(anonymous requirement)";
   return `*Subject inherited from \`${ownerName}\`:* \`${subjectText}\``;
 }
+var CASE_KIND_LABELS = {
+  "case": "Case",
+  "analysis": "Analysis case",
+  "verification": "Verification case",
+  "use-case": "Use case"
+};
+function caseBindingSections(node) {
+  const out = [];
+  const kind = caseKindOf(node);
+  if (kind) {
+    const effective = effectiveCaseDefinition(node);
+    if (effective && !effective.isDefinition && effective.sole) {
+      out.push(`*${CASE_KIND_LABELS[kind]} performs:* \`${effective.sole.name}\``);
+    }
+    const subject = effectiveCaseSubject(node);
+    if (subject.origin === "inherited") {
+      const owner = subject.owner?.name;
+      out.push(`*Subject inherited${owner ? ` from \`${owner}\`` : ""}:* \`${subject.name ?? "subject"} : ${subject.typeName}\``);
+    } else if (subject.origin === "default") {
+      out.push("*Subject:* none declared, so this case investigates `Anything`.");
+    }
+    const inherited = effectiveActors(node).filter((actor) => actor.origin === "inherited");
+    if (inherited.length > 0) {
+      const list = inherited.map((actor) => `\`${actor.name ?? "actor"}${actor.typeName ? ` : ${actor.typeName}` : ""}\``).join(", ");
+      out.push(`*Actors inherited:* ${list}`);
+    }
+  }
+  if (node.$type === "ObjectiveDecl") {
+    const binding = objectiveBindingOf(node);
+    if (binding) {
+      const what = binding.target === "case-subject" ? "subject" : "result";
+      const verb = binding.strength === "bind" ? "is bound to" : "defaults to";
+      const type = binding.typeName ? ` (\`${binding.typeName}\`)` : "";
+      const caseName = binding.caseNode.name;
+      out.push(`*Objective subject ${verb}* the ${what} of ${caseName ? `\`${caseName}\`` : "the enclosing case"}${type}.`);
+    }
+    const subrequirements = objectiveSubrequirements(node);
+    if (subrequirements.length > 0) {
+      const list = subrequirements.map((sub) => `\`${sub.path ?? sub.declaration.name ?? "requirement"}\``).join(", ");
+      out.push(`*Required subrequirements:* ${list} \u2014 each is checked on this objective's subject.`);
+    }
+  }
+  if (node.$type === "IncludeStmt") {
+    const binding = includeBindingOf(node);
+    if (binding?.target) {
+      const name = binding.path ? `\`${binding.path}\`` : "the included use case";
+      out.push(`*Includes:* ${name}, a reference to a use case performed elsewhere. It keeps its own identity and is not copied here.`);
+      if (binding.subjectOrigin === "containing") {
+        out.push(`*Investigated on:* the including case's subject (\`${binding.subjectTypeName}\`).`);
+      } else if (binding.subjectOrigin === "included") {
+        out.push(`*Investigated on:* its own subject (\`${binding.subjectTypeName}\`).`);
+      }
+    }
+  }
+  return out;
+}
 function flipDirection(direction) {
   return direction === "in" ? "out" : direction === "out" ? "in" : direction;
 }
@@ -178204,6 +179009,13 @@ var TYPE_CONTEXTS = {
   calc: ["CalcDecl", "FunctionDecl"],
   constraint: ["ConstraintDecl", "PredicateDecl"]
 };
+var CONSTRAINT_REFERENCE_TYPES = [
+  "ConstraintDecl",
+  "InvShorthand",
+  "PredicateDecl",
+  "RequirementDecl",
+  "ConcernDecl"
+];
 var ALL_DEFINITION_TYPES = [
   "PartDecl",
   "PortDecl",
@@ -178389,6 +179201,10 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
       allowedLabels.add("requirement");
       allowedLabels.add("by");
     }
+    if (context.kind === "constraint-reference") {
+      allowedLabels.add("constraint");
+      allowedLabels.add("not");
+    }
     if (context.kind === "specialization") {
       allowedLabels.add("specializes");
       allowedLabels.add("subsets");
@@ -178463,6 +179279,14 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
         addUnique(items, this.visibleSymbolItems(["RequirementDecl"], { document: document2, offset: offset2 }));
         return;
       }
+      // REQ-415 — a reference shorthand names a CONSTRAINT, so the slot
+      // offers constraint usages and definitions rather than every symbol.
+      // A requirement and a concern are constraints too (OMG SysML v2
+      // Part 1 §7.20.2, §7.21.2), so both belong in the list.
+      case "constraint-reference": {
+        addUnique(items, this.visibleSymbolItems(CONSTRAINT_REFERENCE_TYPES, { document: document2, offset: offset2 }));
+        return;
+      }
       case "connect": {
         addUnique(items, this.connectPortItems(document2, offset2));
         return;
@@ -178484,6 +179308,8 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
   symbolTypesForContext(context) {
     if (context.kind === "verify" || context.kind === "satisfy")
       return ["RequirementDecl"];
+    if (context.kind === "constraint-reference")
+      return CONSTRAINT_REFERENCE_TYPES;
     const keyword = context.typingKeyword;
     if (!keyword)
       return ALL_DEFINITION_TYPES;
@@ -178687,6 +179513,9 @@ function detectCompletionContext(text, offset2) {
   if (/\bconnect\s+(?:[\p{L}_:'.]+(?:\.[\p{L}_:']+)*\s+to\s*)?[\p{L}_:'.]*$/u.test(statement)) {
     return { kind: "connect", statement };
   }
+  if (/\b(?:assert|require|assume)\s+(?:not\s+)?[\p{L}_:'.]*$/u.test(statement)) {
+    return { kind: "constraint-reference", statement };
+  }
   if (/(?:^|[^\w:])(?::>|:>>|specializes|subsets|redefines)\s*~?[\p{L}_:'.]*$/u.test(statement)) {
     return { kind: "specialization", statement, typingKeyword: keyword };
   }
@@ -180197,6 +181026,60 @@ var CONSTRAINT_SIDE_EFFECT_TYPES = /* @__PURE__ */ new Set([
   "DoAction",
   "ExitAction"
 ]);
+var BOOLEAN_OPERATORS = /* @__PURE__ */ new Set([
+  "or",
+  "|",
+  "implies",
+  "xor",
+  "and",
+  "&",
+  ">=",
+  "<=",
+  "===",
+  "!==",
+  "==",
+  "!=",
+  ">",
+  "<",
+  "hastype",
+  "istype",
+  "@",
+  "@@"
+]);
+var ARITHMETIC_OPERATORS = /* @__PURE__ */ new Set(["+", "-", "*", "/", "%", "**", "^", ".."]);
+function nonBooleanExpressionKind(expr) {
+  const node = expr;
+  switch (expr.$type) {
+    case "NumericPrimary":
+      return node.unit ? "a quantity" : "a number";
+    case "LiteralStr":
+      return "a string";
+    case "UnaryMinusExpr":
+    case "UnaryPlusExpr":
+      return "a number";
+    case "ParenExpr": {
+      const items = Array.isArray(node.items) ? node.items : [];
+      return items.length === 1 ? nonBooleanExpressionKind(items[0]) : void 0;
+    }
+    case "BinExpr": {
+      const op = typeof node.op === "string" ? node.op : void 0;
+      if (op && BOOLEAN_OPERATORS.has(op))
+        return void 0;
+      if (op && ARITHMETIC_OPERATORS.has(op)) {
+        return op === ".." ? "a range" : "an arithmetic expression";
+      }
+      return void 0;
+    }
+    default:
+      return void 0;
+  }
+}
+function directionOfModifiers(node) {
+  const modifiers2 = node.modifiers;
+  if (!Array.isArray(modifiers2))
+    return void 0;
+  return modifiers2.find((modifier) => modifier === "in" || modifier === "out" || modifier === "inout");
+}
 var ACTION_BODY_TYPES = /* @__PURE__ */ new Set([
   "ActionDecl",
   "PerformStmt",
@@ -180497,7 +181380,122 @@ var SysmlValidator = class _SysmlValidator {
         accept(severity("SEM010", "warning"), `Constraint '${node.name ?? "(anonymous)"}' must be a pure Boolean expression - '${member.$type}' is a statement with side effects and is not allowed in a constraint body.`, { node: member, code: "SEM010" });
       }
     }
+    const notBoolean = node.body ? nonBooleanExpressionKind(node.body) : void 0;
+    if (node.body?.$cstNode && notBoolean) {
+      accept(severity("SEM015", "error"), DIAGNOSTIC_MESSAGES.SEM015_CONSTRAINT_BODY_NOT_BOOLEAN(node.body.$cstNode.text.replace(/\s+/g, " ").trim(), notBoolean), { node, property: "body", code: "SEM015" });
+    }
+    if (!node.isDef && node.body) {
+      const definition = this.constraintTypeOf(node);
+      if (definition?.body && definition.name) {
+        accept(severity("STYL012", "hint"), DIAGNOSTIC_MESSAGES.STYL012_CONSTRAINT_BODY_OVERRIDES_DEFINITION(node.name ?? "(anonymous)", definition.name), { node, property: "body", code: "STYL012" });
+      }
+    }
+  }
+  /** REQ-209 — the constraint definition a usage is typed by, when the link
+   *  resolved. Only a direct typing is followed: a deeper specialization chain
+   *  is not what "replaces its definition's expression" is about. */
+  constraintTypeOf(node) {
+    const target = node.typing?.type?.ref;
+    return target?.$type === "ConstraintDecl" ? target : void 0;
+  }
+  /* REQ-376 (user direction 2026-09-07) — STYL014: a parameter of a constraint
+   * or a calculation is an INPUT. A constraint's one output is its Boolean
+   * result and a calculation's is its `return`; neither sends anything back
+   * through a parameter, and no model in the OMG corpus declares one `out` or
+   * `inout`.
+   *
+   * Reported where the parameter is DECLARED: on a definition, and on a usage
+   * that declares its own (an untyped `constraint c { out x : T; … }`). A TYPED
+   * usage inherits its parameters, so a direction written there is a
+   * redefinition of one, and `SSM025` already reports that as an error - saying
+   * it twice, once as an error and once as an advisory, helps nobody. */
+  checkParameterDirection(node, accept) {
+    const decl = node;
+    const typed = node.typing?.type?.ref;
+    if (decl.isDef !== true && typed)
+      return;
+    const kind = node.$type === "ConstraintDecl" ? "constraint" : "calculation";
+    const owner = typeof decl.name === "string" && decl.name ? decl.name : "(anonymous)";
+    for (const member of decl.members ?? []) {
+      const direction = directionOfModifiers(member);
+      if (direction !== "out" && direction !== "inout")
+        continue;
+      const name = member.name;
+      if (typeof name !== "string" || !name)
+        continue;
+      accept(severity("STYL014", "hint"), DIAGNOSTIC_MESSAGES.STYL014_PARAMETER_DIRECTION(name, direction, kind, owner), { node: member, code: "STYL014" });
+    }
   }
+  // REQ-376 — STYL013: a directed parameter is an input a usage binds, not a
+  // value slot. OMG declares them bare on a definition and puts values on
+  // `attribute` members. Only a DEFINITION is flagged: `in x = expr;` on a usage
+  // is the canonical binding form.
+  checkParameterDefaultOnDefinition(node, accept) {
+    const decl = node;
+    if (decl.isDef !== true || typeof decl.name !== "string" || !decl.name)
+      return;
+    for (const member of decl.members ?? []) {
+      const name = member.name;
+      const value = member.value;
+      if (!value || typeof name !== "string" || !name)
+        continue;
+      if (directionOfModifiers(member) === void 0)
+        continue;
+      accept(severity("STYL013", "hint"), DIAGNOSTIC_MESSAGES.STYL013_PARAMETER_DEFAULT_ON_DEFINITION(name, decl.name), { node: member, code: "STYL013" });
+    }
+  }
+  // REQ-415 — issue #164. `assert c;`, `assert not c;`, `require c;` and
+  // `assume c;` name a constraint declared elsewhere (OMG SysML v2 Part 1
+  // §7.20.3, §7.21.2). Three things can go wrong with that name, and all three
+  // were silent: it may resolve to nothing, it may resolve to something that is
+  // not a constraint, and the constraint it resolves to may be decidably false.
+  //
+  // The ROOT link is judged here rather than in `checkWrittenPaths`, which
+  // deliberately leaves a root alone: a root is reported absent only when the
+  // resolver could enumerate the whole surrounding inventory, and that is
+  // exactly the guarantee `unresolvedIndex === 0` carries. It is the same rule
+  // `checkRelationshipTargets` applies to a redefinition target.
+  checkConstraintReference(node, accept) {
+    const reference = constraintReferenceOf(node);
+    if (!reference)
+      return;
+    const resolution = reference.property ? this.featurePaths.resolvePropertyPath(node, reference.property) : this.featurePaths.resolveDeclarationPath(node);
+    if (resolution.segments.length === 0)
+      return;
+    if (resolution.unresolvedIndex === 0) {
+      const invalid = resolution.segments[0];
+      accept(severity("RES001", "error"), DIAGNOSTIC_MESSAGES.RES001_FEATURE_PATH_SEGMENT(invalid.text, "the current scope"), { node, range: invalid.cst.range, code: "RES001", data: { featurePathSegment: true } });
+      return;
+    }
+    if (resolution.unresolvedIndex !== void 0 || resolution.indeterminateIndex !== void 0)
+      return;
+    const last2 = resolution.segments[resolution.segments.length - 1];
+    const target = last2.target;
+    if (target && isWrongKindConstraintTarget(target)) {
+      accept(severity("SSM043", "error"), DIAGNOSTIC_MESSAGES.SSM043_CONSTRAINT_REFERENCE_KIND(reference.kind, reference.path, wrongKindLabel(target)), { node, range: last2.cst.range, code: "SSM043" });
+    }
+  }
+  // REQ-415 — SEM014. An assertion the model can DECIDE and that comes out
+  // false is an inconsistency the author wrote against themselves. Only a
+  // closed constant expression is decided: every feature reference is
+  // inconclusive here, so an assertion that depends on a binding, on time, or
+  // on anything this evaluator does not model stays silent rather than passing
+  // quietly or being reported on a guess.
+  checkAssertionConsistency(node, accept) {
+    if (node.$type !== "AssertConstraintStmt")
+      return;
+    const result = evaluateAssertion(node, this.constraintResolver);
+    if (result?.status !== "fail")
+      return;
+    accept(severity("SEM014", "warning"), DIAGNOSTIC_MESSAGES.SEM014_ASSERTION_VIOLATED(result.text), { node, code: "SEM014" });
+  }
+  // REQ-415 — Resolve a reference shorthand through the shared path resolver,
+  // so a target in another file or in the standard library is evaluated exactly
+  // as a same-file one is.
+  constraintResolver = (reference, member) => {
+    const resolution = reference.property ? this.featurePaths.resolvePropertyPath(member, reference.property) : this.featurePaths.resolveDeclarationPath(member);
+    return resolution.segments[resolution.segments.length - 1]?.target;
+  };
   // REQ-410 — SEM013. A `ref` feature is NON-composite: it names a feature that
   // is owned somewhere else. An unbound one therefore names nothing at all, and
   // the General View cannot draw it as anything: a box would claim the owner
@@ -181996,6 +182994,7 @@ ${baseIndent}}`;
     const decls = [];
     const verifyStmts = [];
     const satisfyStmts = [];
+    const includeStmts = [];
     const aliasMap = /* @__PURE__ */ new Map();
     for (const child of ast_utils_exports.streamAllContents(node)) {
       if (isImport(child)) {
@@ -182019,6 +183018,8 @@ ${baseIndent}}`;
         if (a2.name && a2.target)
           aliasMap.set(a2.name, a2.target);
       }
+      if (child.$type === "IncludeStmt")
+        includeStmts.push(child);
     }
     this.checkAmbiguousReferences(node, imports, index2, accept);
     this.checkPrivateImports(imports, index2, accept);
@@ -182054,7 +183055,7 @@ ${baseIndent}}`;
       this.checkInverseOfTargets(decl, index2, accept);
       this.checkTypeComposition(decl, index2, accept);
     }
-    this.checkTypeConformance(decls, satisfyStmts, index2, accept);
+    this.checkTypeConformance(decls, satisfyStmts, includeStmts, index2, accept);
   }
   // ══════════════════════════════════════════════════════════════════════
   // REQ-390 — SSM017-SSM021: whole-model type conformance (issue #104)
@@ -182064,7 +183065,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, satisfyStmts, index2, accept) {
+  checkTypeConformance(decls, satisfyStmts, includeStmts, 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);
@@ -182079,9 +183080,78 @@ ${baseIndent}}`;
       this.checkRedefinitionDirection(decl, index2, accept);
       this.checkInterfaceEndTypes(decl, model, index2, accept);
       this.checkIndividualDefinitions(decl, model, accept);
+      this.checkCaseDefinitionCount(decl, index2, accept);
+      this.checkObjectiveSubject(decl, model, index2, accept);
     }
     for (const stmt of satisfyStmts)
       this.checkSatisfierSubjectType(stmt, model, index2, accept);
+    for (const stmt of includeStmts)
+      this.checkIncludeBindings(stmt, model, index2, accept);
+  }
+  // ══════════════════════════════════════════════════════════════════════
+  // REQ-417 — SSM045-SSM048: the bindings a case makes (issue #166)
+  // ══════════════════════════════════════════════════════════════════════
+  // SSM045 — OMG SysML v2 Part 1 §7.22.2: a CaseUsage has exactly one
+  // CaseDefinition. Everything this extension derives about a case usage reads
+  // through that one — its subject, its actor parameters, its objective — so
+  // two leave all three undecided rather than merged. A type this validator
+  // could not read is NOT counted: an unread type is not a wrong one, the same
+  // three-valued rule the rest of this family follows.
+  checkCaseDefinitionCount(decl, index2, accept) {
+    const effective = effectiveCaseDefinition(decl, (name) => this.resolveUnique(name, index2));
+    if (!effective || effective.isDefinition)
+      return;
+    const read = effective.definitions.filter((type) => type.node !== void 0);
+    if (read.length < 2)
+      return;
+    accept(severity("SSM045", "error"), DIAGNOSTIC_MESSAGES.SSM045_CASE_MULTIPLE_DEFINITIONS(decl.name ?? "this case", read[0].name, read[1].name), { node: decl, code: "SSM045" });
+  }
+  // SSM046 — a `verification case` and a `use case` BIND their objective's
+  // subject to their own (`objective obj { subject subj = VerificationCase::subj; }`
+  // in `VerificationCases.sysml`), so a `subject` written on the objective with
+  // an unrelated type states something the case has already decided otherwise.
+  // A generic `case` and an `analysis case` only DEFAULT the objective's subject
+  // to their result, which the model may override, so neither is judged here.
+  checkObjectiveSubject(decl, model, index2, accept) {
+    if (decl.$type !== "ObjectiveDecl")
+      return;
+    const binding = objectiveBindingOf(decl, (name) => this.resolveUnique(name, index2));
+    if (!binding || binding.strength !== "bind" || !binding.own)
+      return;
+    const written = binding.own.typing?.type?.$refText?.trim();
+    if (!written)
+      return;
+    const bound = binding.typeName;
+    if (!bound || bound === DEFAULT_SUBJECT_TYPE)
+      return;
+    if (model.compatible(written, bound) !== "unrelated")
+      return;
+    const caseName = binding.caseNode.name ?? "this case";
+    accept(severity("SSM046", "warning"), DIAGNOSTIC_MESSAGES.SSM046_OBJECTIVE_SUBJECT_TYPE(caseName, written, bound), { node: binding.own, code: "SSM046" });
+  }
+  // SSM047 / SSM048 — OMG SysML v2 Part 1 §7.25 / §8.2.2.25 IncludeUseCaseUsage.
+  // An include is a REFERENCE to a use case performed elsewhere: it keeps that
+  // use case's identity, is investigated on the including case's subject, and
+  // binds that use case's own actor parameters. Both checks stay silent unless
+  // the included use case was actually read.
+  checkIncludeBindings(stmt, model, index2, accept) {
+    const binding = includeBindingOf(stmt, (name) => this.resolveUnique(name, index2));
+    if (!binding?.target)
+      return;
+    const included = binding.path ?? "the included use case";
+    const includedSubject = binding.includedSubject;
+    const containingSubject = binding.containingSubject;
+    if (isDecidedSubject(includedSubject) && isDecidedSubject(containingSubject) && model.compatible(includedSubject.typeName, containingSubject.typeName) === "unrelated") {
+      accept(severity("SSM047", "warning"), DIAGNOSTIC_MESSAGES.SSM047_INCLUDE_SUBJECT_TYPE(included, includedSubject.typeName, containingSubject.typeName), { node: stmt, code: "SSM047" });
+    }
+    if (binding.parameters.length === 0)
+      return;
+    const known2 = binding.parameters.map((parameter) => `'${parameter.name ?? "(anonymous)"}'`).join(", ");
+    for (const actor of binding.actors) {
+      if (!actor.name || actor.parameter)
+        continue;
+      accept(severity("SSM048", "warning"), DIAGNOSTIC_MESSAGES.SSM048_INCLUDE_ACTOR_BINDING(actor.name, included, known2), { node: actor.declaration, code: "SSM048" });
+    }
   }
   // 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
@@ -183346,7 +184416,16 @@ ${baseIndent}}`;
       // issue #215 — the rest of the reference-form declarations. They share
       // `ReferenceFormPath` with `perform`/`exhibit`, so they can spell the
       // same defect and are judged by the same rule.
-      AssertConstraintStmt: this.checkChainSeparators.bind(this),
+      // REQ-415 — issue #164: the constraint reference shorthands. `assert`
+      // shares its `ReferenceFormPath` with the other reference forms, so it
+      // also carries the RES019 separator rule above.
+      AssertConstraintStmt: [
+        this.checkChainSeparators.bind(this),
+        this.checkConstraintReference.bind(this),
+        this.checkAssertionConsistency.bind(this)
+      ],
+      RequireConstraintStmt: this.checkConstraintReference.bind(this),
+      AssumeConstraintStmt: this.checkConstraintReference.bind(this),
       EntryAction: this.checkChainSeparators.bind(this),
       DoAction: this.checkChainSeparators.bind(this),
       ExitAction: this.checkChainSeparators.bind(this),
@@ -183354,7 +184433,17 @@ ${baseIndent}}`;
       ConnectorEnd: this.checkConnectorEndSeparators.bind(this),
       RequirementDecl: this.checkRequirementDecl.bind(this),
       AttributeDecl: this.checkAttributeDecl.bind(this),
-      ConstraintDecl: this.checkConstraintDecl.bind(this),
+      // REQ-376 — STYL013 applies to both behavioral definitions that take
+      // parameters, so the constraint check runs beside it here.
+      ConstraintDecl: [
+        this.checkConstraintDecl.bind(this),
+        this.checkParameterDefaultOnDefinition.bind(this),
+        this.checkParameterDirection.bind(this)
+      ],
+      CalcDecl: [
+        this.checkParameterDefaultOnDefinition.bind(this),
+        this.checkParameterDirection.bind(this)
+      ],
       VerificationCaseDecl: this.checkVerificationCaseDecl.bind(this),
       AnalysisCaseDecl: this.checkAnalysisCaseDecl.bind(this),
       ViewDecl: this.checkViewDecl.bind(this),
@@ -184077,6 +185166,9 @@ var STYLE_ADVISORY_CODES = /* @__PURE__ */ new Set([
   "STYL009",
   "STYL010",
   "STYL011",
+  "STYL012",
+  "STYL013",
+  "STYL014",
   "LEX009",
   // trailing whitespace
   "SYN024",
@@ -184399,6 +185491,8 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
         break;
       if (node.$type === "ShortName" || node.$type === "ImportSeg")
         continue;
+      if (isReferenceFormDeclaration(node))
+        continue;
       const aliases = this.nameAliasesOf(node);
       if (aliases.length === 0)
         continue;
@@ -190059,7 +191153,9 @@ function nodeSize(node, direction) {
   const portRunHeight = connectionUsage ? portRows ? portRows * 18 + 6 : 0 : portRows ? compactContainer ? portRows * 24 + 8 : 40 + portRows * 24 + 8 : 0;
   const bodyH = Math.max(
     connectionUsage ? 42 : BOX_H,
-    node.value !== void 0 ? 88 : 0,
+    // REQ-209/375 - The value field sits at the bottom of the card, under
+    // whatever compartments it carries, so both have to fit.
+    node.value !== void 0 ? Math.max(88, NODE_COMPARTMENT_TOP + compartmentHeight(node) + 36) : 0,
     featureH === 0 ? NODE_COMPARTMENT_TOP + compartmentHeight(node) : 0,
     portRunHeight,
     portedSideLength(ph, "left"),
@@ -190730,7 +191826,7 @@ function collapseIvModel(model, hiddenInternals) {
   const frames = model.frames ?? [];
   if (!frames.length) return model;
   const frameById = new Map(frames.map((f) => [f.id, f]));
-  const requested = new Set(frames.filter((frame2) => framePresentationEnabled(hiddenInternals, frame2, true) && isCollapsibleFrame("iv", frame2)).map((frame2) => frame2.id));
+  const requested = new Set(frames.filter((frame2) => (frame2.meta?.internalsExpandable === false || framePresentationEnabled(hiddenInternals, frame2, true)) && isCollapsibleFrame("iv", frame2)).map((frame2) => frame2.id));
   if (requested.size === 0) return model;
   const hasRequestedAncestor = (id2) => {
     let p = frameById.get(id2)?.parent;
@@ -190793,12 +191889,11 @@ function collapseIvModel(model, hiddenInternals) {
     const toRoot = containerRootOf(e.to);
     if (fromRoot !== void 0 && fromRoot === toRoot) return false;
     return !(hidden.has(e.from) && fromRoot === void 0) && !(hidden.has(e.to) && toRoot === void 0);
-  }).map((e) => {
+  }).filter((e) => e.from === e.to || (bodyDock.get(e.from) ?? e.from) !== (bodyDock.get(e.to) ?? e.to)).map((e) => {
     const from = bodyDock.get(e.from) ?? e.from;
     const to = bodyDock.get(e.to) ?? e.to;
     return from === e.from && to === e.to ? e : { ...e, from, to };
   }).filter((e) => {
-    if (e.from === e.to) return false;
     const key2 = `${e.from}\0${e.to}\0${e.kind}\0${e.label ?? ""}`;
     if (seenEdge.has(`${key2}:${e.id}`)) return false;
     seenEdge.add(`${key2}:${e.id}`);
@@ -190876,17 +191971,30 @@ function isFeatureCompartmentNode(kind, node) {
   if (kind === "stv") return node.shape === "state";
   return false;
 }
+function graphicalChildOwners(model) {
+  const owners = /* @__PURE__ */ new Set();
+  for (const node of model.nodes) {
+    const owner = node.frame ?? node.parent;
+    if (owner && owner !== node.id) owners.add(owner);
+  }
+  for (const frame2 of model.frames ?? []) {
+    if (frame2.parent && frame2.parent !== frame2.id) owners.add(frame2.parent);
+  }
+  return owners;
+}
 function applyFeatureCompartmentVisibility(model, visibleFeatureCompartments, hiddenInternals = {}) {
   if (!CONTAINER_PRESENTATION_KINDS.has(model.kind)) return model;
   const legacy = model.kind === "iv";
+  const owners = graphicalChildOwners(model);
   let changed = false;
   const project = (host, leaf) => {
+    const internalsExpandable = owners.has(host.id);
     const alwaysVisible = host.meta?.alwaysVisibleCompartments === true;
     const defaultVisible = leaf || model.kind === "afv" && !leaf;
     const visible = alwaysVisible || framePresentationEnabled(visibleFeatureCompartments, host, legacy, defaultVisible);
     const compartments = visible ? host.compartments : void 0;
     const internalsHidden = leaf ? framePresentationEnabled(hiddenInternals, host, legacy) : host.meta?.internalsHidden === true;
-    if (compartments === host.compartments && host.meta?.containerControls === true && host.meta?.featureCompartmentsVisible === visible && (!leaf || host.meta?.internalsHidden === internalsHidden)) return host;
+    if (compartments === host.compartments && host.meta?.containerControls === true && host.meta?.internalsExpandable === internalsExpandable && host.meta?.featureCompartmentsVisible === visible && (!leaf || host.meta?.internalsHidden === internalsHidden)) return host;
     changed = true;
     return {
       ...host,
@@ -190894,6 +192002,7 @@ function applyFeatureCompartmentVisibility(model, visibleFeatureCompartments, hi
       meta: {
         ...host.meta,
         containerControls: true,
+        internalsExpandable,
         featureCompartmentsVisible: visible,
         ...leaf ? { internalsHidden } : {}
       }
@@ -190909,10 +192018,10 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
   if (!frames.length) return model;
   const frameById = new Map(frames.map((f) => [f.id, f]));
   const requested = new Set(
-    frames.filter((f) => framePresentationEnabled(hiddenInternals, f) && isHost(f)).map((f) => f.id)
+    frames.filter((f) => (f.meta?.internalsExpandable === false || framePresentationEnabled(hiddenInternals, f)) && isHost(f)).map((f) => f.id)
   );
   if (requested.size === 0) return model;
-  const rootOf2 = (id2) => {
+  const rootOf3 = (id2) => {
     let root4;
     const seen = /* @__PURE__ */ new Set();
     for (let cur = id2; cur !== void 0 && !seen.has(cur); cur = frameById.get(cur)?.parent) {
@@ -190921,13 +192030,13 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
     }
     return root4;
   };
-  const roots = new Set([...requested].filter((id2) => rootOf2(frameById.get(id2)?.parent) === void 0));
+  const roots = new Set([...requested].filter((id2) => rootOf3(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) ? rootOf2(f.parent) : rootOf2(f.id);
+    const root4 = roots.has(f.id) ? rootOf3(f.parent) : rootOf3(f.id);
     if (root4 === void 0) continue;
     hiddenFrameIds.add(f.id);
     dockOf.set(f.id, root4);
@@ -190938,7 +192047,7 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
   }
   const hiddenNodeIds = /* @__PURE__ */ new Set();
   for (const n2 of model.nodes) {
-    const root4 = rootOf2(n2.frame);
+    const root4 = rootOf3(n2.frame);
     if (root4 === void 0) continue;
     hiddenNodeIds.add(n2.id);
     dockOf.set(n2.id, root4);
@@ -190967,12 +192076,11 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
   const edges = model.edges.filter((e) => {
     const fromRoot = containerRootOf(e.from);
     return fromRoot === void 0 || fromRoot !== containerRootOf(e.to);
-  }).map((e) => {
+  }).filter((e) => e.from === e.to || (dockOf.get(e.from) ?? e.from) !== (dockOf.get(e.to) ?? e.to)).map((e) => {
     const from = dockOf.get(e.from) ?? e.from;
     const to = dockOf.get(e.to) ?? e.to;
     return from === e.from && to === e.to ? e : { ...e, from, to };
   }).filter((e) => {
-    if (e.from === e.to) return false;
     const key2 = `${e.from}\0${e.to}\0${e.kind}\0${e.label ?? ""}`;
     if (seenEdge.has(`${key2}:${e.id}`)) return false;
     seenEdge.add(`${key2}:${e.id}`);
@@ -205385,6 +206493,10 @@ function markersFor(kind) {
     // REQ-199
     case "derive":
     // REQ-188
+    case "assert":
+    // REQ-131/REQ-415 — the constraint claims
+    case "assume":
+    case "require":
     case "causation":
     // REQ-189
     case "import":
@@ -205761,7 +206873,7 @@ var KIN_MARKER_DEFS_SVG = [
 
 // ../extension/src/webview/diagram/element-colors.ts
 var ELEMENT_CLOSED_OPACITY = 1;
-var ELEMENT_OPEN_OPACITY = 0.2;
+var ELEMENT_OPEN_OPACITY = 0.3;
 var DIAGRAM_ELEMENT_COLORS = {
   default: {
     outline: { light: "#3a3a3a", dark: "#a1a1a1" },
@@ -205894,7 +207006,22 @@ var DIAGRAM_LINE_COLORS = {
   },
   dependency: {
     color: { light: "#6b46c1", dark: "#b08cf0" },
-    kinds: ["satisfy", "verify", "include", "dependency", "allocate", "frame", "derive", "causation", "import", "expose"],
+    kinds: [
+      "satisfy",
+      "verify",
+      "include",
+      "dependency",
+      "allocate",
+      "frame",
+      "derive",
+      "causation",
+      "import",
+      "expose",
+      // REQ-131/REQ-415 — the constraint claims read as the same family.
+      "assert",
+      "assume",
+      "require"
+    ],
     colorLabels: true
   },
   binding: {
@@ -206321,6 +207448,8 @@ body {
 .dlink.satisfy, .dlink.verify, .dlink.include, .dlink.dependency { stroke-dasharray: 4 3; }
 /* REQ-186/188/189/199/206/210 \u2014 the dashed labelled families */
 .dlink.allocate, .dlink.frame, .dlink.derive, .dlink.causation, .dlink.import, .dlink.expose { stroke-dasharray: 4 3; }
+/* REQ-131/REQ-415 \u2014 the three constraint claims */
+.dlink.assert, .dlink.assume, .dlink.require { stroke-dasharray: 4 3; }
 .dlink.annotation { stroke-dasharray: 2 3; }
 .dlink.elaboration { stroke-dasharray: 2 3; pointer-events: none; }
 .dlink.reply { stroke-dasharray: 4 3; } /* REQ-202 \u2014 sequence reply arrows */
@@ -207812,7 +208941,15 @@ var TOOLBOX = {
       rel("verify", "verify", "\u2713", "click the verification case, then the requirement"),
       rel("frame", "frame", "\u274F", "click the requirement/view, then the framed concern"),
       rel("exhibit", "exhibit", "\u25C9", "click the part, then the exhibited state"),
-      rel("perform", "perform", "\u25B7", "click the part, then the performed action")
+      rel("perform", "perform", "\u25B7", "click the part, then the performed action"),
+      // REQ-131/REQ-415 (user direction 2026-09-08 — "how do we add assert
+      // constraint from the diagram") — the three constraint CLAIMS. The
+      // diagram drew them in its compartments but could not create one, so
+      // `assert constraint …` could only be typed. Each writes into the
+      // claiming element, exactly as satisfy/verify/frame do.
+      rel("assert", "assert", "\u22A8", "click the element that asserts, then the constraint"),
+      rel("assume", "assume", "\u2283", "click the requirement/concern, then the assumed constraint"),
+      rel("require", "require", "\u22A2", "click the requirement/concern, then the required constraint")
     ]
   },
   // The Interconnection View depicts parts, ports, and the compartment rows of
@@ -207843,7 +208980,12 @@ var TOOLBOX = {
       rel("flow", "flow", "\u2192", "click the source port/feature, then the target"),
       // issue #115 — an item flow that also sequences its ends.
       rel("successionFlow", "succession flow", "\u21C9", "click the source port/feature, then the target"),
-      rel("allocate", "allocate", "\u290F", "click the source part/feature, then the target")
+      rel("allocate", "allocate", "\u290F", "click the source part/feature, then the target"),
+      // REQ-131 — the view draws a part's constraints, and OMG's own
+      // parametric picture is a part asserting one and binding its
+      // parameters (ConstraintTest.sysml). `bind` was already here; the
+      // claim that gives it something to bind was not.
+      rel("assert", "assert", "\u22A8", "click the part, then the constraint it asserts")
     ]
   },
   // Action Flow depicts actions (a new `action def` becomes its own tile in a
@@ -208025,7 +209167,10 @@ var CHILD_KINDS = {
   "event occurrence": [],
   requirement: ["requirement", "constraint", "attribute", "part", "actor"],
   concern: ["requirement", "constraint", "attribute", "actor"],
-  constraint: ["attribute", "constraint"],
+  // REQ-376 — a constraint and a calculation take INPUTS, and there was no way
+  // to add one from the diagram. Only `in`: an `out` or `inout` parameter on
+  // either is STYL014, so offering one would contradict the check.
+  constraint: ["in parameter", "attribute", "constraint"],
   "use case": CASE_CHILDREN,
   "analysis case": CASE_CHILDREN,
   "verification case": CASE_CHILDREN,
@@ -208037,7 +209182,7 @@ var CHILD_KINDS = {
   // issue (GRV on enum def): an enum def owns enumeration VALUES — nested enum
   // usages — never requirements/parts; the old fallback offered the view list.
   enum: ["enum"],
-  calc: ["attribute", "calc"],
+  calc: ["in parameter", "attribute", "calc"],
   connection: ["attribute", "item", "part"],
   connector: ["attribute", "item", "part"],
   interface: ["port", "attribute", "item"],
@@ -208052,6 +209197,10 @@ var CHILD_KINDS = {
   control: [],
   terminate: [],
   pin: [],
+  // REQ-376 — the banner of a constraint/calc parameter card.
+  "in parameter": [],
+  "out parameter": [],
+  "inout parameter": [],
   // REQ-196 — a «performer» swimlane (OMG SysML v2 Part 1 §8.2.3.17, p.90). Its
   // members are the actions that part performs; the edit writes the action into
   // the OWNING action's body and a `perform` for it into the part.
@@ -208164,12 +209313,33 @@ function relationToolsForNode(keyword, viewKind, shape) {
         case "exhibit":
         case "perform":
           return base === "part";
+        // REQ-131 — the OMG corpus asserts inside a part or a package
+        // (ConstraintTest.sysml, MassConstraintExample.sysml); a case and
+        // a requirement own constraints of their own.
+        case "assert":
+          return [
+            "part",
+            "item",
+            "package",
+            "requirement",
+            "concern",
+            "use case",
+            "analysis case",
+            "verification case",
+            "case"
+          ].includes(base);
+        // REQ-131 — OMG SysML 8.2.2.21.1: a RequirementConstraintMembership
+        // belongs to a requirement or a concern.
+        case "assume":
+        case "require":
+          return ["requirement", "concern"].includes(base);
         default:
           return true;
       }
     }
     if (viewKind === "iv") {
       if (!["part", "port", "attribute", "item", "connection"].includes(base)) return false;
+      if (tool.kind === "assert") return base === "part" || base === "item";
       return tool.kind === "interface" ? base === "port" : true;
     }
     if (viewKind === "afv") {
@@ -208604,7 +209774,7 @@ function GvDisclosure({ element, svgWidth }) {
     }
   );
 }
-function AttributeValueEditor({ id: id2, name, value, top }) {
+function AttributeValueEditor({ id: id2, name, value, top, label = "Value", placeholder = "Add value" }) {
   const { onSetElementValue } = useDiagram();
   const [draft, setDraft] = (0, import_react9.useState)(value);
   if (!onSetElementValue) return null;
@@ -208614,8 +209784,8 @@ function AttributeValueEditor({ id: id2, name, value, top }) {
       type: "text",
       className: "dattribute-value nodrag nopan nowheel",
       style: { top },
-      "aria-label": "Value of " + name,
-      placeholder: "Add value",
+      "aria-label": label + " of " + name,
+      placeholder,
       value: draft,
       onPointerDown: (event) => event.stopPropagation(),
       onClick: (event) => event.stopPropagation(),
@@ -209026,12 +210196,17 @@ function titleNameLine(name, type, mult, alias, availPx) {
   const shown = fitText(full, availPx, 11);
   return { full, shown, clipped: shown !== full };
 }
-function AttributeValueShape({ value, w, top }) {
-  const shown = fitText(value || "Add value", Math.max(16, w - 32), 11);
+function valueFieldRole(keyword) {
+  if (keyword.startsWith("constraint")) return { label: "Constraint", placeholder: "Add constraint" };
+  if (keyword.startsWith("calc")) return { label: "Expression", placeholder: "Add expression" };
+  return { label: "Value", placeholder: "Add value" };
+}
+function AttributeValueShape({ value, w, top, placeholder = "Add value" }) {
+  const shown = fitText(value || placeholder, Math.max(16, w - 32), 11);
   return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("g", { className: "dattribute-value-shape", children: [
     /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("rect", { x: 8, y: top, width: Math.max(1, w - 16), height: 28, rx: 3 }),
     /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("text", { x: 15, y: top + 18, className: "dnode-label", children: [
-      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("title", { children: value || "Add value" }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("title", { children: value || placeholder }),
       shown
     ] })
   ] });
@@ -209078,7 +210253,15 @@ function BoxBody({ node, w, h, showMult }) {
       ] })
     ] }),
     /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Compartments, { node, w, ruleClass }),
-    node.value !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(AttributeValueShape, { value: node.value, w, top: h - 36 }) : null
+    node.value !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      AttributeValueShape,
+      {
+        value: node.value,
+        w,
+        top: h - 36,
+        placeholder: valueFieldRole(node.keyword).placeholder
+      }
+    ) : null
   ] });
 }
 function RoundedBody({ node, w, h, cls, showMult }) {
@@ -209262,7 +210445,7 @@ function SendAcceptBody({ node, w, h, accept }) {
 }
 function PackageBody({ node, w, h }) {
   if (node.meta?.gvMode !== void 0) {
-    const title = fitText(node.name, Math.max(24, w - 42), 11);
+    const title = fitText(node.name, Math.max(24, w - (node.meta?.gvCanExpand === true ? 42 : 20)), 11);
     return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("g", { children: [
       /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("path", { className: "dnode-rect package", d: packageFramePath(w, h) }),
       /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("text", { className: "dnode-kind", x: 10, y: 12, children: "\xABpackage\xBB" }),
@@ -210032,7 +211215,7 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
               internalsVisible: !hiddenContainer,
               featureCompartmentsVisible,
               cornerRadius: nodeCornerRadius(node.shape, node.isDef, h, (node.compartments?.length ?? 0) > 0),
-              onToggleInternals: ctx.onToggleInternals,
+              onToggleInternals: node.meta?.internalsExpandable === true ? ctx.onToggleInternals : void 0,
               onToggleFeatureCompartments: ctx.onToggleFeatureCompartments
             }
           ) : null,
@@ -210042,7 +211225,8 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
               id: id2,
               name: node.name,
               value: node.value,
-              top: h - 36
+              top: h - 36,
+              ...valueFieldRole(node.keyword)
             },
             id2 + ":" + node.value
           ) : null,
@@ -210289,7 +211473,15 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
                 strokeWidth: 0.8
               }
             ) : null,
-            frame2.value !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(AttributeValueShape, { value: frame2.value, w, top: frameHeaderHeight - 34 }) : null,
+            frame2.value !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+              AttributeValueShape,
+              {
+                value: frame2.value,
+                w,
+                top: frameHeaderHeight - 34,
+                placeholder: valueFieldRole(frame2.keyword).placeholder
+              }
+            ) : null,
             isStructuredControl ? /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("g", { className: "dstructured-condition-compartment", children: [
               isNamedStructuredAction ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
                 "line",
@@ -210555,7 +211747,7 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
             internalsVisible: true,
             featureCompartmentsVisible,
             cornerRadius: frame2.isDef === true ? 0 : FRAME_USAGE_CORNER_RADIUS,
-            onToggleInternals: ctx.onToggleInternals,
+            onToggleInternals: frame2.meta?.internalsExpandable === true ? ctx.onToggleInternals : void 0,
             onToggleFeatureCompartments: ctx.onToggleFeatureCompartments
           }
         ) : null,
@@ -210565,7 +211757,8 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
             id: id2,
             name: frame2.label,
             value: frame2.value,
-            top: frameHeaderHeight - 34
+            top: frameHeaderHeight - 34,
+            ...valueFieldRole(frame2.keyword)
           },
           id2 + ":" + frame2.value
         ) : null,
@@ -211260,7 +212453,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.36.0" : "dev";
+var VERSION2 = true ? "0.38.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;