sysml-diagram 0.36.0 → 0.39.0

package/out/main.js

@@ -161054,6 +161054,128 @@ var ANCHOR_KEYWORD = {
   bv: "package"
 };
 
+// ../language-server/out/src/services/constraint-reference.js
+var REFERENCE_KEYWORDS = {
+  AssertConstraintStmt: "assert",
+  RequireConstraintStmt: "require",
+  AssumeConstraintStmt: "assume"
+};
+function isInlineConstraintClaim(node) {
+  return REFERENCE_KEYWORDS[node.$type] !== void 0 && node.constraintKw === true;
+}
+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 +161193,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 +161310,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 +161494,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 +161818,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 +161826,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 +161921,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 +163246,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 +163269,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 +163752,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) {
@@ -163877,6 +164104,28 @@ var FeaturePathResolver = class {
   }
 };
 
+// ../language-server/out/src/services/calculation-semantics.js
+function effectiveCalculationResult(node, resolve8) {
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (current2, depth) => {
+    if (depth > 32 || seen.has(current2))
+      return void 0;
+    seen.add(current2);
+    const parameter = current2.members?.find((member) => member.$type === "ReturnDecl");
+    if (parameter || current2.body)
+      return {
+        parameter,
+        expression: parameter?.value ?? current2.body,
+        inherited: current2 !== node
+      };
+    const parents = supertypesOf(current2, resolve8).filter((parent) => parent.$type === "CalcDecl");
+    if (parents.length !== 1)
+      return void 0;
+    return walk(parents[0], depth + 1);
+  };
+  return walk(node, 0);
+}
+
 // ../language-server/out/src/platform/platform.js
 var current;
 function setPlatform(platform) {
@@ -166341,6 +166590,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 +166661,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";
   }
