sysml-diagram 0.38.0 → 0.39.0

package/out/main.js

@@ -161060,6 +161060,9 @@ var REFERENCE_KEYWORDS = {
   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)
@@ -164101,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) {
@@ -166671,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",
@@ -167585,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":
@@ -167636,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":
@@ -167659,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
@@ -167669,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
@@ -167795,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.
@@ -167821,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) => {
@@ -167847,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).
@@ -167969,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;
@@ -168202,8 +168266,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const attributeValue = (node) => valueTextOf(node) ?? node.default?.value?.$cstNode?.text ?? "";
     const returnMemberOf = (node) => membersOf(node).find((m) => m.$type === "ReturnDecl");
     const expressionBody = (node) => {
-      const ret = isCalcDecl(node) ? returnMemberOf(node) : void 0;
-      const text = ret ? valueTextOf(ret) ?? "" : node.body?.$cstNode?.text ?? "";
+      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;
@@ -168649,27 +168713,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         }
       }
     }
-    const CLAIM_EDGE_KINDS = {
-      AssertConstraintStmt: "assert",
-      AssumeConstraintStmt: "assume",
-      RequireConstraintStmt: "require"
-    };
     for (const owner of [...defNodes, ...usageNodes]) {
-      for (const m of membersOf(owner)) {
-        const claim = CLAIM_EDGE_KINDS[m.$type];
-        if (!claim)
-          continue;
-        const negated = m.isNegated === true;
-        const label = `\xAB${claim}${negated ? " not" : ""}\xBB`;
-        const reference = constraintReferenceOf(m);
-        if (reference) {
-          linkByName(claim, owner, reference.path, label, m);
-          continue;
-        }
-        const typed = typeText(m);
-        if (typed)
-          linkByName(claim, owner, typed, label, m);
-      }
+      this.emitConstraintGraphics(owner, semanticId(owner), membersOf(owner), nodes, edges, index2, uri, false);
     }
     const allocPairs = [
       ...all.filter((m) => m.$type === "AllocateStmt").map((a2) => ({
@@ -169306,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 (+
@@ -169358,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)
@@ -169608,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}__`;
@@ -169699,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) => {
@@ -170247,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;
           }
@@ -170301,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),
@@ -170527,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";
@@ -170536,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;
@@ -170770,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;
@@ -170955,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),
@@ -170964,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),
@@ -171000,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) }]
@@ -171013,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,
@@ -171114,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();
@@ -171156,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),
@@ -174745,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;
@@ -174764,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))
+    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);
@@ -175124,7 +175303,7 @@ function projectGvTree(input) {
     visible.add(node.id);
     const isPackage2 = node.shape === "package";
     const children2 = (index2.children.get(node.id) ?? []).filter(
-      (child) => child.meta?.gvTreeExcluded !== true && !isDerivedHub(child) && (isPackage2 || isGvPartUsage(child))
+      (child) => child.meta?.gvTreeExcluded !== true && !isDerivedHub(child) && (isPackage2 || isGvPartUsage(child) || child.meta?.constraintUsage === true)
     );
     const key2 = gvElementKey(node);
     const canExpand = children2.length > 0;
@@ -175134,7 +175313,7 @@ function projectGvTree(input) {
       ...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",
@@ -191059,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,
@@ -192222,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,
@@ -192337,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,
@@ -208164,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
@@ -208999,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
@@ -209212,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",
@@ -209343,6 +209538,7 @@ function relationToolsForNode(keyword, viewKind, shape) {
       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;
@@ -210197,7 +210393,7 @@ function titleNameLine(name, type, mult, alias, availPx) {
   return { full, shown, clipped: shown !== full };
 }
 function valueFieldRole(keyword) {
-  if (keyword.startsWith("constraint")) return { label: "Constraint", placeholder: "Add constraint" };
+  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" };
 }
@@ -212453,7 +212649,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.38.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;