@@ -166434,6 +166696,7 @@ var isBareDefDecl = (node) => node.$type === "BareDefDecl";
 var isDefinitionNode = (node) => isDefinitionKind(node) && node.isDef === true || isBareDefDecl(node);
 var ACTION_FLOW_STEP_TYPES = /* @__PURE__ */ new Set([
   "ActionDecl",
+  "CalcDecl",
   "PerformStmt",
   "AssignNode",
   "SendNode",
@@ -167348,8 +167611,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       case "iv":
         return firstContent(isPartDecl) ?? firstContent(isPackage) ?? firstThat(isPartDecl) ?? firstThat(isPackage) ?? root4;
       case "afv":
-        return firstContent((n2) => isActionDecl(n2) || this.isCaseLike(n2)) ?? firstContent(isPartDecl) ?? // REQ-196 — action flow over a part's performers
-        firstThat((n2) => isActionDecl(n2) || this.isCaseLike(n2)) ?? root4;
+        return firstContent((n2) => isActionDecl(n2) || isCalcDecl(n2) || this.isCaseLike(n2)) ?? firstContent(isPartDecl) ?? // REQ-196 — action flow over a part's performers
+        firstThat((n2) => isActionDecl(n2) || isCalcDecl(n2) || this.isCaseLike(n2)) ?? root4;
       case "stv":
         return firstContent((n2) => isExhibitStateDecl(n2) || isStateDecl(n2)) ?? firstThat((n2) => isExhibitStateDecl(n2) || isStateDecl(n2)) ?? root4;
       case "sv":
@@ -167399,7 +167662,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       case "iv":
         return isPartDecl(node);
       case "afv":
-        return isActionDecl(node) || isPartDecl(node) || this.isCaseLike(node);
+        return isActionDecl(node) || isCalcDecl(node) || isPartDecl(node) || this.isCaseLike(node);
       case "stv":
         return isStateDecl(node) || isExhibitStateDecl(node) || isPartDecl(node);
       case "sv":
@@ -167422,7 +167685,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // and `findAnchor` drills to them, so a view opened on the OWNER of an empty
   // action definition shows the same thing the package overview does.
   isAfvScaffoldAnchor(node) {
-    return isActionDecl(node) && !!nameOf2(node) && (node.isDef === true || this.isDirectPackageMember(node));
+    return (isActionDecl(node) || isCalcDecl(node)) && !!nameOf2(node) && (node.isDef === true || this.isDirectPackageMember(node));
   }
   // REQ-196 — a member that is a STEP of the flow its holder runs: an action
   // usage, a send/accept/assign node, or a `perform`. An action DEFINITION is
@@ -167432,7 +167695,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // `hasAnchorContent` and `hasAfvOverviewDescendant` both read, so what makes a
   // part an anchor and what makes it a scope cannot drift apart.
   isAfvFlowNode(member, index2) {
-    return !this.isSwimlaneClaim(member, index2) && (isActionDecl(member) && member.isDef !== true || ["SendNode", "AcceptNode", "AssignNode", "PerformStmt"].includes(member.$type));
+    return !this.isSwimlaneClaim(member, index2) && ((isActionDecl(member) || isCalcDecl(member)) && member.isDef !== true || ["SendNode", "AcceptNode", "AssignNode", "PerformStmt"].includes(member.$type));
   }
   // REQ-196 — does this part's own subtree hold action flow anywhere? Counted
   // over the nested part usages of a flow-less part, this is what tells a shared
@@ -167558,20 +167821,29 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
    *  `accept` payload in on top) and the Interconnection View, where an action
    *  drawn inside a part must expose the same pins a flow can dock on. */
   actionPinPorts(action, ownerId, index2, uri) {
-    const inheritedFrom = action.isDef === true ? void 0 : this.resolveType(action, index2);
     const directed = /* @__PURE__ */ new Map();
-    for (const member of inheritedFrom ? membersOf(inheritedFrom) : []) {
-      if (nameOf2(member) && directionOf(member))
-        directed.set(nameOf2(member), member);
+    const inheritedTypes = /* @__PURE__ */ new Map();
+    for (const owner of [...this.inheritedFeatureOwnersOf(action, index2)].reverse()) {
+      for (const member of membersOf(owner)) {
+        const targets = redefinitionTargetsOf(member).map(lastSeg);
+        for (const target of targets)
+          directed.delete(target);
+        if (effectiveNameOf(member) && directionOf(member)) {
+          directed.set(effectiveNameOf(member), member);
+          inheritedTypes.set(effectiveNameOf(member), typeText(member) ?? inheritedTypes.get(targets[0] ?? effectiveNameOf(member)));
+        }
+      }
     }
     for (const member of membersOf(action)) {
-      if (nameOf2(member) && directionOf(member))
-        directed.set(nameOf2(member), member);
+      for (const target of redefinitionTargetsOf(member))
+        directed.delete(lastSeg(target));
+      if (effectiveNameOf(member) && directionOf(member))
+        directed.set(effectiveNameOf(member), member);
     }
     const pinOf = (member, id2, parentPort) => ({
       id: id2,
-      name: nameOf2(member),
-      type: typeText(member),
+      name: effectiveNameOf(member),
+      type: typeText(member) ?? inheritedTypes.get(lastSeg(redefinitionTargetsOf(member)[0] ?? effectiveNameOf(member))),
       direction: directionOf(member),
       conjugated: isConjugated(member) || void 0,
       // REQ-194/REQ-408 - see the port rule above: only a written `ref` dashes.
@@ -167584,7 +167856,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       // part does, so Properties inspects it the same way in the AFV as it
       // inspects a port in the IV.
       compartments: this.compartmentsFor(member, uri, index2, true),
-      source: sourceOf2(member, uri)
+      source: sourceOf2(member, uri),
+      meta: valueTextOf(member) !== void 0 ? { boundArgument: valueTextOf(member) } : void 0
     });
     const pins = [];
     const addNestedPins = (param, paramId, depth, seenTypes) => {
@@ -167610,12 +167883,38 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       }
     };
     for (const member of directed.values()) {
-      const id2 = `${ownerId}.${nameOf2(member)}`;
+      const id2 = `${ownerId}.${effectiveNameOf(member)}`;
       pins.push(pinOf(member, id2));
       addNestedPins(member, id2, 1, /* @__PURE__ */ new Set());
     }
+    if (isCalcDecl(action)) {
+      const result = effectiveCalculationResult(action, (name) => index2.get(name));
+      if (result) {
+        const parameter = result.parameter;
+        const name = parameter ? nameOf2(parameter) ?? "result" : "result";
+        pins.push({
+          id: `${ownerId}.${name}`,
+          name,
+          direction: "out",
+          pin: true,
+          isDef: false,
+          type: parameter ? typeText(parameter) : void 0,
+          source: sourceOf2(parameter ?? action, uri),
+          meta: { calculationResult: true, inherited: result.inherited }
+        });
+      }
+    }
     return pins;
   }
+  // REQ-208 - Only a locally declared result expression is editable on a usage.
+  calculationValue(node, index2) {
+    if (!isCalcDecl(node))
+      return {};
+    const result = effectiveCalculationResult(node, (name) => index2.get(name));
+    if (node.isDef !== true && (!result?.expression || result.inherited))
+      return {};
+    return { value: result?.expression?.$cstNode?.text.replace(/\s+/g, " ").trim() ?? "" };
+  }
   /** REQ-196/198: one definition node per type used by a drawn usage.
    *  The Defs filter controls these nodes. An existing definition tile is
    *  reused. Typing links are omitted by user direction (2026-09-06).
@@ -167732,8 +168031,10 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         }
         return (isPackage(node) || isDocument(node)) && this.nestedUsages(node, isPartDecl).some((n2) => nameOf2(n2) !== void 0);
       case "afv": {
+        if (isCalcDecl(node))
+          return true;
         if (isActionDecl(node) || this.isCaseLike(node)) {
-          const actions = membersOf(node).map((member) => this.thenActionMemberNode(member) ?? member).filter(isActionDecl);
+          const actions = membersOf(node).map((member) => this.thenActionMemberNode(member) ?? member).filter((n2) => isActionDecl(n2) || isCalcDecl(n2));
           if (actions.some((n2) => nameOf2(n2) !== void 0))
             return true;
           return node.inlineBody !== void 0;
@@ -167879,6 +168180,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 +168231,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 +168255,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 result = isCalcDecl(node) ? effectiveCalculationResult(node, (name) => index2.get(name)) : void 0;
+      const text = isCalcDecl(node) ? result && !result.inherited ? result.expression?.$cstNode?.text ?? "" : "" : 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 +168327,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 +168343,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 +168713,9 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         }
       }
     }
+    for (const owner of [...defNodes, ...usageNodes]) {
+      this.emitConstraintGraphics(owner, semanticId(owner), membersOf(owner), nodes, edges, index2, uri, false);
+    }
     const allocPairs = [
       ...all.filter((m) => m.$type === "AllocateStmt").map((a2) => ({
         from: String(a2.source ?? ""),
@@ -168957,6 +169351,89 @@ ${node.id}`;
       out.push({ title: "flows", items: rows });
     return out;
   }
+  // REQ-209 - Claims preserve usage identity; references reuse their target.
+  emitConstraintGraphics(owner, ownerId, members, nodes, edges, index2, uri, interconnection) {
+    const kinds = {
+      AssertConstraintStmt: "assert",
+      AssumeConstraintStmt: "assume",
+      RequireConstraintStmt: "require"
+    };
+    const ensureNode = (target, id2, keyword) => {
+      let node = nodes.find((candidate) => candidate.id === id2);
+      if (!node) {
+        const body = target.body?.$cstNode?.text;
+        node = {
+          id: id2,
+          name: effectiveNameOf(target) ?? keyword,
+          keyword,
+          shape: "box",
+          isDef: target.isDef === true,
+          type: typeText(target),
+          multiplicity: this.multText(target),
+          compartments: this.compartmentsFor(target, uri, index2),
+          ...(isConstraintDecl(target) || isInlineConstraintClaim(target)) && (body !== void 0 || target.isDef) ? { value: (body ?? "").replace(/\s+/g, " ").trim() } : {},
+          ...interconnection ? { ports: this.actionPinPorts(target, id2, index2, uri) } : {},
+          source: sourceOf2(target, uri),
+          ...interconnection ? {} : { parent: ownerId },
+          meta: { constraintUsage: true, ...!interconnection ? { gvUsage: true } : {} }
+        };
+        nodes.push(node);
+      }
+      node.meta = { ...node.meta, constraintUsage: true };
+      return node;
+    };
+    for (const member of members) {
+      const kind = kinds[member.$type];
+      if (!kind) {
+        if (interconnection && isConstraintDecl(member) && !member.isDef) {
+          ensureNode(member, `${ownerId}::${effectiveNameOf(member) ?? member.$cstNode?.offset}`, "constraint");
+        }
+        continue;
+      }
+      const reference = constraintReferenceOf(member);
+      let target = member;
+      let targetId = `${ownerId}::${effectiveNameOf(member) ?? `#${member.$type}:${members.filter((m) => m.$type === member.$type).indexOf(member) + 1}`}`;
+      if (reference) {
+        const resolved = this.featurePaths.resolveDeclarationPath(member);
+        const localPath = reference.path === reference.simpleName || reference.path.replaceAll("::", ".") === `self.${reference.simpleName}`;
+        const effective = interconnection && localPath ? members.find((candidate) => (isConstraintDecl(candidate) || isInlineConstraintClaim(candidate)) && [effectiveNameOf(candidate), ...redefinitionTargetsOf(candidate).map(lastSeg)].includes(reference.simpleName)) : void 0;
+        const found = effective ?? resolved.segments.at(-1)?.target ?? membersOf(owner).find((candidate) => candidate !== member && nameOf2(candidate) === reference.path) ?? index2.get(reference.path) ?? index2.get(reference.simpleName);
+        if (!found || found === member)
+          continue;
+        target = found;
+        targetId = interconnection && members.includes(target) && effectiveNameOf(target) ? `${ownerId}::${effectiveNameOf(target)}` : qnameOf(target) || reference.path;
+      }
+      const negated = member.isNegated === true;
+      ensureNode(target, targetId, reference ? keywordFor(target) : `${kind}${negated ? " not" : ""} constraint`);
+      const id2 = `${ownerId}::__${kind}_${member.$cstNode?.offset ?? edges.length}`;
+      if (!edges.some((edge) => edge.id === id2))
+        edges.push({
+          id: id2,
+          from: ownerId,
+          to: targetId,
+          kind,
+          label: `\xAB${kind}${negated ? " not" : ""}\xBB`,
+          source: sourceOf2(member, uri),
+          meta: { constraintReference: !!reference, negated }
+        });
+      if (!reference && !interconnection) {
+        const definition = this.resolveType(member, index2);
+        const definitionId = definition ? qnameOf(definition) : void 0;
+        if (definitionId && nodes.some((node) => node.id === definitionId) && !edges.some((edge) => edge.kind === "definedBy" && edge.from === targetId)) {
+          edges.push({
+            id: `${id2}_type`,
+            from: targetId,
+            to: definitionId,
+            kind: "definedBy",
+            source: sourceOf2(member, uri)
+          });
+        }
+      }
+    }
+    const drawnOwner = nodes.find((node) => node.id === ownerId);
+    if (drawnOwner && interconnection)
+      drawnOwner.compartments = withoutCompartments(drawnOwner.compartments, "assert constraints", "assume constraints", "require constraints");
+  }
   // REQ-192/360/363 — the ONE recursive Interconnection View renderer. Given the
   // top-level `roots` to draw, it renders each part instance and nests its
   // internals recursively, drilling into a usage's type DEFINITION (+
@@ -169009,8 +169486,13 @@ ${node.id}`;
           const emptyPrefixFlow = isEmptyPrefixFlow(member);
           const emptyPrefixInterface = isInterfaceDecl(member) && relationship.target !== void 0 && relationship.connect === void 0;
           const namedRelationship = isConnectorDecl(member) || isConnectionDecl(member) || isInterfaceDecl(member) && !emptyPrefixInterface || member.$type === "BindingDecl" || member.$type === "FlowStmt" && !emptyPrefixFlow;
-          if (namedRelationship) {
-            const names = [nameOf2(member), redefinedNameOf(member)].filter((name) => name !== void 0);
+          const constraint = isConstraintDecl(member) || isInlineConstraintClaim(member);
+          if (namedRelationship || constraint) {
+            const names = [
+              nameOf2(member),
+              redefinedNameOf(member),
+              ...constraint ? redefinitionTargetsOf(member).map(lastSeg) : []
+            ].filter((name) => name !== void 0);
             if (names.some((name) => claimedNames.has(name)))
               continue;
             for (const name of names)
@@ -169259,6 +169741,10 @@ ${node.id}`;
         const resolver = childResolver([], { usage: part, id: instanceId });
         this.emitInterconnectEdges(effectiveMembersOf(part), resolver.resolve, [], index2, uri, target.nodes, target.edges, eRef, instanceId, resolver.actionPinIds, resolver.structuralPortIds, part, occurrenceInherited, endpointProvenance);
       }
+      this.emitConstraintGraphics(part, instanceId, effectiveMembersOf(part), target.nodes, target.edges, index2, uri, true);
+      const claimFrame = target.frames.find((frame2) => frame2.id === instanceId);
+      if (claimFrame)
+        claimFrame.compartments = withoutCompartments(claimFrame.compartments, "assert constraints", "assume constraints", "require constraints");
     };
     const packageOfRoot = (root4) => enclosingPackage(root4) ?? scope;
     const rootBaseId = (root4) => qnameOf(root4) || nameOf2(root4) || `__root_${root4.$cstNode?.offset ?? 0}__`;
@@ -169350,8 +169836,35 @@ ${node.id}`;
   // single Interconnection View (called once over the anchor's whole subtree)
   // and the package overview (called once per container part, tagging any
   // synthetic n-ary dot with that container's frame id).
-  emitInterconnectEdges(members, resolveEnd, parts, index2, uri, nodes, edges, eRef, frameId, actionPinIds = /* @__PURE__ */ new Set(), structuralPortIds = /* @__PURE__ */ new Set(), memberOwner, memberOwnerInherited = false, endpointProvenance = /* @__PURE__ */ new Map()) {
+  emitInterconnectEdges(members, resolveStructuralEnd, parts, index2, uri, nodes, edges, eRef, frameId, actionPinIds = /* @__PURE__ */ new Set(), structuralPortIds = /* @__PURE__ */ new Set(), memberOwner, memberOwnerInherited = false, endpointProvenance = /* @__PURE__ */ new Map()) {
     const memberList2 = [...members];
+    if (memberOwner && frameId)
+      this.emitConstraintGraphics(memberOwner, frameId, memberList2, nodes, edges, index2, uri, true);
+    const resolveEnd = (pathText) => {
+      const structural = resolveStructuralEnd(pathText);
+      if (structural)
+        return structural;
+      const path10 = pathText.replaceAll("::", ".");
+      const candidates = nodes.filter((node) => node.meta?.constraintUsage === true && (!frameId || node.id.startsWith(`${frameId}::`) || edges.some((edge) => edge.from === frameId && edge.to === node.id))).flatMap((node) => (node.ports ?? []).filter((pin) => `${node.name}.${pin.name}` === path10 || pin.id.replaceAll("::", ".") === path10));
+      if (candidates.length === 1)
+        return candidates[0].id;
+      const attribute = memberList2.find((member) => isAttributeDecl(member) && nameOf2(member) === path10);
+      if (!attribute || !frameId)
+        return void 0;
+      const id2 = `${frameId}::${nameOf2(attribute)}`;
+      if (!nodes.some((node) => node.id === id2))
+        nodes.push({
+          id: id2,
+          name: nameOf2(attribute),
+          keyword: "attribute",
+          isDef: false,
+          shape: "box",
+          type: typeText(attribute),
+          value: valueTextOf(attribute),
+          source: sourceOf2(attribute, uri)
+        });
+      return id2;
+    };
     const pendingFlows = [];
     const firstEdge = edges.length;
     const relationshipFields = (source) => {
@@ -169898,7 +170411,7 @@ ${node.id}`;
       while (cur && cur !== scope) {
         if (set3.has(cur)) {
           if (kind !== "stv" || !isPartDecl(n2)) {
-            if (kind === "afv" && isPartDecl(cur) && n2.isDef === true && isActionDecl(n2))
+            if (kind === "afv" && isPartDecl(cur) && n2.isDef === true && (isActionDecl(n2) || isCalcDecl(n2)))
               break;
             return false;
           }
@@ -169952,12 +170465,12 @@ ${node.id}`;
         anchor: sub,
         diagramRoot: ctx.diagramRoot ?? ctx.anchor
       });
-      if (this.diagramElementCount(subModel) === 0 && !(kind === "afv" && isActionDecl(sub)) && !(kind === "stv" && (isStateDecl(sub) || isExhibitStateDecl(sub))))
+      if (this.diagramElementCount(subModel) === 0 && !(kind === "afv" && (isActionDecl(sub) || isCalcDecl(sub))) && !(kind === "stv" && (isStateDecl(sub) || isExhibitStateDecl(sub))))
         continue;
       const frameId = `t${tile}`;
       const q = qnameOf(sub) || nameOf2(sub) || "";
       const rel2 = scopeQ && q.startsWith(`${scopeQ}::`) ? q.slice(scopeQ.length + 2) : nameOf2(sub) ?? q;
-      const tileMetaTag = kind === "afv" ? isPartDecl(sub) ? { afvPart: true } : isActionDecl(sub) && sub.isDef === true ? { behaviorDef: true } : void 0 : kind === "stv" && sub.isDef === true ? { behaviorDef: true } : void 0;
+      const tileMetaTag = kind === "afv" ? isPartDecl(sub) ? { afvPart: true } : (isActionDecl(sub) || isCalcDecl(sub)) && sub.isDef === true ? { behaviorDef: true } : void 0 : kind === "stv" && sub.isDef === true ? { behaviorDef: true } : void 0;
       const tileIdentity = {
         declarationId: qnameOf(sub) || nameOf2(sub),
         declarationName: nameOf2(sub),
@@ -170178,7 +170691,7 @@ ${node.id}`;
         addStepAlias(alias, id2);
     };
     let anon = 0;
-    const anchorHostsFlow = isActionDecl(anchor) || this.isCaseLike(anchor);
+    const anchorHostsFlow = isActionDecl(anchor) || isCalcDecl(anchor) || this.isCaseLike(anchor);
     const exprTextOf = (v) => (v?.$cstNode?.text ?? (typeof v === "string" ? v : "")).replace(/\s+/g, " ").trim();
     const performPathOf = (m) => [nameOf2(m), ...m.chainSegs ?? []].filter((segment) => !!segment);
     const performLabel = (m) => performPathOf(m).at(-1) ?? typeText(m) ?? "perform";
@@ -170187,6 +170700,9 @@ ${node.id}`;
     const flowNodeInfo = (m) => {
       const mm = m;
       switch (m.$type) {
+        // REQ-208 - Calculations share action occurrence docking.
+        case "CalcDecl":
+          return { shape: "action", label: nameOf2(m) ?? "calc" };
         case "ActionDecl": {
           if (!nameOf2(m))
             return void 0;
@@ -170421,7 +170937,7 @@ ${node.id}`;
         pinByPath.set(alias, null);
     };
     const actionPinsOf = (action, ownerId) => {
-      if (!isActionDecl(action) && action.$type !== "PerformStmt")
+      if (!isActionDecl(action) && !isCalcDecl(action) && action.$type !== "PerformStmt")
         return [];
       const pins = this.actionPinPorts(action, ownerId, index2, uri);
       const inline = action.inlineBody;
@@ -170606,7 +171122,7 @@ ${node.id}`;
       frameOfNode.set(holder, frameId);
       const framePorts = isPartDecl(holder) ? [...framePins, ...this.portsOf(holder, index2, uri, frameId).ports.filter((port) => !framePins.some((pin) => pin.name === port.name)).map((port) => ({ ...port, meta: { ...port.meta, afvPartPort: true } }))] : framePins;
       registerPins(holder, frameId, framePins, isAnchor);
-      const frameCompartments = isActionDecl(holder) ? actionFeatureCompartments(holder) : withoutCompartments(this.compartmentsFor(holder, uri, index2), ...graphicalAfvTitles);
+      const frameCompartments = isActionDecl(holder) || isCalcDecl(holder) ? actionFeatureCompartments(holder) : withoutCompartments(this.compartmentsFor(holder, uri, index2), ...graphicalAfvTitles);
       frames.push({
         id: frameId,
         label: nameOf2(holder) ?? lastSeg(frameId),
@@ -170615,6 +171131,7 @@ ${node.id}`;
         isDef: holder.isDef === true,
         type: typeText(holder),
         multiplicity: this.multText(holder),
+        ...this.calculationValue(holder, index2),
         compartments: frameCompartments?.length ? frameCompartments : void 0,
         ports: framePorts,
         source: sourceOf2(holder, uri),
@@ -170651,7 +171168,7 @@ ${node.id}`;
         this.featurePath(namedSendNode.via) ? `via ${this.featurePath(namedSendNode.via)}` : void 0,
         this.featurePath(namedSendNode.sendTarget) ? `to ${this.featurePath(namedSendNode.sendTarget)}` : void 0
       ].filter((value) => !!value).join(" ") : void 0;
-      const featureCompartments = m.$type === "ActionDecl" || m.$type === "PerformStmt" ? actionFeatureCompartments(m) : [];
+      const featureCompartments = isCalcDecl(m) || m.$type === "ActionDecl" || m.$type === "PerformStmt" ? actionFeatureCompartments(m) : [];
       const detailCompartment = acceptTrigger || sendDetail ? [{
         title: acceptTrigger ? "accepts" : "sends",
         items: [{ text: acceptTrigger ?? sendDetail, source: sourceOf2(inlineAccept ?? m, uri) }]
@@ -170664,6 +171181,8 @@ ${node.id}`;
         keyword: info.keyword ?? keywordFor(m),
         isDef: m.isDef === true,
         shape: info.shape,
+        ...isCalcDecl(m) ? { type: typeText(m), multiplicity: this.multText(m) } : {},
+        ...this.calculationValue(m, index2),
         ports: pins,
         compartments: compartments.length ? compartments : void 0,
         frame: frameId,
@@ -170765,14 +171284,14 @@ ${node.id}`;
       }) || inline?.$type === "AssignNode" || definitionFlowMembersOf(node).length > 0;
     };
     const contentSourceOf = (node) => {
-      if (node.$type === "ActionDecl")
+      if (isActionDecl(node) || isCalcDecl(node))
         return ownsFlow(node) ? node : void 0;
       if (node.$type !== "PerformStmt")
         return void 0;
       if (ownsFlow(node))
         return node;
       const target = performTarget(node);
-      return target && isActionDecl(target) && ownsFlow(target) ? target : void 0;
+      return target && (isActionDecl(target) || isCalcDecl(target)) && ownsFlow(target) ? target : void 0;
     };
     const isCompositeAction = (node) => contentSourceOf(node) !== void 0;
     const openFrames = /* @__PURE__ */ new Set();
@@ -170807,6 +171326,7 @@ ${node.id}`;
         isDef: action.isDef === true,
         type: typeText(action),
         multiplicity: this.multText(action),
+        ...this.calculationValue(action, index2),
         compartments: actionCompartments.length ? actionCompartments : void 0,
         ports: pins,
         source: sourceOf2(action, uri),
@@ -172388,7 +172908,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 +172957,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 +172974,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 +172992,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 +173004,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 +173066,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 +174855,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 +174907,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")));
@@ -174332,7 +174916,7 @@ ${node.id}`;
     add("objective", members.filter(isObjectiveDecl).filter(isNonVariantMember).map((m) => item(m, nameOf2(m) ?? "objective")));
     add("verifies", members.filter((m) => m.$type === "VerifyStmt").map((m) => item(m, String(m.target ?? ""))));
     add("verification methods", members.filter((m) => isMetadataDecl(m) && (typeText(m) ?? "").includes("VerificationMethod")).map((m) => item(m, typeText(m) ?? "method")));
-    const behavioralParameterOwner = isActionDecl(node) || isCalcDecl(node) || isConstraintDecl(node) || isCaseDecl(node) || isAnalysisCaseDecl(node) || isVerificationCaseDecl(node) || isUseCaseDecl(node);
+    const behavioralParameterOwner = ["AssertConstraintStmt", "AssumeConstraintStmt", "RequireConstraintStmt"].includes(node.$type) || isActionDecl(node) || isCalcDecl(node) || isConstraintDecl(node) || isCaseDecl(node) || isAnalysisCaseDecl(node) || isVerificationCaseDecl(node) || isUseCaseDecl(node);
     const enclosingBehavioralParameterOwner = (() => {
       if (isPartDecl(node) || isPortDecl(node) || directionOf(node) === void 0)
         return false;
@@ -174351,9 +174935,17 @@ ${node.id}`;
       ...members.filter((m) => directionOf(m) !== void 0 && nameOf2(m)).filter((m) => !isVariantMember(m) && !isVariantConfigMember(m)).map((m) => item(m, canonicalFeatureText(m))),
       ...inheritedRows((member) => directionOf(member) !== void 0 && isNonVariantMember(member))
     ]);
-    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) }] : []);
+    const calculationResult = isCalcDecl(node) ? effectiveCalculationResult(node, (name) => index2?.get(name)) : void 0;
+    const results = calculationResult?.parameter ? [calculationResult.parameter] : members.filter((m) => m.$type === "ReturnDecl");
+    add("result", results.map((m) => item(m, `${calculationResult?.inherited ? "^" : ""}return${nameOf2(m) ? ` ${nameOf2(m)}` : ""}${typeText(m) ? ` : ${typeText(m)}` : ""}${valueTextOf(m) ? ` = ${valueTextOf(m)}` : ""}`)));
+    if (calculationResult?.expression)
+      add("expression", [{
+        text: calculationResult.expression.$cstNode?.text ?? "",
+        source: sourceOf2(calculationResult.expression, uri)
+      }]);
+    if (isConstraintDecl(node) || ["AssertConstraintStmt", "AssumeConstraintStmt", "RequireConstraintStmt"].includes(node.$type)) {
+      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 +174974,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 +175235,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 +175259,7 @@ function projectGvCompartments(input) {
         ...node.meta,
         gvMode: "group",
         gvExpansionKey: key2,
-        gvCanExpand: true,
+        gvCanExpand: canExpand,
         gvExpanded: open,
         gvOpenContainer: open,
         internalsHidden: !open,
@@ -174671,7 +175267,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,17 +175303,17 @@ 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) || child.meta?.constraintUsage === true)
     );
     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({
       ...node,
       // Tree states membership with a line. It does not borrow canvas containment.
       parent: void 0,
-      compartments: (isPackage2 && open ? void 0 : gvPackageMemberCompartments(node, index2))?.filter((compartment) => !open || !isPackage2 && compartment.title !== "parts").map((compartment) => ({ ...compartment, expandable: false, expanded: false })),
+      compartments: (isPackage2 && open ? void 0 : gvPackageMemberCompartments(node, index2))?.filter((compartment) => !open || !isPackage2 && !["parts", "assert constraints", "assume constraints", "require constraints"].includes(compartment.title)).map((compartment) => ({ ...compartment, expandable: false, expanded: false })),
       meta: {
         ...node.meta,
         gvMode: "tree",
@@ -175761,6 +176357,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 +177403,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 +177923,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 +177934,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 +177948,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 +178120,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 +178158,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 +179188,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 +179380,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 +179458,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 +179487,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 +179692,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 +181205,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 +181559,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 +183173,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 +183197,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 +183234,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 +183244,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 +183259,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 +184595,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 +184612,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 +185345,9 @@ var STYLE_ADVISORY_CODES = /* @__PURE__ */ new Set([
   "STYL009",
   "STYL010",
   "STYL011",
+  "STYL012",
+  "STYL013",
+  "STYL014",
   "LEX009",
   // trailing whitespace
   "SYN024",
@@ -184399,6 +185670,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;
@@ -189965,7 +191238,7 @@ function nodeBlockForCanvas(node) {
       compartments: compartments2?.length ? compartments2 : void 0
     };
   }
-  if (!/\bconstraint(?:\s+def)?$/u.test(node.keyword.trim().toLowerCase())) return node;
+  if (!/\b(?:constraint|calc)(?:\s+def)?$/u.test(node.keyword.trim().toLowerCase())) return node;
   const compartments = node.compartments?.filter((compartment) => compartment.title !== "expression");
   return {
     ...node,
@@ -190059,7 +191332,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 +192005,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 +192068,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 +192150,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 +192181,7 @@ function applyFeatureCompartmentVisibility(model, visibleFeatureCompartments, hi
       meta: {
         ...host.meta,
         containerControls: true,
+        internalsExpandable,
         featureCompartmentsVisible: visible,
         ...leaf ? { internalsHidden } : {}
       }
@@ -190909,10 +192197,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 +192209,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 +192226,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 +192255,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}`);
@@ -191114,6 +192401,8 @@ function modelToFlow(model, opts) {
     nodes.push({
       id: f.id,
       type: "frame",
+      // REQ-361 - Portless GV bounds include the complete painted frame.
+      className: model.kind === "gv" && !f.ports?.length ? "rf-bounded-paint" : void 0,
       position: { x: 0, y: 0 },
       data: {
         kind: model.kind,
@@ -191229,6 +192518,8 @@ function modelToFlow(model, opts) {
     nodes.push({
       id: n2.id,
       type: isGeo ? "geo" : "sysml",
+      // REQ-361 - Outside port labels must never enter paint containment.
+      className: model.kind === "gv" && !n2.ports?.length ? "rf-bounded-paint" : void 0,
       position: { x: 0, y: 0 },
       data: {
         kind: model.kind,
@@ -205385,6 +206676,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 +207056,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 +207189,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 +207631,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 */
@@ -207035,6 +208347,15 @@ svg.react-flow__connectionline { z-index: 1; }
 .rf-ctl-zoom { width: auto; min-width: 42px; padding: 0 4px; text-align: center; font: 600 11px var(--font-mono); color: var(--fg-2); }
 .rf-ctl-sep { width: 1px; height: 16px; background: var(--line); margin: 0 3px; }
 .react-flow__node { font-family: var(--font-mono); font-size: 11px; color: var(--fg-0); }
+/* REQ-361 - Bound hit testing on portless GV cards. The margin retains border
+ * strokes, package tabs and side handles. Port glyphs and their outside labels
+ * remain unbounded. Editing and hover controls also retain their full overflow. */
+/* Keep every card mounted. Only ordinary Group cards defer off-screen contents.
+ * Their explicit dimensions preserve geometry. Large frames and Tree retain
+ * their regular rendering path; deferring their contents adds layout work. */
+.react-flow__node.rf-bounded-paint { contain: paint; overflow-clip-margin: 16px; }
+.rf-gv-group .react-flow__node-sysml.rf-bounded-paint { content-visibility: auto; }
+.react-flow__node.rf-bounded-paint:is(:hover, :focus-within, .selected) { contain: none; content-visibility: visible; }
 .react-flow__node-sysml, .react-flow__node-frame { background: transparent; border: none; padding: 0; border-radius: 0; box-shadow: none; }
 .rf-node, .rf-frame { position: relative; user-select: none; }
 /* Container frames: the interior is click-through so connectors drawn underneath
@@ -207812,7 +209133,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 +209172,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
@@ -207857,6 +209191,8 @@ var TOOLBOX = {
   // they are the action's parameter pins.
   afv: {
     elements: [
+      el("calc def", "calc def", "\u2211"),
+      el("calc", "calc", "\u2211"),
       el("action def", "action def", "\u25B7"),
       el("action", "action", "\u25B7"),
       // issue #217 — a behaviour-root canvas writes into the action
@@ -208025,7 +209361,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 +209376,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 +209391,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.
@@ -208063,6 +209406,7 @@ var CHILD_KINDS = {
 function normalizedElementKeyword(keyword) {
   const normalized = keyword.trim().toLowerCase();
   let base = normalized.replace(/\s*def$/u, "").replace(/^(?:(?:abstract|variation|variant|ref|derived|readonly|individual|timeslice|snapshot|parallel)\s+)+/u, "").trim();
+  if (/^(assert(?: not)?|assume|require) constraint$/u.test(base)) base = "constraint";
   const isDecision = base === "decide" || base === "decision";
   if ([
     "send action",
@@ -208164,15 +209508,37 @@ 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") {
+      if (base === "calc") return tool.kind === "succession" || tool.kind === "begin";
       if (base === "action") return tool.kind === "succession" || tool.kind === "begin" || tool.kind === "guard" || tool.kind === "terminate" || tool.kind === TERMINAL_RELATION;
       if (base === "control") return tool.kind === "succession" || tool.kind === "begin" || tool.kind === "guard" || isDecision && tool.kind === "else" || tool.kind === "terminate" || tool.kind === TERMINAL_RELATION;
       if (base === "port") return false;
@@ -208604,7 +209970,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 +209980,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 +210392,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 (/\bconstraint(?:\s+def)?$/u.test(keyword)) 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 +210449,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 +210641,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 +211411,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 +211421,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 +211669,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 +211943,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 +211953,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 +212649,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.36.0" : "dev";
+var VERSION2 = true ? "0.39.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;