sysml-diagram 0.14.5 → 0.15.1

package/out/main.js

@@ -133689,6 +133689,9 @@ function isExhibitStateDecl(item) {
 var ExitAction = "ExitAction";
 var ExposeMember = "ExposeMember";
 var ExposePath = "ExposePath";
+function isExposePath(item) {
+  return reflection2.isInstance(item, ExposePath);
+}
 var ExpressionDecl = "ExpressionDecl";
 var FeatureDecl = "FeatureDecl";
 function isFeatureDecl(item) {
@@ -161748,6 +161751,12 @@ function keywordFor(node) {
   const parallel = isParallelState(node) ? "parallel " : "";
   const leadMods = [variability, temporal].filter(Boolean);
   const prefix = leadMods.length ? leadMods.map((m) => `${m} `).join("") : parallel;
+  if (t === "BareDefDecl")
+    return `${prefix}def`.trim();
+  if (t === "FeatureShorthand") {
+    const kinds = (Array.isArray(n2.usageKinds) ? n2.usageKinds : []).join(" ");
+    return `${prefix}${kinds}`.trim() || "feature";
+  }
   if (t === "ActorDecl" || t === "SubjectDecl" || t === "StakeholderDecl")
     return `${prefix}${word}`;
   return def ? `${prefix}${word} def` : `${prefix}${word}`;
@@ -161756,7 +161765,39 @@ var isDefinitionKind = (node) => isPartDecl(node) || isPortDecl(node) || isItemD
 // genuine SysML definitions (FlowConnectionDefinition / AssociationStructure /
 // AllocationDefinition) and belong in the General View like any other def.
 isFlowStmt(node) || isConnectorDecl(node) || isAllocationDecl(node) || isConstraintDecl(node) || isEnumDecl(node) || isStateDecl(node) || isActionDecl(node) || isCalcDecl(node) || isConcernDecl(node) || isViewDecl(node) || isViewpointDecl(node) || isRenderingDecl(node) || isMetadataDecl(node);
-var isFeatureUsageMember = (m, owner) => isPartDecl(m) || isPortDecl(m) || isItemDecl(m) || isAttributeDecl(m) || isOccurrenceDecl(m) || isStateDecl(m) && !isExhibitStateDecl(m) || isActionDecl(m) || isCalcDecl(m) || isConstraintDecl(m) || isRequirementDecl(m) || isConcernDecl(m) || isViewDecl(m) || isViewpointDecl(m) || isRenderingDecl(m) || isUseCaseDecl(m) || isAnalysisCaseDecl(m) || isVerificationCaseDecl(m) || isCaseDecl(m) || isConnectionDecl(m) || isInterfaceDecl(m) || isAllocationDecl(m) || isEnumDecl(m) && !isEnumDecl(owner);
+var isBareDefDecl = (node) => node.$type === "BareDefDecl";
+var isDefinitionNode = (node) => isDefinitionKind(node) && node.isDef === true || isBareDefDecl(node);
+var modifiersOf = (node) => {
+  const mods = node.modifiers;
+  return Array.isArray(mods) ? mods : [];
+};
+var portionKindOf = (node) => modifiersOf(node).find((m) => m === "timeslice" || m === "snapshot");
+var isIndividualOccurrence = (node) => modifiersOf(node).includes("individual");
+var isOccurrenceModified = (node) => portionKindOf(node) !== void 0 || isIndividualOccurrence(node);
+var redefinedNameOf = (node) => {
+  const n2 = node;
+  for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
+    if (rel2.kind === ":>>" || rel2.kind === "redefines") {
+      const target = (rel2.targets ?? [])[0];
+      if (target)
+        return lastSeg(target);
+    }
+  }
+  return void 0;
+};
+var portionLabelOf = (node) => nameOf2(node) ?? (isOccurrenceModified(node) ? redefinedNameOf(node) : void 0);
+function diagramNodeId(node) {
+  const name = nameOf2(node);
+  if (name)
+    return qnameOf(node) || name;
+  const label = portionLabelOf(node);
+  if (!label)
+    return void 0;
+  const ownerQname = qnameOf(node);
+  return ownerQname ? `${ownerQname}::${label}` : label;
+}
+var isDeclaredEventOccurrence = (m) => isEventDecl(m) && m.isOccurrence === true;
+var isFeatureUsageMember = (m, owner) => isPartDecl(m) || isPortDecl(m) || isItemDecl(m) || isAttributeDecl(m) || isOccurrenceDecl(m) || isDeclaredEventOccurrence(m) || isStateDecl(m) && !isExhibitStateDecl(m) || isActionDecl(m) || isCalcDecl(m) || isConstraintDecl(m) || isRequirementDecl(m) || isConcernDecl(m) || isViewDecl(m) || isViewpointDecl(m) || isRenderingDecl(m) || isUseCaseDecl(m) || isAnalysisCaseDecl(m) || isVerificationCaseDecl(m) || isCaseDecl(m) || isConnectionDecl(m) || isInterfaceDecl(m) || isAllocationDecl(m) || isEnumDecl(m) && !isEnumDecl(owner);
 function specializationTargets(node) {
   const n2 = node;
   const out = [];
@@ -162316,7 +162357,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           return false;
         }
         const scope = this.packageScopeOf(node);
-        return [...ast_utils_exports.streamAllContents(scope)].some((n2) => isDefinitionKind(n2) && n2.isDef === true && nameOf2(n2) || this.isViewlessUsage(n2) && this.isDirectPackageMember(n2) || isPartDecl(n2) && n2.isDef !== true && !!nameOf2(n2) && this.isDirectPackageMember(n2));
+        return [...ast_utils_exports.streamAllContents(scope)].some((n2) => isDefinitionNode(n2) && nameOf2(n2) || this.isViewlessUsage(n2) && this.isDirectPackageMember(n2) || isPartDecl(n2) && n2.isDef !== true && !!nameOf2(n2) && this.isDirectPackageMember(n2));
       }
       case "iv":
         if (isPartDecl(node)) {
@@ -162387,6 +162428,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // they get their graphical home as General View usage nodes — previously a
   // package-level `constraint massLimitation { … }` was invisible everywhere.
   isViewlessUsage(n2) {
+    if (n2.$type === "FeatureShorthand" && isOccurrenceModified(n2) && nameOf2(n2) !== void 0)
+      return true;
     return (isConstraintDecl(n2) || isCalcDecl(n2) || isOccurrenceDecl(n2) || isItemDecl(n2) || isAttributeDecl(n2)) && n2.isDef !== true && nameOf2(n2) !== void 0;
   }
   isDirectPackageMember(n2) {
@@ -162411,9 +162454,9 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const { uri, index: index2 } = ctx;
     const scope = this.packageScopeOf(ctx.anchor);
     const all = [...ast_utils_exports.streamAllContents(scope)];
-    const defNodes = all.filter((n2) => isDefinitionKind(n2) && n2.isDef === true && nameOf2(n2));
+    const defNodes = all.filter((n2) => isDefinitionNode(n2) && nameOf2(n2));
     const packageOverview = isPackage(ctx.anchor) || isDocument(ctx.anchor);
-    const hasOwnedMemberNode = all.some((n2) => isPackage(n2) && !!nameOf2(n2) || isDefinitionKind(n2) && n2.isDef === true && !!nameOf2(n2) || this.isViewlessUsage(n2) && this.isDirectPackageMember(n2) || isPartDecl(n2) && n2.isDef !== true && !!nameOf2(n2) && this.isDirectPackageMember(n2));
+    const hasOwnedMemberNode = all.some((n2) => isPackage(n2) && !!nameOf2(n2) || isDefinitionNode(n2) && !!nameOf2(n2) || this.isViewlessUsage(n2) && this.isDirectPackageMember(n2) || isPartDecl(n2) && n2.isDef !== true && !!nameOf2(n2) && this.isDirectPackageMember(n2));
     const packageNodes = [
       ...packageOverview && hasOwnedMemberNode && isPackage(scope) && nameOf2(scope) ? [scope] : [],
       ...all.filter((p) => isPackage(p) && nameOf2(p))
@@ -162603,16 +162646,18 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const boundReferences = [];
     for (let w = 0; w < featureWork.length; w += 1) {
       const d = featureWork[w];
-      for (const m of membersOf(d)) {
+      for (const raw of membersOf(d)) {
+        const m = this.thenActionMemberNode(raw) ?? raw;
         const mm = m;
-        if (mm.isDef === true || !nameOf2(m))
+        const label = portionLabelOf(m);
+        if (mm.isDef === true || !label)
           continue;
         if (directionOf(m) !== void 0)
           continue;
-        if (!isFeatureUsageMember(m, d))
+        if (!isFeatureUsageMember(m, d) && !isOccurrenceModified(m))
           continue;
         const isRefMembership = (mm.modifiers ?? []).includes("ref");
-        if (!isPartDecl(m) && !isOccurrenceDecl(m))
+        if (!isPartDecl(m) && !isOccurrenceDecl(m) && !isOccurrenceModified(m) && !isDeclaredEventOccurrence(m))
           continue;
         const boundTarget = isRefMembership ? boundPartTarget(m) : void 0;
         const hasBoundPath = isRefMembership && isPathExpr(mm.value);
@@ -162625,14 +162670,16 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         }
         const def = this.resolveType(m, index2);
         const defOnCanvas = !!(def && ids.has(def));
-        const uid = qnameOf(m) || nameOf2(m);
+        const uid = diagramNodeId(m) ?? label;
         if (!ids.has(m)) {
           ids.set(m, uid);
-          if (!byName.has(nameOf2(m)))
-            byName.set(nameOf2(m), m);
+          if (!byName.has(label))
+            byName.set(label, m);
+          if (!byQName.has(uid))
+            byQName.set(uid, m);
           nodes.push({
             id: uid,
-            name: nameOf2(m),
+            name: label,
             keyword: keywordFor(m),
             isDef: false,
             shape: "box",
@@ -162657,10 +162704,16 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           id: `e${e++}`,
           from: ids.get(d),
           to: uid,
-          kind: isRefMembership ? "reference" : "composition",
+          // REQ-160 — a composed `timeslice`/`snapshot` is not ordinary
+          // feature membership: it is the temporal decomposition of the
+          // owner's life (OMG 8.2.3.9), drawn with the hollow triangle at
+          // the whole end. A `ref` portion still reads as a reference — it
+          // points at a portion owned elsewhere rather than carving up this
+          // occurrence's own lifetime.
+          kind: isRefMembership ? "reference" : portionKindOf(m) ? "portion" : "composition",
           // No label — the usage name/type read inside the box; keep
           // `name` for the stable route key and Properties.
-          name: nameOf2(m),
+          name: label,
           type: typeText(m),
           source: sourceOf2(m, uri)
         });
@@ -162669,6 +162722,31 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         }
       }
     }
+    for (const owner of [...ids.keys()]) {
+      const from = ids.get(owner);
+      for (const raw of membersOf(owner)) {
+        const m = this.thenActionMemberNode(raw) ?? raw;
+        if (!isEventDecl(m) || m.isOccurrence === true)
+          continue;
+        const ev = m;
+        const path10 = [nameOf2(m), ...ev.chainSegs].filter(Boolean).join("::");
+        if (!path10)
+          continue;
+        const target = resolveDrawnByText(path10);
+        const to = target && ids.get(target);
+        if (!to || to === from)
+          continue;
+        edges.push({
+          id: `e${e++}`,
+          from,
+          to,
+          kind: "referenceSubsetting",
+          label: "event",
+          name: lastSeg(path10),
+          source: sourceOf2(m, uri)
+        });
+      }
+    }
     for (const binding of boundReferences) {
       const from = ids.get(binding.owner);
       const to = ids.get(binding.target);
@@ -165863,7 +165941,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const related = this.relatedNodes(anchor, index2);
     const keepIds = /* @__PURE__ */ new Set();
     for (const n2 of related) {
-      const id2 = qnameOf(n2) || nameOf2(n2);
+      const id2 = diagramNodeId(n2);
       if (id2)
         keepIds.add(id2);
     }
@@ -166073,7 +166151,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // One registry: each compartment is defined once with the member predicate
   // that fills it, emitted in a single canonical order that satisfies the
   // requirement order (doc → subject → attributes → assume → require →
-  // actors → stakeholders → frame concerns, REQ-183) and the use-case order
+  // actors → stakeholders → frames, REQ-183) and the use-case order
   // (subject → actors → include use cases, REQ-184). Empty compartments are
   // omitted (REQ-181) — except `subject`, which is mandatory on requirement /
   // use-case / verification-case definitions (REQ-183/184) and shows a
@@ -166087,7 +166165,10 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const t = typeText(m);
     return `${dir ? `${dir} ` : ""}${derived}${nameOf2(m) ?? ""}${t ? ` : ${conj}${t}` : ""}`.trim();
   }
-  /** REQ-177/REQ-187 — inherited features (`^name`), dropped when redefined locally. */
+  /** REQ-177/REQ-187 — inherited attributes, dropped when redefined locally.
+   *  Their textual home is selected later by the same classifier as local
+   *  members; retaining the AST member here prevents direction/variability
+   *  from being flattened into `attributes` before classification. */
   inheritedItems(node, index2, uri) {
     if (node.isDef === true)
       return [];
@@ -166104,22 +166185,45 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       }
     }
     const localNames = new Set(membersOf(node).map((m) => nameOf2(m)).filter(Boolean));
-    return membersOf(def).filter((m) => isAttributeDecl(m) && m.isDef !== true && nameOf2(m)).filter((m) => !localRedefined.has(nameOf2(m)) && !localNames.has(nameOf2(m))).map((m) => ({ text: `^${this.featureText(m)}`, source: sourceOf2(m, uri) }));
+    return membersOf(def).filter((m) => isAttributeDecl(m) && m.isDef !== true && nameOf2(m)).filter((m) => !localRedefined.has(nameOf2(m)) && !localNames.has(nameOf2(m))).map((member) => ({ member, source: sourceOf2(member, uri) }));
   }
   compartmentsFor(node, uri, index2, featureRows = false, includeInherited = true) {
     const members = membersOf(node);
     const n2 = node;
     const item = (m, text) => ({ text: text ?? this.featureText(m), source: sourceOf2(m, uri) });
-    const usages = (guard) => members.filter((m) => guard(m) && m.isDef !== true && nameOf2(m));
+    const isVariantConfigMember = (m) => m.allVariants === true;
+    const isVariantMember = (m) => modifiersOf(m).includes("variant") && !isVariantConfigMember(m);
+    const isNonVariantMember = (m) => !isVariantMember(m) && !isVariantConfigMember(m);
+    const isOrdinaryMember = (m) => directionOf(m) === void 0 && isNonVariantMember(m);
+    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 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 = [];
+    const claimedSources = /* @__PURE__ */ new Set();
+    const sourceKey = (source) => `${source.uri}:${source.range.start.line}:${source.range.start.character}:${source.range.end.line}:${source.range.end.character}`;
     const add = (title, items) => {
-      if (items.length)
-        out.push({ title, items });
+      const accepted = items.filter((candidate) => {
+        if (!candidate.source)
+          return true;
+        const key = sourceKey(candidate.source);
+        if (claimedSources.has(key))
+          return false;
+        claimedSources.add(key);
+        return true;
+      });
+      if (!accepted.length)
+        return;
+      const existing = out.find((compartment) => compartment.title === title);
+      if (existing)
+        existing.items.push(...accepted);
+      else
+        out.push({ title, items: accepted });
     };
     add("doc", members.filter((m) => m.$type === "DocCommentMember").map((m) => item(m, notePreview(docCommentBody(m)) ?? "doc")));
-    const subjects = members.filter(isSubjectDecl);
+    const subjects = members.filter(isSubjectDecl).filter(isNonVariantMember);
     const subjectMandatory = n2.isDef === true && (isRequirementDecl(node) || isUseCaseDecl(node) || isVerificationCaseDecl(node));
     if (subjects.length) {
       add("subject", subjects.map((s) => item(s)));
@@ -166128,34 +166232,53 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     }
     add("attributes", [
       ...usages(isAttributeDecl).map((a2) => item(a2)),
-      ...includeInherited ? this.inheritedItems(node, index2, uri) : []
+      ...inheritedRows((member) => isAttributeDecl(member) && isOrdinaryMember(member))
     ]);
+    const notPortion = (m) => portionKindOf(m) === void 0;
     if (featureRows) {
       add("ports", usages(isPortDecl).map((m) => item(m)));
-      add("parts", usages(isPartDecl).map((m) => item(m)));
+      add("parts", usages(isPartDecl).filter(notPortion).map((m) => item(m)));
     }
-    add("features", members.filter((m) => m.$type === "FeatureShorthand" || m.$type === "FeatureRedefinitionShorthand").map((m) => item(m, statementText(m))));
-    const undirected = (guard) => usages(guard).filter((m) => directionOf(m) === void 0);
-    add("items", undirected(isItemDecl).map((m) => item(m)));
-    const occMods = (m) => m.modifiers ?? [];
-    add("occurrences", undirected(isOccurrenceDecl).filter((m) => !occMods(m).includes("timeslice") && !occMods(m).includes("snapshot")).map((m) => item(m)));
+    add("features", members.filter((m) => m.$type === "FeatureShorthand" || m.$type === "FeatureRedefinitionShorthand").filter(isOrdinaryMember).filter((m) => !isOccurrenceModified(m)).map((m) => item(m, canonicalFeatureText(m))));
+    const undirected = (guard) => usages(guard);
+    add("items", undirected(isItemDecl).filter(notPortion).map((m) => item(m)));
+    add("occurrences", undirected(isOccurrenceDecl).filter(notPortion).map((m) => item(m)));
+    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("actors", members.filter(isActorDecl).map((m) => item(m)));
-    add("stakeholders", members.filter(isStakeholderDecl).map((m) => item(m)));
-    add("frame concerns", members.filter((m) => m.$type === "FrameMember").map((m) => item(m, this.refText(m.target) ?? "concern")));
+    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")));
     add("include use cases", members.filter((m) => m.$type === "IncludeStmt").map((m) => item(m, this.refText(m.target) ?? "")));
-    add("objective", members.filter(isObjectiveDecl).map((m) => item(m, nameOf2(m) ?? "objective")));
+    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")));
-    add("parameters", members.filter((m) => directionOf(m) !== void 0 && nameOf2(m)).map((m) => item(m)));
-    add("return", members.filter((m) => m.$type === "ReturnDecl").map((m) => item(m, `return${nameOf2(m) ? ` ${nameOf2(m)}` : ""}${typeText(m) ? ` : ${typeText(m)}` : ""}`)));
+    const behavioralParameterOwner = 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;
+      let owner = node.$container;
+      while (owner) {
+        if (isActionDecl(owner) || isCalcDecl(owner) || isConstraintDecl(owner) || isCaseDecl(owner) || isAnalysisCaseDecl(owner) || isVerificationCaseDecl(owner) || isUseCaseDecl(owner))
+          return true;
+        if (isPartDecl(owner) || isPortDecl(owner))
+          return false;
+        owner = owner.$container;
+      }
+      return false;
+    })();
+    const directedTitle = behavioralParameterOwner || enclosingBehavioralParameterOwner ? "parameters" : "directed features";
+    add(directedTitle, [
+      ...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 enumValueMembers = members.filter((m) => m.$type === "EnumValueDecl" && (isEnumDecl(node) || !m.typing) || isEnumDecl(node) && isEnumDecl(m) && m.isDef !== true);
-    add("enumerations", enumValueMembers.map((m) => {
+    const enumValueMembers = members.filter(isNonVariantMember).filter((m) => m.$type === "EnumValueDecl" && (isEnumDecl(node) || !m.typing) || isEnumDecl(node) && isEnumDecl(m) && m.isDef !== true);
+    add("enums", enumValueMembers.map((m) => {
       const nm = nameOf2(m);
       if (nm)
         return item(m, nm);
@@ -166165,7 +166288,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     add("states", usages(isStateDecl).map((m) => item(m)));
     const stateActions = members.map((m) => ({ m, kind: { EntryAction: "entry", DoAction: "do", ExitAction: "exit" }[m.$type] })).filter((x) => !!x.kind);
     add("state actions", stateActions.map(({ m, kind }) => item(m, `${kind} ${nameOf2(m) ?? ""}`.trim())));
-    add("transitions", members.filter((m) => m.$type === "TransitionDecl").map((m) => item(m, `${m.from ?? ""} \u2192 ${m.to ?? ""}`)));
+    add("state transition", members.filter((m) => m.$type === "TransitionDecl").map((m) => item(m, `${m.from ?? ""} \u2192 ${m.to ?? ""}`)));
     add("assert constraints", members.filter((m) => m.$type === "AssertConstraintStmt").map((m) => item(m, exprText3(m) || nameOf2(m) || "assert constraint")));
     add("invariants", members.filter((m) => m.$type === "InvShorthand").map((m) => {
       const inv = m;
@@ -166173,15 +166296,22 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const expr = exprText3(m);
       return item(m, `${head2} { ${expr} }`.replace(/\s+/g, " ").trim());
     }));
-    add("action flow", usages(isActionDecl).map((m) => item(m)));
+    add("actions", usages(isActionDecl).map((m) => item(m)));
     add("concerns", usages(isConcernDecl).map((m) => item(m)));
     add("viewpoints", usages(isViewpointDecl).map((m) => item(m)));
-    add("exposes", members.filter((m) => m.$type === "ExposeMember").flatMap((m) => (m.paths ?? []).map((p) => item(m, this.featurePath(p) ?? ""))));
+    add("exposes", members.filter((m) => m.$type === "ExposeMember").flatMap((m) => (m.paths ?? []).map((path10) => item(path10, this.featurePath(path10) ?? (path10.$cstNode?.text ?? "").replace(/\s+/g, " ").trim()))));
     add("filters", members.filter((m) => m.$type === "FilterMember").map((m) => item(m, (m.$cstNode?.text ?? "filter").replace(/\s+/g, " ").replace(/^filter\s*/, "").replace(/;$/, "").trim())));
     add("rendering", members.filter((m) => m.$type === "RenderMember").map((m) => item(m, this.refText(m.target) ?? "")));
-    const withMod = (mod) => members.filter((m) => (m.modifiers ?? []).includes(mod) && nameOf2(m));
-    add("timeslices", withMod("timeslice").map((m) => item(m)));
-    add("snapshots", withMod("snapshot").map((m) => item(m)));
+    const portionMembers = members.map((m) => this.thenActionMemberNode(m) ?? m).filter(isNonVariantMember);
+    const withPortionKind = (kind) => portionMembers.filter((m) => portionKindOf(m) === kind && portionLabelOf(m));
+    const portionText = (m) => {
+      const t = typeText(m);
+      const mult = multText(m);
+      return `${portionLabelOf(m)}${t ? ` : ${t}` : ""}${mult ? ` ${mult}` : ""}`;
+    };
+    add("timeslices", withPortionKind("timeslice").map((m) => item(m, portionText(m))));
+    add("snapshots", withPortionKind("snapshot").map((m) => item(m, portionText(m))));
+    add("individuals", portionMembers.filter((m) => m.$type === "FeatureShorthand" && isIndividualOccurrence(m) && portionKindOf(m) === void 0 && portionLabelOf(m)).map((m) => item(m, portionText(m))));
     const metaBadges = [
       ...prefixTagsOf(node).map((t) => `#${t}`),
       ...members.filter((m) => m.$type === "MetadataAnnotation").map((m) => {
@@ -166192,8 +166322,15 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       })
     ];
     add("metadata", metaBadges.map((text) => ({ text })));
-    add("variants", withMod("variant").map((m) => item(m)));
-    add("variant config", members.filter((m) => m.allVariants === true).map((m) => item(m, `${nameOf2(m) ?? ""} = all ${(m.value?.$cstNode?.text ?? "").trim()}`.trim())));
+    add("variants", [
+      ...members.filter((m) => isVariantMember(m) && nameOf2(m)).map((m) => item(m)),
+      ...inheritedRows((member) => isVariantMember(member) && !!nameOf2(member))
+    ]);
+    const variantElementText = (member) => `${nameOf2(member) ?? ""} = all ${(member.value?.$cstNode?.text ?? "").trim()}`.trim();
+    add("variant element usages", [
+      ...members.filter(isVariantConfigMember).map((m) => item(m, variantElementText(m))),
+      ...inheritedRows(isVariantConfigMember, variantElementText)
+    ]);
     add("satisfies", members.filter((m) => m.$type === "SatisfyStmt").map((m) => item(m, String(m.target ?? ""))));
     return out.length ? out : void 0;
   }
@@ -166811,7 +166948,7 @@ function symbolNameFor(node) {
   const redefined = redefinitionTargets(node)[0];
   return redefined ? `:>> ${lastNameSegment(redefined)}` : void 0;
 }
-function isDefinitionNode(node) {
+function isDefinitionNode2(node) {
   return node.isDef === true;
 }
 function isInheritableFeature(node) {
@@ -166951,7 +167088,7 @@ function findNameLeaf(node, name) {
   return void 0;
 }
 function inheritedFeatureSymbols(node, inheritedRange, context, seen = /* @__PURE__ */ new Set()) {
-  if (!isDefinitionNode(node) || seen.has(node))
+  if (!isDefinitionNode2(node) || seen.has(node))
     return [];
   seen.add(node);
   const symbols = [];
@@ -167876,6 +168013,13 @@ var DIAGNOSTIC_MESSAGES = {
   // implicit-redefinition resolution this validator does not yet model.
   RES017_DUPLICATE_MEMBER: (name) => `'${name}' is already declared in this namespace. Members must be distinguishable by name \u2014 rename or remove the duplicate.`,
   RES017_DUPLICATE_SHORT_NAME: (name) => `Short name '<${name}>' is already used in this namespace. Members must be distinguishable \u2014 rename the short name.`,
+  // issue #102 — REQ-387. The filter evaluator (`import-visibility.ts`,
+  // `evaluateFilterCondition`) decides metadata-presence tests and the Boolean
+  // operators over them; every other form fails OPEN, keeping the member. Failing
+  // open is the right default — under-importing would manufacture spurious
+  // RES001s — but an unevaluated filter produces a scope or view that looks
+  // authoritative and is not, so the fail-open is stated rather than assumed.
+  RES018_UNEVALUATED_FILTER: (subject, construct) => `${subject} filter is not evaluated: ${construct} is outside the metadata-filter evaluator, which decides '@'/'@@' metadata tests combined with 'not', 'and'/'&', and 'or'/'|'. The filter fails open \u2014 it is treated as pass-through and removes nothing.`,
   // REQ-007 — SysML v1 → v2 migration guardrail.
   MIG001_V1_KEYWORD: (keyword, v2, note) => `'${keyword}' is a SysML v1 construct, not a SysML v2 keyword. ${note} Use '${v2}'.`,
   MIG002_V1_STEREOTYPE_KNOWN: (stereotype, v2, note) => `SysML v2 has no stereotypes. ${note} Replace \xAB${stereotype}\xBB with '${v2}'.`,
@@ -170333,14 +170477,14 @@ function evaluateFilterCondition(node, metadataTypes, resolveRefs) {
     return node.items.length === 1 ? evaluateFilterCondition(node.items[0], metadataTypes, resolveRefs) : void 0;
   }
   if (isBinExpr(node)) {
-    if (node.op === "and" || node.op === "&") {
+    if (CONJUNCTION_OPERATORS.has(node.op)) {
       const left = evaluateFilterCondition(node.left, metadataTypes, resolveRefs);
       const right = evaluateFilterCondition(node.right, metadataTypes, resolveRefs);
       if (left === false || right === false)
         return false;
       return left === void 0 || right === void 0 ? void 0 : true;
     }
-    if (node.op === "or" || node.op === "|") {
+    if (DISJUNCTION_OPERATORS.has(node.op)) {
       const left = evaluateFilterCondition(node.left, metadataTypes, resolveRefs);
       const right = evaluateFilterCondition(node.right, metadataTypes, resolveRefs);
       if (left === true || right === true)
@@ -170351,6 +170495,42 @@ function evaluateFilterCondition(node, metadataTypes, resolveRefs) {
   }
   return void 0;
 }
+var CONJUNCTION_OPERATORS = /* @__PURE__ */ new Set(["and", "&"]);
+var DISJUNCTION_OPERATORS = /* @__PURE__ */ new Set(["or", "|"]);
+function undecidableFilterCondition(condition) {
+  if (!condition)
+    return void 0;
+  if (isSelfClassifyExpr(condition)) {
+    return condition.op === "@" || condition.op === "@@" ? void 0 : { node: condition, construct: `the '${condition.op}' classification operator` };
+  }
+  if (isNotExpr(condition) && condition.operand) {
+    return undecidableFilterCondition(condition.operand);
+  }
+  if (condition.$type === "NotExpr")
+    return void 0;
+  if (isParenExpr(condition)) {
+    return condition.items.length === 1 ? undecidableFilterCondition(condition.items[0]) : { node: condition, construct: "a parenthesized expression list" };
+  }
+  if (isBinExpr(condition)) {
+    if (CONJUNCTION_OPERATORS.has(condition.op) || DISJUNCTION_OPERATORS.has(condition.op)) {
+      return undecidableFilterCondition(condition.left) ?? undecidableFilterCondition(condition.right);
+    }
+    return { node: condition, construct: `the '${condition.op}' operator` };
+  }
+  return { node: condition, construct: describeFilterExpr(condition) };
+}
+function describeFilterExpr(node) {
+  if (isPostfixOp(node)) {
+    if ((node.dot || node.select) && node.field)
+      return `the '.${node.field}' feature access`;
+    if (node.arrow && node.invoke)
+      return `the '->${node.invoke}' invocation`;
+    return "this postfix expression";
+  }
+  if (isPathExpr(node))
+    return "a plain feature reference";
+  return "this expression form";
+}
 function attachedMetadataTypes(node, resolveRefs) {
   const siblings = node.$container?.members;
   if (!Array.isArray(siblings))
@@ -170579,6 +170759,26 @@ function actionOnlyConstruct(node) {
   const keyword = CONTROL_NODE_KEYWORDS[node.$type];
   return keyword ? { construct: `A '${keyword}' control node`, clause: "7.17.3" } : void 0;
 }
+function portionKindOf2(node) {
+  const mods = node.modifiers;
+  if (!Array.isArray(mods))
+    return void 0;
+  return mods.find((m) => m === "timeslice" || m === "snapshot");
+}
+var NAMESPACE_ONLY_TYPES = /* @__PURE__ */ new Set(["Package", "Document", "NamespaceDecl"]);
+function owningTypeOf(node) {
+  let owner = node.$container;
+  while (owner && (owner.$type === "PrefixMetadataMember" || owner.$type === "ThenActionMember")) {
+    owner = owner.$container;
+  }
+  if (!owner)
+    return void 0;
+  return NAMESPACE_ONLY_TYPES.has(owner.$type) ? void 0 : owner;
+}
+function declLabel(node, kind) {
+  const name = node.name;
+  return name ? `'${name}'` : `this '${kind}'`;
+}
 var SysmlValidator = class _SysmlValidator {
   indexManager;
   langiumDocuments;
@@ -170802,6 +171002,7 @@ var SysmlValidator = class _SysmlValidator {
     this.checkLanguageDisjointness(node, accept);
     this.checkKermlWellFormedness(node, accept);
     this.checkFilterExpressions(node, accept);
+    this.checkOccurrencePortions(node, accept);
     this.checkCrossReferences(node, accept);
     this.checkAutoImportSuggestions(node, accept);
     this.checkUnits(node, accept);
@@ -171629,6 +171830,7 @@ ${baseIndent}}`;
   checkCrossReferences(node, accept) {
     const index2 = this.buildIndex();
     const imports = [];
+    const exposePaths = [];
     const decls = [];
     const verifyStmts = [];
     const satisfyStmts = [];
@@ -171640,7 +171842,9 @@ ${baseIndent}}`;
         const path10 = importedPath(child);
         if (alias && path10 && importWildcard(child) === "none")
           aliasMap.set(alias, path10);
-      } else if (isVerifyStmt(child))
+      } else if (isExposePath(child))
+        exposePaths.push(child);
+      else if (isVerifyStmt(child))
         verifyStmts.push(child);
       else if (isSatisfyStmt(child))
         satisfyStmts.push(child);
@@ -171656,6 +171860,7 @@ ${baseIndent}}`;
     this.checkPrivateImports(imports, index2, accept);
     this.checkPrivateWildcardReferences(node, imports, index2, accept);
     this.checkImportCycles(imports, index2, accept);
+    this.checkUnevaluatedFilters(imports, exposePaths, accept);
     if (sysmlDiagnosticSettings.unusedImports !== "off") {
       this.checkUnusedImports(node, imports, index2, sysmlDiagnosticSettings.unusedImports, accept);
     }
@@ -171685,6 +171890,49 @@ ${baseIndent}}`;
       this.checkTypeComposition(decl, index2, accept);
     }
   }
+  // ══════════════════════════════════════════════════════════════════════
+  // REQ-160 — occurrence portions: `timeslice` / `snapshot` well-formedness
+  // ══════════════════════════════════════════════════════════════════════
+  // The declaration kinds that are NOT occurrences, so a portion of their life is
+  // meaningless. Kept as a deny-list rather than an allow-list because nearly every
+  // SysML usage kind IS an OccurrenceUsage (part, item, action, state, port,
+  // connection, case, …) while the data-valued ones are few and closed: an
+  // AttributeUsage is typed by a DataType and an enumeration is a special attribute,
+  // neither of which has a life to carve up.
+  static NON_OCCURRENCE_OWNER_TYPES = /* @__PURE__ */ new Set(["AttributeDecl", "EnumDecl", "EnumValueDecl", "MetadataDecl", "MultiplicityDecl"]);
+  // REQ-160 — OMG SysML v2 §8.2.2.9 (Occurrences) with the Kernel Semantic Library
+  // `Occurrences::TimeSlice` / `Occurrences::Snapshot`:
+  //
+  //  SSM015 — a portion is a portion OF something. Its owning type must be an
+  //           occurrence; declared at package level (or inside an attribute /
+  //           enumeration body) there is no life for it to be a portion of.
+  //  SSM016 — `Snapshot :> TimeSlice` with a zero duration: a snapshot is the
+  //           occurrence at ONE instant. Every portion of a zero-duration
+  //           occurrence is itself zero-duration, so a snapshot may own further
+  //           snapshots but never a `timeslice`.
+  //
+  // Both are structural — they read modifiers and owners only — so they hold
+  // without resolving a single cross-reference.
+  checkOccurrencePortions(node, accept) {
+    for (const child of ast_utils_exports.streamAllContents(node)) {
+      const kind = portionKindOf2(child);
+      if (!kind)
+        continue;
+      const label = declLabel(child, kind);
+      const owner = owningTypeOf(child);
+      if (!owner) {
+        accept(severity("SSM015", "error"), `A '${kind}' is a portion of an occurrence's life, so ${label} must be declared inside an occurrence \u2014 not directly in a package.`, { node: child, code: "SSM015" });
+        continue;
+      }
+      if (_SysmlValidator.NON_OCCURRENCE_OWNER_TYPES.has(owner.$type)) {
+        accept(severity("SSM015", "error"), `A '${kind}' is a portion of an occurrence's life, and '${owner.name ?? owner.$type}' is not an occurrence.`, { node: child, code: "SSM015" });
+        continue;
+      }
+      if (kind === "timeslice" && portionKindOf2(owner) === "snapshot") {
+        accept(severity("SSM016", "error"), `A 'snapshot' is a zero-duration timeslice, so ${label} cannot be a timeslice of it \u2014 a portion of an instant is itself a snapshot.`, { node: child, code: "SSM016" });
+      }
+    }
+  }
   // REQ-328 — KSM008: a `filter` membership condition must be Boolean. Only a
   // *definitely* non-Boolean expression is flagged — a string or numeric/quantity
   // literal, or an arithmetic/range binary expression. A bare feature path is left
@@ -172231,6 +172479,34 @@ ${baseIndent}}`;
     }
     return false;
   }
+  /**
+   * REQ-387 — RES018: an `import` or `expose` filter the metadata-filter
+   * evaluator cannot decide (issue #102).
+   *
+   * The evaluator keeps a member it cannot decide, so an unevaluated filter
+   * silently contributes the members it was written to exclude — a scope or a
+   * view that reads as authoritative and is not. Failing open stays (narrowing
+   * on a guess would manufacture unresolved-name errors); what changes is that
+   * the model now says so at the filter that is not applied.
+   *
+   * Default severity is `info` rather than a warning: the model is legal and the
+   * limitation is this evaluator's, not the author's. Teams that want an
+   * unevaluated filter to break a build raise it per code through
+   * `sysml.validation.severities` (REQ-240).
+   */
+  checkUnevaluatedFilters(imports, exposePaths, accept) {
+    const report2 = (condition, subject) => {
+      const undecidable = undecidableFilterCondition(condition);
+      if (!undecidable)
+        return;
+      accept(severity("RES018", "info"), DIAGNOSTIC_MESSAGES.RES018_UNEVALUATED_FILTER(subject, undecidable.construct), { node: undecidable.node, code: "RES018" });
+    };
+    for (const imp of imports)
+      for (const filter4 of imp.filters)
+        report2(filter4.condition, "Import");
+    for (const path10 of exposePaths)
+      report2(path10.condition, "Expose");
+  }
   // REQ-324 — RES009 unused import (configurable, OFF by default)
   checkUnusedImports(root4, imports, index2, level, accept) {
     if (imports.length === 0)
@@ -176534,6 +176810,7 @@ function readProjectConfig(root4) {
 // ../extension/src/webview/diagram/flow/diagram-rules.ts
 var PORT_GLYPH_SIZE = 20;
 var PORT_GLYPH_HALF = PORT_GLYPH_SIZE / 2;
+var FEATURE_COMPARTMENT_CLEARANCE = PORT_GLYPH_HALF + 12;
 var ACTION_PIN_GLYPH_SIZE = PORT_GLYPH_SIZE;
 function endpointGlyphSize(endpoint) {
   return endpoint.pin ? ACTION_PIN_GLYPH_SIZE : PORT_GLYPH_SIZE;
@@ -176576,18 +176853,26 @@ var DOCK_TANGENT = {
   left: { x: 0, y: 1 },
   right: { x: 0, y: 1 }
 };
-function portGlyphRect(g, w, h) {
-  const base = sidePoint(g.side, g.offset, w, h);
-  const t = DOCK_TANGENT[g.side];
-  const n2 = DOCK_NORMAL[g.side];
-  const shift = g.shift ?? { along: 0, across: 0 };
-  const cx = base.x + t.x * shift.along + n2.x * shift.across;
-  const cy = base.y + t.y * shift.along + n2.y * shift.across;
+function portGlyphRect(g, w, h, topReserve = 0) {
   const natural = endpointGlyphSize(g.port);
   const along = g.along ?? natural;
   const toggleRun = g.toggleRun ?? 0;
   const across = g.across ?? (along - toggleRun > natural ? NESTED_PORT_HOST_ACROSS : natural);
   const vertical = g.side === "left" || g.side === "right";
+  const base = sidePoint(g.side, g.offset, w, h, topReserve);
+  const t = DOCK_TANGENT[g.side];
+  const n2 = DOCK_NORMAL[g.side];
+  const shift = g.shift ?? { along: 0, across: 0 };
+  const rawCx = base.x + t.x * shift.along + n2.x * shift.across;
+  const rawCy = base.y + t.y * shift.along + n2.y * shift.across;
+  const run = sideLength(g.side, w, h, topReserve);
+  const alongCentre = vertical ? rawCy : rawCx;
+  const rootAlong = g.rootAlong ?? along;
+  const rootCentre = vertical ? base.y : base.x;
+  const boundedRootCentre = topReserve > 0 && vertical ? run >= rootAlong ? Math.max(topReserve + rootAlong / 2, Math.min(topReserve + run - rootAlong / 2, rootCentre)) : topReserve + run / 2 : rootCentre;
+  const boundedAlong = alongCentre + boundedRootCentre - rootCentre;
+  const cx = vertical ? rawCx : boundedAlong;
+  const cy = vertical ? boundedAlong : rawCy;
   const width = vertical ? across : along;
   const height = vertical ? along : across;
   return {
@@ -176661,18 +176946,40 @@ var DOCK_NORMAL = {
   bottom: { x: 0, y: 1 },
   left: { x: -1, y: 0 }
 };
-function sidePoint(side, offset2, w, h) {
+function portSideHeight(h, topReserve = 0) {
+  const band = Number.isFinite(topReserve) ? Math.max(0, Math.min(Math.max(0, h), topReserve)) : 0;
+  return Math.max(0, h - band);
+}
+function sidePoint(side, offset2, w, h, topReserve = 0) {
+  const top = h - portSideHeight(h, topReserve);
+  const sideH = portSideHeight(h, topReserve);
   switch (side) {
     case "top":
       return { x: w * offset2, y: 0 };
     case "bottom":
       return { x: w * offset2, y: h };
     case "left":
-      return { x: 0, y: h * offset2 };
+      return { x: 0, y: top + sideH * offset2 };
     case "right":
-      return { x: w, y: h * offset2 };
+      return { x: w, y: top + sideH * offset2 };
   }
 }
+function nearestPortOwnerPlacement(x, y, w, h, topReserve = 0) {
+  const sideH = portSideHeight(h, topReserve);
+  const top = h - sideH;
+  const clamp3 = (value, lo, hi) => Math.max(lo, Math.min(hi, value));
+  const distanceSq = (px, py, qx, qy) => (px - qx) ** 2 + (py - qy) ** 2;
+  const sideY = clamp3(y, top, h);
+  const offsetY = sideH > 0 ? (sideY - top) / sideH : 0.5;
+  const candidates = [
+    { side: "left", offset: offsetY, distance: distanceSq(x, y, 0, sideY) },
+    { side: "right", offset: offsetY, distance: distanceSq(x, y, w, sideY) },
+    { side: "top", offset: w > 0 ? clamp3(x, 0, w) / w : 0.5, distance: distanceSq(x, y, clamp3(x, 0, w), 0) },
+    { side: "bottom", offset: w > 0 ? clamp3(x, 0, w) / w : 0.5, distance: distanceSq(x, y, clamp3(x, 0, w), h) }
+  ];
+  const best = candidates.reduce((nearest, candidate) => candidate.distance < nearest.distance ? candidate : nearest);
+  return { side: best.side, offset: best.offset };
+}
 var SIDE_ANCHOR_SEP = ":";
 var CONNECT_POINT_SPACING_DEFAULT = 24;
 var CONNECT_POINT_SPACING_MIN = 8;
@@ -176705,12 +177012,12 @@ function centerOutOffsetOrder(offsets) {
 function sidePointOffsetsForLength(length2, spacing) {
   return sidePointOffsets(connectPointCountForLength(length2, spacing));
 }
-function sideLength(side, w, h) {
-  return side === "top" || side === "bottom" ? w : h;
+function sideLength(side, w, h, topReserve = 0) {
+  return side === "top" || side === "bottom" ? w : portSideHeight(h, topReserve);
 }
 var SENDACCEPT_NOTCH = 14;
-function sideEffectiveLength(shape, side, w, h) {
-  const raw = sideLength(side, w, h);
+function sideEffectiveLength(shape, side, w, h, topReserve = 0) {
+  const raw = sideLength(side, w, h, topReserve);
   switch (shape) {
     case "usecase":
       return raw * 0.82;
@@ -176725,7 +177032,7 @@ function sideEffectiveLength(shape, side, w, h) {
       return raw;
   }
 }
-function sideSurfacePoint(shape, side, offset2, w, h) {
+function sideSurfacePoint(shape, side, offset2, w, h, topReserve = 0) {
   const cx = w / 2;
   const cy = h / 2;
   switch (shape) {
@@ -176753,22 +177060,22 @@ function sideSurfacePoint(shape, side, offset2, w, h) {
     case "send": {
       if (side === "top" || side === "bottom") return { x: (w - SENDACCEPT_NOTCH) * offset2, y: side === "top" ? 0 : h };
       if (side === "right") return { x: w, y: cy };
-      return sidePoint(side, offset2, w, h);
+      return sidePoint(side, offset2, w, h, topReserve);
     }
     case "accept": {
       if (side === "left") return { x: SENDACCEPT_NOTCH, y: cy };
-      return sidePoint(side, offset2, w, h);
+      return sidePoint(side, offset2, w, h, topReserve);
     }
     default:
-      return sidePoint(side, offset2, w, h);
+      return sidePoint(side, offset2, w, h, topReserve);
   }
 }
 function isPackageEndpoint(shape, keyword) {
   if (shape === "package") return true;
   return (keyword ?? "").trim().toLowerCase() === "package";
 }
-function sidePointOffsetsFor(side, w, h, spacing, connectable, shape) {
-  return connectable ? sidePointOffsetsForLength(sideEffectiveLength(shape, side, w, h), spacing) : [0.5];
+function sidePointOffsetsFor(side, w, h, spacing, connectable, shape, topReserve = 0) {
+  return connectable ? sidePointOffsetsForLength(sideEffectiveLength(shape, side, w, h, topReserve), spacing) : [0.5];
 }
 function sideAnchorHandleId(side, offset2) {
   return Math.abs(offset2 - 0.5) < 1e-6 ? side : `${side}${SIDE_ANCHOR_SEP}${offset2.toFixed(3)}`;
@@ -176809,6 +177116,50 @@ function clampDockSide(encoded, portSide) {
 }
 var PORT_PLUS_GAP = 7;
 var PORT_PLUS_HALF = 4;
+var NODE_USAGE_CORNER_RADIUS = 14;
+var NODE_ROUNDED_USAGE_RADIUS = 20;
+var NODE_ROUNDED_TITLED_RADIUS = 12;
+function nodeCornerRadius(shape, isDef, height, titled) {
+  if (isDef) return 0;
+  if (shape === "action" || shape === "state") {
+    const r = Math.min(height / 2, NODE_ROUNDED_USAGE_RADIUS);
+    return titled ? Math.min(r, NODE_ROUNDED_TITLED_RADIUS) : r;
+  }
+  return NODE_USAGE_CORNER_RADIUS;
+}
+var FRAME_USAGE_CORNER_RADIUS = 12;
+var CONTAINER_CONTROL_SIZE = 20;
+var CONTAINER_CONTROL_GAP = 1;
+var CONTAINER_CONTROLS_RIGHT = 2;
+function containerControlsInset(cornerRadius) {
+  return Math.max(CONTAINER_CONTROLS_RIGHT, Math.ceil(cornerRadius * (1 - Math.SQRT1_2)));
+}
+var CONTAINER_CONTROLS_INSET_MAX = containerControlsInset(NODE_ROUNDED_USAGE_RADIUS);
+var CONTAINER_TITLE_RIGHT_RESERVE = 2 * CONTAINER_CONTROL_SIZE + CONTAINER_CONTROL_GAP + CONTAINER_CONTROLS_INSET_MAX + 11;
+var COLLAPSED_CONTAINER_MIN_WIDTH = CONTAINER_TITLE_RIGHT_RESERVE + 48;
+var CONTAINER_GLYPH_VIEWBOX = 20;
+var CONTAINER_GLYPH_EXTENT = 11;
+function containerTitleArea(ownerWidth, controlsVisible) {
+  const width = Math.max(0, ownerWidth - (controlsVisible ? CONTAINER_TITLE_RIGHT_RESERVE : 0));
+  return { centerX: width / 2, width };
+}
+var NODE_COMPARTMENT_TOP = 30;
+var FRAME_TITLE_HEIGHT = NODE_COMPARTMENT_TOP;
+function containerTitleHeight(isFrame) {
+  return isFrame ? FRAME_TITLE_HEIGHT : NODE_COMPARTMENT_TOP;
+}
+var CONTAINER_TITLE_KIND_BASELINE = 14;
+var CONTAINER_TITLE_NAME_BASELINE = 28;
+function containerTopReserve(bandHeight, isFrame) {
+  return bandHeight && bandHeight > 0 ? containerTitleHeight(isFrame) + bandHeight : 0;
+}
+var COMPARTMENT_TITLE_HEIGHT = 16;
+var COMPARTMENT_ROW_HEIGHT = 14;
+var COMPARTMENT_TITLE_BASELINE = 12;
+var COMPARTMENT_ROW_BASELINE = 26;
+function compartmentBlockHeight(items) {
+  return COMPARTMENT_TITLE_HEIGHT + items * COMPARTMENT_ROW_HEIGHT;
+}
 function portLabelPlacement(side, x, y, label, half = PORT_GLYPH_HALF, alongHalf = half) {
   const vertical = side === "left" || side === "right";
   const halfX = vertical ? half : alongHalf;
@@ -176846,18 +177197,20 @@ function edgeRouteKey(e, duplicateIndex = 0) {
   const name = e.name ?? e.label;
   return `${e.kind}:${e.from}->${e.to}${name ? `:${name}` : ""}${duplicateIndex > 0 ? `~${duplicateIndex}` : ""}`;
 }
-var GV_TREE_EDGE_KIND_LIST = ["owningMembership", "composition", "reference", "definedBy"];
+var GV_TREE_EDGE_KIND_LIST = ["owningMembership", "composition", "portion", "reference", "definedBy"];
 var GV_TREE_EDGE_KINDS = new Set(GV_TREE_EDGE_KIND_LIST);
-var GV_TREE_HIERARCHY_EDGE_KIND_LIST = ["owningMembership", "composition"];
+var GV_TREE_HIERARCHY_EDGE_KIND_LIST = ["owningMembership", "composition", "portion"];
 var GV_TREE_HIERARCHY_EDGE_KINDS = new Set(GV_TREE_HIERARCHY_EDGE_KIND_LIST);
 function gvModeEdges(model, mode) {
   if (mode === "group") return [];
-  return model.edges.some((edge) => edge.kind === "owningMembership") ? model.edges.filter((edge) => edge.kind !== "owningMembership") : model.edges;
+  const packageIds = new Set(model.nodes.filter((node) => node.shape === "package").map((node) => node.id));
+  const drawn = (edge) => edge.kind !== "owningMembership" && !packageIds.has(edge.from) && !packageIds.has(edge.to);
+  return model.edges.every(drawn) ? model.edges : model.edges.filter(drawn);
 }
 function isGvUsageNode(n2) {
   return n2.meta?.gvUsage === true;
 }
-var GV_BOXED_USAGE_COMPARTMENTS = /* @__PURE__ */ new Set(["parts", "occurrences"]);
+var GV_BOXED_USAGE_COMPARTMENTS = /* @__PURE__ */ new Set(["parts", "occurrences", "timeslices", "snapshots", "individuals"]);
 function stripBoxedUsageCompartments(nodes) {
   let changed = false;
   const out = nodes.map((n2) => {
@@ -176898,7 +177251,8 @@ var GV_CATEGORIES = [
 function gvNodeCategory(node) {
   if (node.shape === "package") return "package";
   if (node.shape === "annotation" || node.shape === "dot") return "annotation";
-  const k = node.keyword.toLowerCase().trim().replace(/^(individual|timeslice|snapshot|parallel|variation|variant|abstract|ref|derived)\s+/g, "").replace(/\s+def$/, "").trim();
+  const k = node.keyword.toLowerCase().trim().replace(/^(individual|timeslice|snapshot|parallel|variation|variant|abstract|ref|derived)(\s+|$)/g, "").replace(/\s+def$/, "").trim();
+  if (k === "" || k === "def") return "item";
   const alias = {
     part: "part",
     port: "port",
@@ -176952,9 +177306,19 @@ function twKind(text) {
 function compartmentHeight(node) {
   if (!node.compartments?.length) return 0;
   let h = 0;
-  for (const c of node.compartments) h += 16 + c.items.length * 16;
+  for (const c of node.compartments) h += compartmentBlockHeight(c.items.length);
   return h;
 }
+function featureCompartmentBandHeight(node) {
+  if (node?.meta?.featureCompartmentsVisible !== true || !node.compartments?.length) return 0;
+  return compartmentHeight(node) + FEATURE_COMPARTMENT_CLEARANCE;
+}
+function frameFeatureCompartmentHeight(frame2) {
+  return featureCompartmentBandHeight(frame2);
+}
+function featureBandTopReserve(data) {
+  return containerTopReserve(data.featureCompartmentHeight, data.frame !== void 0);
+}
 function titleWidth(node) {
   let t = `${node.name}${node.type ? ` : ${node.type}` : ""}`;
   if (node.multiplicity) t += ` ${node.multiplicity}`;
@@ -177013,10 +177377,11 @@ function nodeSize(node, direction) {
   const sideLabelW = (side) => ph.filter((p) => p.side === side).reduce((m, p) => Math.max(m, tw(p.port.name, 9) + 18), 0);
   const portsW = ph.length ? sideLabelW("left") + sideLabelW("right") + 56 : 0;
   const portRows = Math.max(ph.filter((p) => p.side === "left").length, ph.filter((p) => p.side === "right").length);
+  const titleRightReserve = node.meta?.containerControls === true || node.meta?.internalsHidden === true ? CONTAINER_TITLE_RIGHT_RESERVE : 0;
   const w = Math.max(
     NODE_W,
-    titleWidth(node) + 2 * PAD,
-    twKind(`\xAB${node.keyword}\xBB`) + 2 * PAD,
+    titleWidth(node) + 2 * PAD + titleRightReserve,
+    twKind(`\xAB${node.keyword}\xBB`) + 2 * PAD + titleRightReserve,
     compartmentWidth(node) + 2 * PAD,
     portsW,
     // issue #108 — an elongated port on the top/bottom edge widens the owner,
@@ -177024,13 +177389,15 @@ function nodeSize(node, direction) {
     portedSideLength(ph, "top"),
     portedSideLength(ph, "bottom")
   );
-  const h = Math.max(
+  const featureH = featureCompartmentBandHeight(node);
+  const bodyH = Math.max(
     BOX_H,
-    36 + compartmentHeight(node),
+    featureH > 0 ? 0 : 36 + compartmentHeight(node),
     portRows ? 40 + portRows * 24 + 8 : 0,
     portedSideLength(ph, "left"),
     portedSideLength(ph, "right")
   );
+  const h = bodyH + featureH;
   return { w, h };
 }
 function frameMinSize(f) {
@@ -177038,13 +177405,21 @@ function frameMinSize(f) {
   const sideLabelW = (side) => ports.filter((p) => p.side === side).reduce((m, p) => Math.max(m, tw(p.port.name, 9) + 18), 0);
   const headerW = twKind(`\xAB${f.keyword}\xBB`) + tw(f.label, 11) + 28;
   const portsW = sideLabelW("left") + sideLabelW("right") + 56;
-  const w = Math.max(160, headerW, portsW, portedSideLength(ports, "top"), portedSideLength(ports, "bottom"));
+  const featureH = frameFeatureCompartmentHeight(f);
+  const w = Math.max(
+    160,
+    headerW,
+    portsW,
+    ...featureH > 0 ? [compartmentWidth(f) + 2 * PAD] : [],
+    portedSideLength(ports, "top"),
+    portedSideLength(ports, "bottom")
+  );
   const portRows = Math.max(ports.filter((p) => p.side === "left").length, ports.filter((p) => p.side === "right").length);
   const h = Math.max(
-    58,
-    36 + portRows * 24,
-    portedSideLength(ports, "left"),
-    portedSideLength(ports, "right")
+    58 + featureH,
+    36 + portRows * 24 + featureH,
+    featureH + portedSideLength(ports, "left"),
+    featureH + portedSideLength(ports, "right")
   );
   return { w, h };
 }
@@ -177180,6 +177555,7 @@ function assignPortHandles(ports, overrides) {
         side,
         offset: +(PORT_BAND_START + centre * PORT_BAND_LENGTH).toFixed(4),
         along: alongs[i],
+        rootAlong: alongs[i] ?? endpointGlyphSize(port),
         across: alongs[i] === void 0 ? void 0 : metricsOf(port).across,
         toggleRun: toggleRunOf(port) || void 0
       };
@@ -177211,6 +177587,7 @@ function assignPortHandles(ports, overrides) {
         side: parent.side,
         offset: parent.offset,
         shift: { along: (parent.shift?.along ?? 0) + slot.along, across: slot.across },
+        rootAlong: parent.rootAlong ?? parent.along ?? endpointGlyphSize(parent.port),
         ...hasToggle(kid) ? { along, across, toggleRun: toggleRunOf(kid) } : {}
       };
       nestedHandles.push(handle);
@@ -177220,10 +177597,10 @@ function assignPortHandles(ports, overrides) {
   for (const parent of topHandles) placeChildren(parent);
   return [...topHandles, ...nestedHandles];
 }
-function sizeWithOverride(base, o) {
+function sizeWithOverride(base, o, minimum = { w: 48, h: 24 }) {
   return {
-    w: o?.w !== void 0 ? Math.max(48, o.w) : base.w,
-    h: o?.h !== void 0 ? Math.max(24, o.h) : base.h
+    w: o?.w !== void 0 ? Math.max(minimum.w, o.w) : base.w,
+    h: o?.h !== void 0 ? Math.max(minimum.h, o.h) : base.h
   };
 }
 function normalizeIvModel(model) {
@@ -177258,6 +177635,7 @@ function promoteIvLeafPartsToFrames(model) {
       const existing = frames[existingIndex];
       frames[existingIndex] = {
         ...existing,
+        layoutKey: n2.layoutKey ?? existing.layoutKey,
         label: n2.name || existing.label,
         isDef: n2.isDef ?? existing.isDef,
         type: n2.type ?? existing.type,
@@ -177275,6 +177653,7 @@ function promoteIvLeafPartsToFrames(model) {
     if (isAnchor || isLeafUsagePart) {
       frames.push({
         id: n2.id,
+        layoutKey: n2.layoutKey,
         label: n2.name,
         keyword: n2.keyword,
         parent: n2.frame,
@@ -177332,13 +177711,11 @@ function applyCaseDefs(model, show) {
     edges
   };
 }
-function collapseIvModel(model, collapsed) {
+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(
-    Object.entries(collapsed).filter(([, c]) => c).map(([id2]) => id2).filter((id2) => frameById.get(id2)?.keyword !== "package" && frameById.get(id2)?.meta?.anchorFrame !== true)
-  );
+  const requested = new Set(frames.filter((frame2) => 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;
@@ -177371,6 +177748,7 @@ function collapseIvModel(model, collapsed) {
     if (!f) return [];
     return [{
       id: f.id,
+      layoutKey: f.layoutKey,
       name: f.label,
       keyword: f.keyword,
       isDef: f.isDef ?? false,
@@ -177381,7 +177759,7 @@ function collapseIvModel(model, collapsed) {
       compartments: f.compartments,
       frame: f.parent,
       source: f.source,
-      meta: { ...f.meta, ivCollapsed: true }
+      meta: { ...f.meta, internalsHidden: true }
     }];
   });
   return {
@@ -177394,22 +177772,67 @@ function collapseIvModel(model, collapsed) {
 function isCollapsibleActionFrame(frame2) {
   return frame2.meta?.compositeAction === true && frame2.meta?.anchorFrame !== true;
 }
+function isCollapsibleStateFrame(frame2) {
+  return frame2.meta?.composite === true && frame2.meta?.anchorFrame !== true;
+}
 function frameStateKey(frame2) {
   return frame2.layoutKey ?? frame2.id;
 }
+function framePresentationEnabled(current2, frame2, acceptLegacyDisplayId = false, whenAbsent = false) {
+  const key = frameStateKey(frame2);
+  if (Object.prototype.hasOwnProperty.call(current2, key)) return current2[key] === true;
+  if (acceptLegacyDisplayId && key !== frame2.id && Object.prototype.hasOwnProperty.call(current2, frame2.id)) {
+    return current2[frame2.id] === true;
+  }
+  return whenAbsent;
+}
 function isCollapsibleFrame(kind, frame2) {
   if (frame2.meta?.anchorFrame === true) return false;
   if (kind === "iv") return frame2.keyword !== "package";
   if (kind === "afv") return isCollapsibleActionFrame(frame2);
+  if (kind === "stv") return isCollapsibleStateFrame(frame2);
+  return false;
+}
+function isFeatureCompartmentNode(kind, node) {
+  if (node.meta?.internalsHidden === true) return false;
+  if (node.meta?.boundary === true || node.meta?.boundaryBox === true) return false;
+  if (kind === "iv") return node.shape === "box" && /\b(?:part|item)\b/i.test(node.keyword);
+  if (kind === "afv") return node.shape === "action";
+  if (kind === "stv") return node.shape === "state";
   return false;
 }
-function collapseActionFrames(model, collapsed) {
+function applyFeatureCompartmentVisibility(model, visibleFeatureCompartments, hiddenInternals = {}) {
+  if (!CONTAINER_PRESENTATION_KINDS.has(model.kind)) return model;
+  const legacy = model.kind === "iv";
+  let changed = false;
+  const project = (host, leaf) => {
+    const visible = framePresentationEnabled(visibleFeatureCompartments, host, legacy, leaf);
+    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;
+    changed = true;
+    return {
+      ...host,
+      compartments,
+      meta: {
+        ...host.meta,
+        containerControls: true,
+        featureCompartmentsVisible: visible,
+        ...leaf ? { internalsHidden } : {}
+      }
+    };
+  };
+  const frames = (model.frames ?? []).map((frame2) => isCollapsibleFrame(model.kind, frame2) ? project(frame2, false) : frame2);
+  const nodes = model.nodes.map((node) => isFeatureCompartmentNode(model.kind, node) ? project(node, true) : node);
+  return changed ? { ...model, frames, nodes } : model;
+}
+var CONTAINER_PRESENTATION_KINDS = /* @__PURE__ */ new Set(["iv", "afv", "stv"]);
+function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActionFrame, collapsedShape = "action") {
   const frames = model.frames ?? [];
   if (!frames.length) return model;
   const frameById = new Map(frames.map((f) => [f.id, f]));
-  const on = new Set(Object.entries(collapsed).filter(([, value]) => value).map(([key]) => key));
   const requested = new Set(
-    frames.filter((f) => on.has(frameStateKey(f)) && isCollapsibleActionFrame(f)).map((f) => f.id)
+    frames.filter((f) => framePresentationEnabled(hiddenInternals, f) && isHost(f)).map((f) => f.id)
   );
   if (requested.size === 0) return model;
   const rootOf = (id2) => {
@@ -177448,17 +177871,18 @@ function collapseActionFrames(model, collapsed) {
     if (!f) return [];
     return [{
       id: f.id,
+      layoutKey: f.layoutKey,
       name: f.label,
       keyword: f.keyword,
       isDef: f.isDef ?? false,
-      shape: "action",
+      shape: collapsedShape,
       type: f.type,
       multiplicity: f.multiplicity,
       ports: f.ports,
       compartments: f.compartments,
       frame: f.parent,
       source: f.source,
-      meta: { ...f.meta, actionCollapsed: true }
+      meta: { ...f.meta, internalsHidden: true }
     }];
   });
   const seenEdge = /* @__PURE__ */ new Set();
@@ -177498,8 +177922,13 @@ function modelToFlow(model, opts) {
   model = collapseNestedPorts(model, opts.nestedPorts ?? {});
   if (model.kind === "iv") model = normalizeIvModel(model);
   if (model.kind === "iv" && (model.meta?.overview === true || model.meta?.unified === true)) model = promoteIvLeafPartsToFrames(model);
-  if (model.kind === "iv" && opts.ivCompartments) model = collapseIvModel(model, opts.ivCompartments);
-  if (model.kind === "afv" && opts.collapsedActions) model = collapseActionFrames(model, opts.collapsedActions);
+  const legacyPresentation = model.kind === "iv" ? opts.ivCompartments : model.kind === "afv" ? opts.collapsedActions : void 0;
+  const hiddenInternals = opts.hiddenInternals ?? legacyPresentation ?? {};
+  const visibleFeatureCompartments = opts.visibleFeatureCompartments ?? legacyPresentation ?? {};
+  model = applyFeatureCompartmentVisibility(model, visibleFeatureCompartments, hiddenInternals);
+  if (model.kind === "iv") model = collapseIvModel(model, hiddenInternals);
+  if (model.kind === "afv") model = collapseActionFrames(model, hiddenInternals);
+  if (model.kind === "stv") model = collapseActionFrames(model, hiddenInternals, isCollapsibleStateFrame, "state");
   if (model.kind === "cv" && opts.subjectBoundary) model = applyCaseBoundary(model);
   const ov = opts.overrides ?? {};
   const nodes = [];
@@ -177528,7 +177957,13 @@ function modelToFlow(model, opts) {
   }
   const orderedFrames = [...frames].sort((a2, b) => frameDepth(a2.id) - frameDepth(b.id));
   for (const f of orderedFrames) {
-    const size = sizeWithOverride(frameMinSize(f), ov[f.layoutKey ?? f.id]);
+    const natural = frameMinSize(f);
+    const featureH = frameFeatureCompartmentHeight(f);
+    const size = sizeWithOverride(
+      natural,
+      ov[f.layoutKey ?? f.id],
+      { w: 48, h: featureH > 0 ? natural.h : 24 }
+    );
     nodes.push({
       id: f.id,
       type: "frame",
@@ -177540,6 +177975,8 @@ function modelToFlow(model, opts) {
         ports: assignPortHandles(f.ports, opts.portOverrides),
         w: size.w,
         h: size.h,
+        featureCompartmentHeight: featureH,
+        featureCompartmentMinHeight: featureH > 0 ? natural.h : void 0,
         showPortLabels: opts.showPortLabels,
         showMult: opts.showMult,
         connectPointSpacing,
@@ -177591,8 +178028,16 @@ function modelToFlow(model, opts) {
   for (const n2 of renderModelNodes) {
     const canvasNode = nodeForCanvas(n2);
     const isGeo = model.kind === "gev" && n2.geo !== void 0;
+    const featureH = featureCompartmentBandHeight(n2);
     const base = isGeo ? { w: 24, h: 24 } : nodeSize(canvasNode, opts.direction);
-    const size = sizeWithOverride(base, ov[n2.layoutKey ?? n2.id]);
+    const size = sizeWithOverride(
+      base,
+      ov[n2.layoutKey ?? n2.id],
+      {
+        w: canvasNode.meta?.containerControls === true || canvasNode.meta?.internalsHidden === true ? COLLAPSED_CONTAINER_MIN_WIDTH : 48,
+        h: featureH > 0 ? base.h : 24
+      }
+    );
     const parentId = n2.frame ?? (model.kind === "gv" && n2.parent && gvPackageIds.has(n2.parent) ? n2.parent : void 0) ?? (boundary ? boundary.id : void 0);
     nodes.push({
       id: n2.id,
@@ -177605,6 +178050,8 @@ function modelToFlow(model, opts) {
         ports: assignPortHandles(n2.ports, opts.portOverrides),
         w: size.w,
         h: size.h,
+        featureCompartmentHeight: featureH,
+        featureCompartmentMinHeight: featureH > 0 ? base.h : void 0,
         showPortLabels: opts.showPortLabels,
         showMult: opts.showMult,
         connectPointSpacing
@@ -177623,10 +178070,14 @@ function modelToFlow(model, opts) {
       // often nearly the whole visible canvas at typical zoom, so its empty
       // interior must pan the canvas rather than move the part (a click
       // there still selects it — dragHandle only gates the DRAG gesture,
-      // never click). Restrict the drag-to-move gesture to the part's own
-      // keyword/name label, its one visible "something to grab"; every
-      // other diagram kind keeps the existing whole-body drag.
-      ...model.kind === "iv" && !isGeo ? { dragHandle: ".dnode-kind, .dnode-label" } : {}
+      // never click). Every other diagram kind keeps the whole-body drag.
+      // User report 2026-08-11 — the grabbable area was the SVG title TEXT
+      // alone, which a part with hidden internals could barely be moved by
+      // and which carries no move cursor: `.rf-node-header` is the same
+      // full-width title strip a container frame has, so a part behaves the
+      // same whether it draws its internals or not. The text selectors stay
+      // for the title of a node whose header strip is not rendered.
+      ...model.kind === "iv" && !isGeo ? { dragHandle: ".rf-node-header, .dnode-kind, .dnode-label" } : {}
     });
   }
   if (model.kind === "sv") {
@@ -178104,6 +178555,9 @@ async function elkLayout(elk, graph) {
 }
 var FRAME_PAD_TOP = 36;
 var FRAME_PAD = 22;
+function frameTopPad(node) {
+  return FRAME_PAD_TOP + frameFeatureCompartmentHeight(node.data.frame);
+}
 var GV_DOCK_FAMILY_ORDER = /* @__PURE__ */ new Map([
   ["owningMembership", 0],
   ["composition", 1],
@@ -178748,7 +179202,7 @@ function buildElkTree(nodes, direction, kind, tree) {
       ...children2.length ? {
         children: children2.map(toElk),
         layoutOptions: {
-          "elk.padding": `[top=${FRAME_PAD_TOP},left=${FRAME_PAD},bottom=${FRAME_PAD},right=${FRAME_PAD}]`,
+          "elk.padding": `[top=${frameTopPad(n2)},left=${FRAME_PAD},bottom=${FRAME_PAD},right=${FRAME_PAD}]`,
           ...minimum,
           // REQ-371 — repeat the selected axis on EVERY compound part.
           // ELK does not reliably inherit a root direction into nested
@@ -178854,12 +179308,12 @@ function arrangeIvHierarchy(nodes, direction) {
     children2.push(node);
     byParent.set(key, children2);
   }
-  const arrange = (children2, inset) => {
+  const arrange = (children2, insetFor) => {
     if (!children2.length) return;
     const minX = Math.min(...children2.map((child) => child.position.x));
     const minY = Math.min(...children2.map((child) => child.position.y));
-    const baseX = inset ? FRAME_PAD : 0;
-    const baseY = inset ? FRAME_PAD_TOP : 0;
+    const baseX = insetFor ? FRAME_PAD : 0;
+    const baseY = insetFor ? frameTopPad(insetFor) : 0;
     for (const child of children2) {
       child.position = {
         x: child.position.x - minX + baseX,
@@ -178938,7 +179392,7 @@ function arrangeIvHierarchy(nodes, direction) {
     frame2.data = { ...frame2.data, w: minimum.w, h: minimum.h };
     const children2 = byParent.get(frame2.id) ?? [];
     if (!children2.length) continue;
-    arrange(children2, true);
+    arrange(children2, frame2);
     const maxX = Math.max(...children2.map((child) => child.position.x + (child.width ?? child.data.w)));
     const maxY = Math.max(...children2.map((child) => child.position.y + (child.height ?? child.data.h)));
     const width = Math.max(minimum.w, maxX + FRAME_PAD);
@@ -178947,7 +179401,7 @@ function arrangeIvHierarchy(nodes, direction) {
     frame2.height = height;
     frame2.data = { ...frame2.data, w: width, h: height };
   }
-  arrange(byParent.get(void 0) ?? [], false);
+  arrange(byParent.get(void 0) ?? [], void 0);
 }
 function applyElkPositions(node, byId) {
   for (const child of node.children ?? []) {
@@ -179066,7 +179520,13 @@ function nextSideAnchor(counts, offsetsCache, node, side, spacing, demand) {
   let offsets = offsetsCache.get(key);
   if (!offsets) {
     const derived = sidePointOffsetsForLength(
-      sideEffectiveLength(node.data.node?.shape, side, node.data.w, node.data.h),
+      sideEffectiveLength(
+        node.data.node?.shape,
+        side,
+        node.data.w,
+        node.data.h,
+        featureBandTopReserve(node.data)
+      ),
       spacing
     );
     const needed = demand?.get(key) ?? 0;
@@ -179078,7 +179538,13 @@ function nextSideAnchor(counts, offsetsCache, node, side, spacing, demand) {
   }
   const offset2 = offsets[i % offsets.length];
   if (i < offsets.length && !sidePointOffsetsForLength(
-    sideEffectiveLength(node.data.node?.shape, side, node.data.w, node.data.h),
+    sideEffectiveLength(
+      node.data.node?.shape,
+      side,
+      node.data.w,
+      node.data.h,
+      featureBandTopReserve(node.data)
+    ),
     spacing
   ).some((o) => Math.abs(o - offset2) < 1e-6)) {
     const explicit = node.data.explicitSideAnchors?.[side] ?? [];
@@ -189511,7 +189977,7 @@ function dockPoint(node, handleId, byId, fallback) {
     const ph = node.data.ports?.find((p) => p.port.id === port.portId);
     if (ph) {
       const dockSide = clampDockSide(port.side, ph.side);
-      const rect = portGlyphRect(ph, w, h);
+      const rect = portGlyphRect(ph, w, h, featureBandTopReserve(node.data));
       const n2 = DOCK_NORMAL[dockSide];
       const at = portDockAt(rect, ph.side, dockSide);
       return { point: { x: pos.x + at.x, y: pos.y + at.y }, normal: n2 };
@@ -189519,12 +189985,19 @@ function dockPoint(node, handleId, byId, fallback) {
   }
   const structural = node.data.structuralDocks?.find((dock) => dock.id === handleId);
   if (structural) {
-    const c = sidePoint(structural.side, structural.offset, w, h);
+    const c = sidePoint(structural.side, structural.offset, w, h, featureBandTopReserve(node.data));
     return { point: { x: pos.x + c.x, y: pos.y + c.y }, normal: DOCK_NORMAL[structural.side] };
   }
   const sideAnchor = parseSideAnchorHandleId(handleId);
   if (sideAnchor) {
-    const c = sideSurfacePoint(node.data.node?.shape, sideAnchor.side, sideAnchor.offset, w, h);
+    const c = sideSurfacePoint(
+      node.data.node?.shape,
+      sideAnchor.side,
+      sideAnchor.offset,
+      w,
+      h,
+      featureBandTopReserve(node.data)
+    );
     return { point: { x: pos.x + c.x, y: pos.y + c.y }, normal: DOCK_NORMAL[sideAnchor.side] };
   }
   return { point: fallback };
@@ -189607,7 +190080,9 @@ function paintedRouteForEdge(edge, nodes, byId, edges = [], lineStyle = "orthogo
     return { points: manhattanThroughPoints([sd.point, ...route, td.point], sd.normal), corner: 0 };
   }
   const structural = isStructuralBusEdge(edge);
-  const [sp, tp] = fanApart(sd.point, td.point, parallelEdgeOffset(
+  const sp = sd.point;
+  const tp = td.point;
+  const via = fanVia(sp, tp, parallelEdgeOffset(
     edge.id,
     edge.source,
     edge.target,
@@ -189615,6 +190090,9 @@ function paintedRouteForEdge(edge, nodes, byId, edges = [], lineStyle = "orthogo
     edge.targetHandle,
     edges
   ));
+  if (via.length) {
+    return { points: manhattanThroughPoints([sp, ...via, tp], sd.normal), corner: 0 };
+  }
   if (edgeUsesObstacleRouting(edge.data?.kind, lineStyle, structural)) {
     return {
       points: routeOrthogonalAroundRects(sp, tp, obstacleRects(nodes, edge.source, edge.target, byId, scene), {
@@ -189642,7 +190120,7 @@ function geometrySignature(nodes) {
       if (n2.dragging === true || n2.resizing === true) continue;
       out += `${n2.id}:${n2.parentId ?? ""}:${n2.type ?? ""}:${n2.hidden ? 1 : 0}:`;
       out += `${n2.position.x},${n2.position.y},${n2.width ?? n2.measured?.width ?? n2.data.w},${n2.height ?? n2.measured?.height ?? n2.data.h}`;
-      out += `:${n2.data.node?.shape ?? ""}:${n2.data.isBoundary ? 1 : 0}`;
+      out += `:${n2.data.node?.shape ?? ""}:${n2.data.isBoundary ? 1 : 0}:${n2.data.featureCompartmentHeight ?? 0}`;
       for (const p of n2.data.ports ?? []) {
         out += `|${p.port.id},${p.side},${p.offset},${p.along ?? ""},${p.shift?.along ?? ""},${p.shift?.across ?? ""}`;
       }
@@ -189762,12 +190240,15 @@ function parallelOffsetMap(edges) {
   const groups = /* @__PURE__ */ new Map();
   for (const edge of edges) {
     if (isPortDocked(edge.sourceHandle) || isPortDocked(edge.targetHandle)) continue;
-    const [a2, b] = edge.source <= edge.target ? [edge.source, edge.target] : [edge.target, edge.source];
+    const forward = edge.source <= edge.target;
+    const [a2, b] = forward ? [edge.source, edge.target] : [edge.target, edge.source];
+    const [ha, hb] = forward ? [edge.sourceHandle ?? "", edge.targetHandle ?? ""] : [edge.targetHandle ?? "", edge.sourceHandle ?? ""];
     let byTarget = groups.get(a2);
     if (!byTarget) groups.set(a2, byTarget = /* @__PURE__ */ new Map());
-    const group = byTarget.get(b) ?? [];
+    const key = `${b}\0${ha}\0${hb}`;
+    const group = byTarget.get(key) ?? [];
     group.push(edge);
-    byTarget.set(b, group);
+    byTarget.set(key, group);
   }
   cached = /* @__PURE__ */ new Map();
   for (const byTarget of groups.values()) {
@@ -189788,14 +190269,14 @@ function parallelEdgeOffset(id2, _source, _target, sourceHandle, targetHandle, e
   if (isPortDocked(sourceHandle) || isPortDocked(targetHandle)) return 0;
   return parallelOffsetMap(edges).get(id2) ?? 0;
 }
-function fanApart(sp, tp, off) {
+function fanVia(sp, tp, off) {
   const dx = tp.x - sp.x;
   const dy = tp.y - sp.y;
   const len = Math.hypot(dx, dy);
-  if (!len || !off) return [sp, tp];
+  if (!len || !off) return [];
   const nx = -dy / len;
   const ny = dx / len;
-  return [{ x: sp.x + nx * off, y: sp.y + ny * off }, { x: tp.x + nx * off, y: tp.y + ny * off }];
+  return [{ x: (sp.x + tp.x) / 2 + nx * off, y: (sp.y + tp.y) / 2 + ny * off }];
 }
 var GV_BUS_EDGE_KINDS = /* @__PURE__ */ new Set([
   "owningMembership",
@@ -189845,13 +190326,14 @@ function computeEdgePath(args) {
     live ? { x: live.targetX, y: live.targetY } : nodeCentre(targetNode, byId)
   );
   const route = args.route ?? edge.data?.route;
-  const fan = route?.length ? 0 : parallelEdgeOffset(edge.id, edge.source, edge.target, edge.sourceHandle, edge.targetHandle, edges);
-  const [sp, tp] = fanApart(sd.point, td.point, fan);
-  const anchors = route?.length ? [sp, ...route, tp] : [sp, tp];
+  const sp = sd.point;
+  const tp = td.point;
+  const via = route?.length ? route : fanVia(sp, tp, parallelEdgeOffset(edge.id, edge.source, edge.target, edge.sourceHandle, edge.targetHandle, edges));
+  const anchors = [sp, ...via, tp];
   const common = { sourceX: sp.x, sourceY: sp.y, targetX: tp.x, targetY: tp.y };
   const structural = isStructuralBusEdge(edge);
   const wantsObstacles = edgeUsesObstacleRouting(edge.data?.kind, lineStyle, structural);
-  const userRouted = route && route.length > 0 ? lineStyle === "curved" ? { path: smoothPathThroughPoints(anchors), label: pathMidpoint(anchors), points: void 0 } : lineStyle === "straight" ? { path: pointsToPath(anchors), label: pathMidpoint(anchors), points: void 0 } : (() => {
+  const guided = via.length > 0 ? lineStyle === "curved" ? { path: smoothPathThroughPoints(anchors), label: pathMidpoint(anchors), points: void 0 } : lineStyle === "straight" ? { path: pointsToPath(anchors), label: pathMidpoint(anchors), points: void 0 } : (() => {
     const pts = manhattanThroughPoints(anchors, sd.normal);
     return { path: pointsToPath(pts), label: pathMidpoint(pts), points: pts };
   })() : void 0;
@@ -189869,8 +190351,8 @@ function computeEdgePath(args) {
       normal: sd.normal
     };
   }
-  const autoRouted = wantsObstacles && !userRouted && !args.dragging ? routedOrthogonalPath({ point: sp, normal: sd.normal }, { point: tp, normal: td.normal }, nodes, edge.source, edge.target) : void 0;
-  const routed = userRouted ?? autoRouted;
+  const autoRouted = wantsObstacles && !guided && !args.dragging ? routedOrthogonalPath({ point: sp, normal: sd.normal }, { point: tp, normal: td.normal }, nodes, edge.source, edge.target) : void 0;
+  const routed = guided ?? autoRouted;
   if (routed) {
     return {
       path: routed.path,
@@ -189930,6 +190412,13 @@ function markersFor(kind) {
     case "redefinition":
     case "referenceSubsetting":
       return { end: "url(#tri-hollow)" };
+    // REQ-160 — temporal decomposition (OMG 8.2.3.9): an occurrence's life →
+    // one `timeslice`/`snapshot` PORTION of it. A portion specializes the life
+    // it is part of, so it carries the specialization triangle — at the WHOLE
+    // end, which is where the edge starts, so the marker is a start-oriented
+    // twin of `tri-hollow` rather than the end-oriented one.
+    case "portion":
+      return { start: "url(#tri-hollow-start)" };
     case "flow":
     case "message":
       return { end: "url(#arrow-cyan)" };
@@ -190250,6 +190739,10 @@ var MARKER_DEFS_SVG = [
   `<marker markerUnits="userSpaceOnUse" id="arrow-open-neutral" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="8" markerHeight="8" orient="auto"><path d="M0 0L10 5L0 10" fill="none" stroke="${GREY}" stroke-width="1.4"/></marker>`,
   `<marker markerUnits="userSpaceOnUse" id="tri-accent" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="8" markerHeight="8" orient="auto"><path d="M0 0L10 5L0 10z" fill="${ACCENT}"/></marker>`,
   `<marker markerUnits="userSpaceOnUse" id="tri-hollow" viewBox="0 0 12 12" refX="11" refY="6" markerWidth="11" markerHeight="11" orient="auto"><path d="M0 0L12 6L0 12z" fill="${BG}" stroke="${GREY}" stroke-width="1.2"/></marker>`,
+  // REQ-160 — the portion (temporal-decomposition) triangle sits at the START of
+  // the edge, at the whole occurrence. Same shape as `tri-hollow`, mirrored so
+  // `orient="auto"` points it back along the line instead of down it.
+  `<marker markerUnits="userSpaceOnUse" id="tri-hollow-start" viewBox="0 0 12 12" refX="1" refY="6" markerWidth="11" markerHeight="11" orient="auto"><path d="M12 0L0 6L12 12z" fill="${BG}" stroke="${GREY}" stroke-width="1.2"/></marker>`,
   `<marker markerUnits="userSpaceOnUse" id="defined-by" viewBox="0 0 18 12" refX="17" refY="6" markerWidth="12" markerHeight="8" orient="auto"><circle cx="3.2" cy="3.6" r="1.6" fill="${GREY}"/><circle cx="3.2" cy="8.4" r="1.6" fill="${GREY}"/><path d="M7 1L17 6L7 11z" fill="${GREY}"/></marker>`,
   `<marker markerUnits="userSpaceOnUse" id="owning-membership" viewBox="0 0 14 14" refX="1" refY="7" markerWidth="12" markerHeight="12" orient="auto"><circle cx="7" cy="7" r="5.2" fill="${BG}" stroke="${GREY}" stroke-width="1.2"/><path d="M3.8 7H10.2M7 3.8V10.2" fill="none" stroke="${GREY}" stroke-width="1.2"/></marker>`,
   `<marker markerUnits="userSpaceOnUse" id="diamond-filled" viewBox="0 0 14 14" refX="1" refY="7" markerWidth="12" markerHeight="12" orient="auto"><path d="M0 7L7 0L14 7L7 14z" fill="${GREY}"/></marker>`,
@@ -190263,6 +190756,7 @@ var KIN_MARKER_DEFS_SVG = [
   `<marker markerUnits="userSpaceOnUse" id="arrow-open-neutral-kin" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="8" markerHeight="8" orient="auto"><path d="M0 0L10 5L0 10" fill="none" stroke="${KIN}" stroke-width="1.4"/></marker>`,
   `<marker markerUnits="userSpaceOnUse" id="tri-accent-kin" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="8" markerHeight="8" orient="auto"><path d="M0 0L10 5L0 10z" fill="${KIN}"/></marker>`,
   `<marker markerUnits="userSpaceOnUse" id="tri-hollow-kin" viewBox="0 0 12 12" refX="11" refY="6" markerWidth="11" markerHeight="11" orient="auto"><path d="M0 0L12 6L0 12z" fill="${BG}" stroke="${KIN}" stroke-width="1.5"/></marker>`,
+  `<marker markerUnits="userSpaceOnUse" id="tri-hollow-start-kin" viewBox="0 0 12 12" refX="1" refY="6" markerWidth="11" markerHeight="11" orient="auto"><path d="M12 0L0 6L12 12z" fill="${BG}" stroke="${KIN}" stroke-width="1.5"/></marker>`,
   `<marker markerUnits="userSpaceOnUse" id="defined-by-kin" viewBox="0 0 18 12" refX="17" refY="6" markerWidth="12" markerHeight="8" orient="auto"><circle cx="3.2" cy="3.6" r="1.6" fill="${KIN}"/><circle cx="3.2" cy="8.4" r="1.6" fill="${KIN}"/><path d="M7 1L17 6L7 11z" fill="${KIN}"/></marker>`,
   `<marker markerUnits="userSpaceOnUse" id="owning-membership-kin" viewBox="0 0 14 14" refX="1" refY="7" markerWidth="12" markerHeight="12" orient="auto"><circle cx="7" cy="7" r="5.2" fill="${BG}" stroke="${KIN}" stroke-width="1.5"/><path d="M3.8 7H10.2M7 3.8V10.2" fill="none" stroke="${KIN}" stroke-width="1.5"/></marker>`,
   `<marker markerUnits="userSpaceOnUse" id="diamond-filled-kin" viewBox="0 0 14 14" refX="1" refY="7" markerWidth="12" markerHeight="12" orient="auto"><path d="M0 7L7 0L14 7L7 14z" fill="${KIN}"/></marker>`,
@@ -190408,6 +190902,9 @@ body {
  * reading. */
 .dframe-rect { fill: var(--node-surface); fill-opacity: 0.92; stroke: var(--fg-3); stroke-width: 1.2; }
 .dframe-rect.container { fill-opacity: 0.16; }
+/* REQ-366/386 \u2014 an expanded frame remains translucent around its graphical
+ * internals, but its optional bottom feature list is an opaque readable card. */
+.dfeature-band-bg { fill: var(--node-surface); }
 .dframe-rect.package.library { stroke-dasharray: 5 3; }
 .dframe-rect.selected { stroke: var(--accent); stroke-width: 2; }
 /* RULE (diagram-rules \u2014 Frame): parallel composite-state region \u2014 dashed border. */
@@ -190452,17 +190949,6 @@ body {
 .dnode-shape.decision { stroke: var(--yellow); }
 /* REQ-006 \u2014 selected-node resize grip */
 .dresize-grip { fill: var(--accent); stroke: var(--bg-1); stroke-width: 1; cursor: nwse-resize; }
-/* REQ-366 \u2014 local IV part presentation control in the upper-right corner.
-   Issue #18 \u2014 a bare +/\u2212 glyph, no surrounding box; the rect stays in the
-   markup only as an invisible, comfortably-sized click target. */
-.div-part-toggle { cursor: pointer; }
-.div-part-toggle rect { fill: transparent; stroke: none; }
-.div-part-toggle text {
-  fill: var(--fg-1); font-family: var(--font-ui); font-size: 16px; font-weight: 700;
-  pointer-events: none;
-}
-.div-part-toggle:hover text { fill: var(--accent); }
-
 /* edges (REQ-186) */
 .dlink { stroke: var(--fg-2); stroke-width: 1.2; fill: none; }
 .dlink.flow, .dlink.connect, .dlink.message, .dlink.interface { stroke: var(--cyan); }
@@ -190483,6 +190969,9 @@ body {
 }
 .dlink.binding { stroke: var(--yellow); stroke-width: 2.6; } /* REQ-195 \u2014 "=" binding (double-weight line) */
 .dlink.specialization, .dlink.owningMembership, .dlink.composition, .dlink.association { stroke: var(--fg-2); }
+/* REQ-160 \u2014 temporal decomposition of an occurrence into timeslices/snapshots
+   (OMG 8.2.3.9): a solid structural line, like the specialization it is. */
+.dlink.portion { stroke: var(--fg-2); }
 /* REQ-094/190 \u2014 custom bound-reference overlay. A dotted directed line is
    deliberately distinct from solid feature membership and its owner diamond. */
 .dlink.reference { stroke: var(--fg-2); stroke-dasharray: 1 3; stroke-linecap: round; }
@@ -190842,16 +191331,23 @@ body {
 /* REQ-190 \u2014 the direction, General-View mode, and line-style segs are icon-only:
    tighter padding (see issue 146). */
 .seg.seg-dir button, .seg.seg-gvmode button, .seg.seg-line-style button, .seg.seg-gridpreset button,
-.seg.seg-afv-filters button { padding: 2px 6px; }
-/* REQ-196 \u2014 the Action Flow show/hide toggles are independent switches, not a
-   one-of-N mode: an OFF one dims and takes a slash, so an engaged filter reads at
-   a glance (the same treatment as the General View's quick-filter chips). */
-.seg.seg-afv-filters button:not(.on) { opacity: 0.38; }
-.seg.seg-afv-filters button:not(.on)::after {
+.seg.seg-visibility button, .seg.seg-presentation button { padding: 2px 6px; }
+/* REQ-196/200/366/386 \u2014 every visibility/presentation segment shares one
+   treatment: visible is lit; hidden is dimmed and slashed. Semantic icon hues
+   remain visible instead of being replaced by a solid orange active button. */
+.seg.seg-visibility button.on, .seg.seg-presentation button.on {
+  background: var(--bg-active); color: var(--fg-0);
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--fg-2) 30%, transparent); }
+.seg.seg-visibility button:not(.on), .seg.seg-presentation button:not(.on) { opacity: 0.38; }
+.seg.seg-visibility button:not(.on)::after, .seg.seg-presentation button:not(.on)::after {
     content: ''; position: absolute; left: 4px; right: 4px; top: 50%;
-    border-top: 1.2px solid currentColor; transform: rotate(-20deg);
+    border-top: 1.2px solid var(--red, #e07a7a); transform: rotate(-20deg);
 }
-.seg.seg-afv-filters button { position: relative; }
+.seg.seg-visibility button, .seg.seg-presentation button { position: relative; }
+.visibility-icon.tone-structure, .presentation-icon.tone-structure { color: var(--cyan); }
+.visibility-icon.tone-behavior, .presentation-icon.tone-behavior { color: var(--accent); }
+.visibility-icon.tone-definition, .presentation-icon.tone-definition,
+.definition-visibility-icon { color: var(--violet); }
 /* issue 156 \u2014 General View quick filters: one icon chip per element category
    (parts always show). A chip stays lit in its element-type colour while its
    category is VISIBLE; hiding one dims and slashes it so an engaged filter is
@@ -191089,6 +191585,12 @@ svg.react-flow__connectionline { z-index: 1; }
 .rf-frame .rf-node-svg { pointer-events: none; }
 .rf-frame .dframe-rect { pointer-events: none; }
 .rf-frame-header { position: absolute; pointer-events: auto; cursor: move; }
+/* issue #58 / user report 2026-08-11 \u2014 the matching title strip on an
+ * Interconnection View PART node. It is what the node's dragHandle selects, so
+ * a part reads and moves identically whether it draws its internals (a frame) or
+ * has them hidden (a node) \u2014 and shows the same move cursor either way, instead
+ * of React Flow's grab hand over a body that cannot actually be dragged. */
+.rf-node-header { position: absolute; pointer-events: auto; cursor: move; }
 /* REQ-379 \u2014 the frame's BORDER band is hover-sensitive (the interior stays
  * click-through): hovering it reveals and mounts the frame's side connect points,
  * which are drawn on that same border. Stroke-only hit testing, so nothing but the
@@ -191096,7 +191598,7 @@ svg.react-flow__connectionline { z-index: 1; }
 .dframe-hover-band { stroke-width: 12; pointer-events: stroke; }
 .rf-frame .dport-hit { pointer-events: auto; }
 .rf-frame .react-flow__handle { pointer-events: auto; }
-.rf-frame .div-part-toggle { pointer-events: auto; }
+.rf-frame .dcontainer-controls { pointer-events: auto; }
 .rf-frame .react-flow__resize-control { pointer-events: auto; }
 .rf-node-svg { display: block; overflow: visible; }
 .react-flow__node.selected { box-shadow: none; }
@@ -191293,12 +191795,29 @@ svg.react-flow__connectionline { z-index: 1; }
   color: var(--fg-0); background: var(--bg-1); border: 1px solid var(--line-soft); border-radius: 3px; padding: 0 4px; white-space: nowrap; }
 .rf-edge-label.mult { background: transparent; border: 0; color: var(--fg-2); padding: 0; }
 
-/* REQ-366 / issues.md #18 \u2014 IV part presentation toggle: a BARE +/\u2212 glyph (no
- * box), with a comfortable invisible click target; highlighted on hover/press. */
-.div-part-toggle { width: 20px; height: 20px; padding: 0; margin: 0; border: 0; background: transparent;
-  color: var(--fg-1); font: 700 17px var(--font-ui); line-height: 1; cursor: pointer;
+/* REQ-366/386 \u2014 two adjacent, independent container presentation controls.
+ * +/\u2212 owns graphical internals; the outlined list owns textual feature
+ * compartments. Their compact hit targets stay interactive over frame chrome.
+ * Both marks are STROKED SVG sized to the whole button (nodes.tsx
+ * ContainerControlGlyph), so nothing here can shift them off centre \u2014 a typed
+ * +/\u2212 character and a bordered box drawn in CSS both did (user report
+ * 2026-08-11). */
+/* The inset is set inline per shape (nodes.tsx ContainerControls): a rounded
+ * outline needs the pair pulled in from its corner arc, a sharp one does not.
+ * These values are the sharp-corner default. */
+.dcontainer-controls { position: absolute; right: ${CONTAINER_CONTROLS_RIGHT}px; top: ${CONTAINER_CONTROLS_RIGHT}px; z-index: 8;
+  display: inline-flex; align-items: center; gap: ${CONTAINER_CONTROL_GAP}px; pointer-events: auto; }
+/* The BUTTON is only a hit target: no plate, no fill, in any state (user
+ * direction 2026-08-11 \u2014 "remove that translucent thing surrounding the box I
+ * just want the hamburger menu"). Neither does STATE live here: the mark itself
+ * carries it \u2014 an empty box or a filled one, a + or a \u2212, at one resting colour
+ * ("at best don't even change color"). Only the pointer feedback is a colour. */
+.div-part-toggle, .dfeature-toggle { width: ${CONTAINER_CONTROL_SIZE}px; height: ${CONTAINER_CONTROL_SIZE}px;
+  padding: 0; margin: 0; border: 0; background: none; cursor: pointer; color: var(--fg-1);
   display: inline-flex; align-items: center; justify-content: center; }
-.div-part-toggle:hover, .div-part-toggle:active, .div-part-toggle:focus-visible { color: var(--accent); outline: none; }
+.div-part-toggle svg, .dfeature-toggle svg { display: block; }
+.div-part-toggle:hover, .div-part-toggle:active, .div-part-toggle:focus-visible,
+.dfeature-toggle:hover, .dfeature-toggle:active, .dfeature-toggle:focus-visible { color: var(--accent); outline: none; }
 
 /* React Flow chrome theming (controls / minimap / attribution) */
 .react-flow__controls { box-shadow: 0 2px 10px rgba(0,0,0,0.35); }
@@ -191395,7 +191914,7 @@ function buildDiagramSvg(options) {
     const { w, h } = sizeOf(node);
     extend2(p.x, p.y, w, h);
     for (const ph of node.data.ports ?? []) {
-      const rect = portGlyphRect(ph, w, h);
+      const rect = portGlyphRect(ph, w, h, featureBandTopReserve(node.data));
       extend2(p.x + rect.x, p.y + rect.y, rect.width, rect.height);
       if (!node.data.showPortLabels || rect.elongated) continue;
       const text = `${ph.port.conjugated ? "~" : ""}${ph.port.name}`;
@@ -191538,7 +192057,7 @@ function tableToCsv(table2, order) {
 // ../extension/src/diagram-sidecar.ts
 var import_diagram_protocol2 = __toESM(require_out());
 var FILE_OVERVIEW_ANCHOR = "~file";
-var SIDECAR_VERSION = 3;
+var SIDECAR_VERSION = 4;
 function emptySideCar() {
   return { version: SIDECAR_VERSION, anchors: {} };
 }
@@ -191593,6 +192112,20 @@ function dropOrdinalKeys(map3) {
   }
   return Object.keys(kept).length > 0 ? kept : void 0;
 }
+function enabledEntries(value) {
+  if (!value || typeof value !== "object") return {};
+  return Object.fromEntries(Object.entries(value).filter(([, enabled]) => enabled === true));
+}
+function normalizeContainerPresentation(state, kind) {
+  const legacy = state;
+  const coupled = kind === "iv" ? enabledEntries(legacy.ivCompartments) : kind === "afv" ? enabledEntries(legacy.collapsedActions) : {};
+  if (Object.keys(coupled).length > 0) {
+    state.hiddenInternals = { ...coupled, ...state.hiddenInternals ?? {} };
+    state.visibleFeatureCompartments = { ...coupled, ...state.visibleFeatureCompartments ?? {} };
+  }
+  delete legacy.ivCompartments;
+  delete legacy.collapsedActions;
+}
 function normalizeSideCar(value) {
   if (!value || typeof value !== "object") return emptySideCar();
   const v = value;
@@ -191601,16 +192134,36 @@ function normalizeSideCar(value) {
   if (version >= SIDECAR_VERSION) {
     for (const byKind of Object.values(anchors)) {
       if (!byKind || typeof byKind !== "object") continue;
-      for (const state of Object.values(byKind)) {
+      for (const [kind, state] of Object.entries(byKind)) {
         if (!state || typeof state !== "object") continue;
         const dir = sanitizeDirection(state.direction);
         if (dir === void 0) delete state.direction;
         else state.direction = dir;
         normalizeGridFields(state);
+        normalizeContainerPresentation(state, kind);
       }
     }
     return { version, anchors };
   }
+  if (version === 3) {
+    const migrated2 = {};
+    for (const [anchor, byKind] of Object.entries(anchors)) {
+      if (!byKind || typeof byKind !== "object") continue;
+      const nextByKind = {};
+      for (const [kind, raw] of Object.entries(byKind)) {
+        if (!raw || typeof raw !== "object") continue;
+        const state = { ...raw };
+        normalizeGridFields(state);
+        const dir = sanitizeDirection(state.direction);
+        if (dir === void 0) delete state.direction;
+        else state.direction = dir;
+        normalizeContainerPresentation(state, kind);
+        nextByKind[kind] = state;
+      }
+      migrated2[anchor] = nextByKind;
+    }
+    return { version: SIDECAR_VERSION, anchors: migrated2 };
+  }
   if (version === 2) {
     const migrated2 = {};
     for (const [anchor, byKind] of Object.entries(anchors)) {
@@ -191629,6 +192182,7 @@ function normalizeSideCar(value) {
         const ports = dropOrdinalKeys(state.ports);
         if (ports) state.ports = ports;
         else delete state.ports;
+        normalizeContainerPresentation(state, kind);
         nextByKind[kind] = state;
       }
       migrated2[anchor] = nextByKind;
@@ -191643,14 +192197,17 @@ function normalizeSideCar(value) {
       if (!raw || typeof raw !== "object") continue;
       const state = raw;
       normalizeGridFields(state);
+      normalizeContainerPresentation(state, kind);
       const next = {};
       if (state.mode !== void 0) next.mode = state.mode;
       if (state.zoom !== void 0) next.zoom = state.zoom;
       const dir = sanitizeDirection(state.direction);
       if (dir !== void 0) next.direction = dir;
-      if (state.ivCompartments !== void 0) next.ivCompartments = state.ivCompartments;
+      if (state.hiddenInternals !== void 0) next.hiddenInternals = state.hiddenInternals;
+      if (state.visibleFeatureCompartments !== void 0) {
+        next.visibleFeatureCompartments = state.visibleFeatureCompartments;
+      }
       if (state.nestedPorts !== void 0) next.nestedPorts = state.nestedPorts;
-      if (state.collapsedActions !== void 0) next.collapsedActions = state.collapsedActions;
       if (state.gvMode !== void 0) next.gvMode = state.gvMode;
       if (state.gvFilters !== void 0) next.gvFilters = state.gvFilters;
       if (state.lineStyle !== void 0) next.lineStyle = state.lineStyle;
@@ -191726,6 +192283,7 @@ function edgeKindLabel(kind) {
   if (kind === "composition") return "feature membership";
   if (kind === "owningMembership") return "owning membership";
   if (kind === "definedBy") return "defined by";
+  if (kind === "portion") return "temporal decomposition (portion)";
   return kind;
 }
 
@@ -192374,7 +192932,8 @@ function nodeSidePointOffsets(data, side, connectable) {
     data.h,
     data.connectPointSpacing ?? CONNECT_POINT_SPACING_DEFAULT,
     connectable,
-    data.node?.shape
+    data.node?.shape,
+    data.featureCompartmentHeight ?? 0
   );
   const explicit = data.explicitSideAnchors?.[side] ?? [];
   return [.../* @__PURE__ */ new Set([...derived, ...explicit])].sort((a2, b) => a2 - b);
@@ -192405,7 +192964,7 @@ var SIDE_NORMAL = {
   left: { x: -1, y: 0 }
 };
 var clampOffset = (v) => Math.max(0.06, Math.min(0.94, v));
-function usePortDrag(containerRef, w, h, onPortMove, onPortPreview, onSelect) {
+function usePortDrag(containerRef, w, h, topReserve, onPortMove, onPortPreview, onSelect) {
   const [dragId, setDragId] = (0, import_react8.useState)(void 0);
   const onPortPointerDown = (portId, e, draggable = true) => {
     if (e.button !== 0) return;
@@ -192422,12 +192981,8 @@ function usePortDrag(containerRef, w, h, onPortMove, onPortPreview, onSelect) {
     const placement = (cx, cy) => {
       const lx = rect.width ? (cx - rect.left) / rect.width * w : 0;
       const ly = rect.height ? (cy - rect.top) / rect.height * h : 0;
-      const dl = lx, dr = w - lx, dt = ly, db = h - ly;
-      const m = Math.min(dl, dr, dt, db);
-      if (m === dt) return { side: "top", offset: clampOffset(lx / w) };
-      if (m === db) return { side: "bottom", offset: clampOffset(lx / w) };
-      if (m === dl) return { side: "left", offset: clampOffset(ly / h) };
-      return { side: "right", offset: clampOffset(ly / h) };
+      const nearest = nearestPortOwnerPlacement(lx, ly, w, h, topReserve);
+      return { side: nearest.side, offset: clampOffset(nearest.offset) };
     };
     const move = (ev) => {
       if (!moved && Math.hypot(ev.clientX - sx, ev.clientY - sy) < 4) return;
@@ -192450,18 +193005,6 @@ function usePortDrag(containerRef, w, h, onPortMove, onPortPreview, onSelect) {
   };
   return { dragId, onPortPointerDown };
 }
-function sideXY(side, offset2, w, h) {
-  switch (side) {
-    case "top":
-      return { x: w * offset2, y: 0 };
-    case "bottom":
-      return { x: w * offset2, y: h };
-    case "left":
-      return { x: 0, y: h * offset2 };
-    case "right":
-      return { x: w, y: h * offset2 };
-  }
-}
 function DualHandle({ id: id2, side, x, y, kind, active, connectable = true, startable = false, size }) {
   const style2 = size !== void 0 ? { left: x, top: y, width: size, height: size, transform: "translate(-50%,-50%)" } : { left: x, top: y, transform: "translate(-50%,-50%)" };
   const cls = `rf-handle rf-handle-${kind}${active ? " active" : ""}`;
@@ -192512,16 +193055,22 @@ function fitKind(s, availPx) {
 function FullTitle({ full, shown }) {
   return shown === full ? null : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("title", { children: full });
 }
-function compartmentTops(node, top = 30) {
+function compartmentTops(node, top = NODE_COMPARTMENT_TOP) {
   const comps = node.compartments ?? [];
   const tops = [];
   let acc = top;
   for (const c of comps) {
     tops.push(acc);
-    acc += 16 + c.items.length * 16;
+    acc += compartmentBlockHeight(c.items.length);
   }
   return { tops, comps };
 }
+function containerBandBottom(node, top) {
+  return top + (node.compartments ?? []).reduce((h, c) => h + compartmentBlockHeight(c.items.length), 0);
+}
+function ContainerBandRule({ w, y }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("line", { className: "dcompartment-rule closing", x1: 0, y1: y, x2: w, y2: y });
+}
 function Compartments({ node, w, top }) {
   const { tops, comps } = compartmentTops(node, top);
   return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, { children: comps.map((c, ci) => {
@@ -192529,13 +193078,13 @@ function Compartments({ node, w, top }) {
     const title = fitKind(c.title, w - 16);
     return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("g", { className: "dnode-compartment", children: [
       /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("line", { className: "dcompartment-rule", x1: 0, y1: cy, x2: w, y2: cy }),
-      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-kind", x: 8, y: cy + 12, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-kind", x: 8, y: cy + COMPARTMENT_TITLE_BASELINE, children: [
         /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: c.title, shown: title }),
         title
       ] }),
       c.items.map((it, i) => {
         const shown = fitText(it.text, w - 20, 10);
-        return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-label", x: 12, y: cy + 12 + (i + 1) * 14, style: { fontSize: 10 }, children: [
+        return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-label", x: 12, y: cy + COMPARTMENT_ROW_BASELINE + i * COMPARTMENT_ROW_HEIGHT, style: { fontSize: 10 }, children: [
           /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: it.text, shown }),
           shown
         ] }, i);
@@ -192548,37 +193097,53 @@ function variabilityMark(keyword) {
   if (/^variant\b/.test(keyword)) return " \u25C6";
   return "";
 }
+function nodeShowsControls(node) {
+  return node.meta?.containerControls === true;
+}
+function titleNameLine(name, type, mult, alias, availPx) {
+  const suffixChars = (mult ? mult.length + 1 : 0) + (alias ? alias.length + 9 : 0);
+  const budget = Math.max(6, fitChars(availPx, 11) - suffixChars);
+  let nameShown = name;
+  let typeShown = type;
+  if (type) {
+    if (name.length + 3 + type.length > budget) {
+      const nameMax = Math.max(4, Math.min(name.length, Math.ceil(budget * 0.6)));
+      nameShown = clipText(name, nameMax);
+      typeShown = clipText(type, Math.max(3, budget - nameShown.length - 3));
+    }
+  } else {
+    nameShown = clipText(name, budget);
+  }
+  return {
+    nameShown,
+    typeShown,
+    full: `${name}${type ? ` : ${type}` : ""}`,
+    shown: `${nameShown}${typeShown ? ` : ${typeShown}` : ""}`
+  };
+}
 function BoxBody({ node, w, h, showMult }) {
-  const rx = node.isDef ? 0 : 14;
+  const rx = nodeCornerRadius(node.shape, node.isDef, h, false);
   const cls = node.keyword.startsWith("requirement") ? "req" : "";
-  const cx = w / 2;
+  const titleArea = containerTitleArea(w, nodeShowsControls(node));
+  const cx = titleArea.centerX;
   const kindFull = `\xAB${node.keyword}\xBB${variabilityMark(node.keyword)}`;
-  const kindShown = fitKind(kindFull, w - 8);
-  const avail = Math.max(24, w - 12);
+  const kindShown = fitKind(kindFull, Math.max(24, titleArea.width - 8));
   const mult = showMult && node.multiplicity ? node.multiplicity : void 0;
   const alias = node.meta?.alias ? String(node.meta.alias) : void 0;
-  const suffixChars = (mult ? mult.length + 1 : 0) + (alias ? alias.length + 9 : 0);
-  const budget = Math.max(6, fitChars(avail, 11) - suffixChars);
-  let nameShown = node.name;
-  let typeShown = node.type;
-  if (node.type) {
-    if (node.name.length + 3 + node.type.length > budget) {
-      const nameMax = Math.max(4, Math.min(node.name.length, Math.ceil(budget * 0.6)));
-      nameShown = clipText(node.name, nameMax);
-      typeShown = clipText(node.type, Math.max(3, budget - nameShown.length - 3));
-    }
-  } else {
-    nameShown = clipText(node.name, budget);
-  }
-  const fullTitle = `${node.name}${node.type ? ` : ${node.type}` : ""}`;
-  const shownTitle = `${nameShown}${typeShown ? ` : ${typeShown}` : ""}`;
+  const { nameShown, typeShown, full: fullTitle, shown: shownTitle } = titleNameLine(
+    node.name,
+    node.type,
+    mult,
+    alias,
+    Math.max(24, titleArea.width - 12)
+  );
   return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("g", { children: [
     /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("rect", { className: `dnode-rect ${cls}`, x: 0, y: 0, width: w, height: h, rx }),
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-kind", x: cx, y: 14, textAnchor: "middle", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-kind", x: cx, y: CONTAINER_TITLE_KIND_BASELINE, textAnchor: "middle", children: [
       /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: kindFull, shown: kindShown }),
       kindShown
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: `dnode-label ${node.abstract ? "abstract" : ""}`, x: cx, y: 28, textAnchor: "middle", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: `dnode-label ${node.abstract ? "abstract" : ""}`, x: cx, y: CONTAINER_TITLE_NAME_BASELINE, textAnchor: "middle", children: [
       /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: fullTitle, shown: shownTitle }),
       nameShown,
       typeShown ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
@@ -192594,41 +193159,57 @@ function BoxBody({ node, w, h, showMult }) {
         alias
       ] }) : ""
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Compartments, { node, w })
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Compartments, { node, w }),
+    nodeShowsControls(node) ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ContainerBandRule, { w, y: containerBandBottom(node, NODE_COMPARTMENT_TOP) }) : null
   ] });
 }
-function RoundedBody({ node, w, h, cls }) {
-  const r = node.isDef ? 0 : Math.min(h / 2, 20);
+function RoundedBody({ node, w, h, cls, showMult }) {
   const comps = node.compartments ?? [];
+  const r = nodeCornerRadius(node.shape, node.isDef, h, comps.length > 0);
   const composite = node.meta?.composite === true ? " composite" : "";
   const kindFull = `\xAB${node.keyword}\xBB${node.meta?.parallel ? " \u2225" : ""}${variabilityMark(node.keyword)}`;
-  const kindShown = fitKind(kindFull, w - 8);
-  const nameShown = fitText(node.name, w - 12, 11);
+  const titleArea = containerTitleArea(w, nodeShowsControls(node));
+  const cx = titleArea.centerX;
+  const kindShown = fitKind(kindFull, Math.max(24, titleArea.width - 8));
+  const mult = showMult && node.multiplicity ? node.multiplicity : void 0;
+  const { nameShown, typeShown, full: fullTitle, shown: shownTitle } = titleNameLine(
+    node.name,
+    node.type,
+    mult,
+    void 0,
+    Math.max(24, titleArea.width - 12)
+  );
+  const nameLine = (y) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-label", x: cx, y, textAnchor: "middle", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: fullTitle, shown: shownTitle }),
+    nameShown,
+    typeShown ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+      " : ",
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("tspan", { className: "dnode-type", children: typeShown })
+    ] }) : "",
+    mult ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("tspan", { className: "dnode-kind", children: [
+      " ",
+      mult
+    ] }) : ""
+  ] });
   if (comps.length > 0) {
-    const cx = w / 2;
     return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("g", { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("rect", { className: `dnode-rect ${cls}${composite}`, x: 0, y: 0, width: w, height: h, rx: Math.min(r, 12) }),
-      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-kind", x: cx, y: 14, textAnchor: "middle", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("rect", { className: `dnode-rect ${cls}${composite}`, x: 0, y: 0, width: w, height: h, rx: r }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-kind", x: cx, y: CONTAINER_TITLE_KIND_BASELINE, textAnchor: "middle", children: [
         /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: kindFull, shown: kindShown }),
         kindShown
       ] }),
-      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-label", x: cx, y: 28, textAnchor: "middle", children: [
-        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: node.name, shown: nameShown }),
-        nameShown
-      ] }),
-      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Compartments, { node, w })
+      nameLine(CONTAINER_TITLE_NAME_BASELINE),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Compartments, { node, w }),
+      nodeShowsControls(node) ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ContainerBandRule, { w, y: containerBandBottom(node, NODE_COMPARTMENT_TOP) }) : null
     ] });
   }
   return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("g", { children: [
     /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("rect", { className: `dnode-rect ${cls}${composite}`, x: 0, y: 0, width: w, height: h, rx: r }),
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-label", x: w / 2, y: h / 2 - 2, textAnchor: "middle", children: [
-      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: node.name, shown: nameShown }),
-      nameShown
-    ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-kind", x: w / 2, y: h / 2 + 12, textAnchor: "middle", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-kind", x: cx, y: h / 2 - 4, textAnchor: "middle", children: [
       /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: kindFull, shown: kindShown }),
       kindShown
-    ] })
+    ] }),
+    nameLine(h / 2 + 11)
   ] });
 }
 function UseCaseBody({ node, w, h }) {
@@ -192809,8 +193390,8 @@ function LifelineBody({ node, w, lineBottom, activation, eventMarks }) {
     ] })
   ] });
 }
-function PortGlyph({ ph, w, h, showLabels, selected: selected2, hovered, moving, connectTarget, connectStart, onSelect, onContext }) {
-  const rect = portGlyphRect(ph, w, h);
+function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2, hovered, moving, connectTarget, connectStart, onSelect, onContext }) {
+  const rect = portGlyphRect(ph, w, h, topReserve);
   const x = rect.cx;
   const y = rect.cy;
   const half = rect.across / 2;
@@ -192930,12 +193511,12 @@ function PortGlyph({ ph, w, h, showLabels, selected: selected2, hovered, moving,
     }
   );
 }
-function NestedPortToggles({ ports, w, h, onToggle }) {
+function NestedPortToggles({ ports, w, h, topReserve = 0, onToggle }) {
   const hosts = ports.filter((ph) => ph.port.meta?.nestedHost === true);
   if (!hosts.length) return null;
   return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, { children: hosts.map((ph) => {
     const expanded2 = ph.port.meta?.nestedExpanded === true;
-    const at = nestedPortTogglePoint(portGlyphRect(ph, w, h), ph.side);
+    const at = nestedPortTogglePoint(portGlyphRect(ph, w, h, topReserve), ph.side);
     const what = ph.port.pin ? "parameters" : "ports";
     return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
       "button",
@@ -192966,6 +193547,84 @@ function NestedPortToggles({ ports, w, h, onToggle }) {
     );
   }) });
 }
+function ContainerControlGlyph({ kind, expanded: expanded2 }) {
+  const c = CONTAINER_GLYPH_VIEWBOX / 2;
+  const half = CONTAINER_GLYPH_EXTENT / 2;
+  const box = CONTAINER_GLYPH_EXTENT;
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    "svg",
+    {
+      className: kind === "internals" ? "internals-glyph" : "feature-list-glyph",
+      viewBox: `0 0 ${CONTAINER_GLYPH_VIEWBOX} ${CONTAINER_GLYPH_VIEWBOX}`,
+      width: CONTAINER_GLYPH_VIEWBOX,
+      height: CONTAINER_GLYPH_VIEWBOX,
+      "aria-hidden": "true",
+      children: kind === "internals" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("g", { stroke: "currentColor", strokeWidth: "1.8", strokeLinecap: "round", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("line", { x1: c - half, y1: c, x2: c + half, y2: c }),
+        expanded2 ? null : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("line", { x1: c, y1: c - half, x2: c, y2: c + half })
+      ] }) : (
+        // A compartment box carrying its rows while the list is HIDDEN and
+        // empty once it is shown (user direction 2026-08-11, correcting the
+        // first reading: "in collapsed state show hamburger menu"). Like
+        // the `+` beside it, the mark advertises what pressing it reveals,
+        // so no colour has to carry the state. The rows are spaced evenly
+        // about the centre line, so the glyph reads as centred either way.
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("g", { stroke: "currentColor", fill: "none", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("rect", { x: c - half, y: c - half, width: box, height: box, rx: 1.5, strokeWidth: "1.4" }),
+          expanded2 ? null : /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("g", { strokeWidth: "1.2", strokeLinecap: "round", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("line", { x1: c - half + 2.5, y1: c - 1.6, x2: c + half - 2.5, y2: c - 1.6 }),
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("line", { x1: c - half + 2.5, y1: c + 1.6, x2: c + half - 2.5, y2: c + 1.6 })
+          ] })
+        ] })
+      )
+    }
+  );
+}
+function ContainerControls({
+  id: id2,
+  label,
+  internalNoun,
+  internalsVisible,
+  featureCompartmentsVisible,
+  cornerRadius,
+  onToggleInternals,
+  onToggleFeatureCompartments
+}) {
+  if (!onToggleInternals && !onToggleFeatureCompartments) return null;
+  const inset = containerControlsInset(cornerRadius);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "dcontainer-controls nodrag", style: { right: inset, top: inset }, children: [
+    onToggleFeatureCompartments ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      "button",
+      {
+        className: "dfeature-toggle nodrag",
+        title: `${featureCompartmentsVisible ? "Hide" : "Show"} feature compartments`,
+        "aria-label": `${featureCompartmentsVisible ? "Hide" : "Show"} feature compartments of ${label}`,
+        "aria-pressed": featureCompartmentsVisible,
+        onPointerDown: (e) => e.stopPropagation(),
+        onClick: (e) => {
+          e.stopPropagation();
+          onToggleFeatureCompartments(id2);
+        },
+        children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ContainerControlGlyph, { kind: "featureList", expanded: featureCompartmentsVisible })
+      }
+    ) : null,
+    onToggleInternals ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      "button",
+      {
+        className: "div-part-toggle nodrag",
+        title: `${internalsVisible ? "Hide" : "Show"} ${internalNoun}`,
+        "aria-label": `${internalsVisible ? "Hide" : "Show"} ${internalNoun} of ${label}`,
+        "aria-pressed": internalsVisible,
+        onPointerDown: (e) => e.stopPropagation(),
+        onClick: (e) => {
+          e.stopPropagation();
+          onToggleInternals(id2);
+        },
+        children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ContainerControlGlyph, { kind: "internals", expanded: internalsVisible })
+      }
+    ) : null
+  ] });
+}
 function InlineEditor({ initial, mode, elementKind, onCommit, onCancel, w }) {
   const ref = (0, import_react8.useRef)(null);
   (0, import_react8.useEffect)(() => {
@@ -193011,13 +193670,18 @@ var BAND_HEADER_PX = 26;
 var BAND_MIN_W2 = 200;
 var BAND_MIN_H2 = 80;
 var SMALL_GLYPH_SHAPES = /* @__PURE__ */ new Set(["initial", "final", "terminate", "dot", "fork", "join", "decision", "merge"]);
+var INTERNAL_NOUN = {
+  iv: "internal parts",
+  afv: "nested actions",
+  stv: "sub-states"
+};
 function shapeBody(node, data) {
   const { w, h, showMult } = data;
   switch (node.shape) {
     case "state":
-      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(RoundedBody, { node, w, h, cls: "state" });
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(RoundedBody, { node, w, h, cls: "state", showMult });
     case "action":
-      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(RoundedBody, { node, w, h, cls: "action" });
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(RoundedBody, { node, w, h, cls: "action", showMult });
     case "initial":
       return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(InitialBody, { w, h });
     case "final":
@@ -193067,6 +193731,7 @@ function NodeBody({ node, data, selectedPortId, hoveredPortId, movingPortId, con
         ph,
         w,
         h,
+        topReserve: featureBandTopReserve(data),
         showLabels: data.showPortLabels,
         selected: selectedPortId === ph.port.id,
         hovered: hoveredPortId === ph.port.id,
@@ -193096,15 +193761,26 @@ function SysmlNode({ id: id2, data, selected: selected2, width, height }) {
   const dim = useInteraction(ctx.store, (s) => s.matchedIds ? !s.matchedIds.has(id2) : false);
   const editing = useInteraction(ctx.store, (s) => s.editing?.nodeId === id2 && !s.editing?.at && !s.editing?.edgeId ? s.editing : void 0);
   const editingHere = editing !== void 0;
-  const collapsed = (node.meta?.ivCollapsed === true || node.meta?.actionCollapsed === true) && ctx.onToggleContainer;
-  const collapsedWhat = node.meta?.actionCollapsed === true ? "flow" : "internals";
+  const hiddenContainer = node.meta?.internalsHidden === true;
+  const showsControls = nodeShowsControls(node);
+  const internalNoun = INTERNAL_NOUN[data.kind] ?? "internal parts";
+  const featureCompartmentsVisible = node.meta?.featureCompartmentsVisible === true;
+  const featureCompartmentHeight = featureBandTopReserve(data);
   const containerRef = (0, import_react8.useRef)(null);
   const portSource = (pid) => {
     const p = node.ports?.find((pp) => pp.id === pid);
     ctx.onPortSelected?.();
     ctx.onReveal(p?.source, pid);
   };
-  const { dragId, onPortPointerDown } = usePortDrag(containerRef, w, h, ctx.onPortMove, ctx.onPortPreview, portSource);
+  const { dragId, onPortPointerDown } = usePortDrag(
+    containerRef,
+    w,
+    h,
+    featureCompartmentHeight,
+    ctx.onPortMove,
+    ctx.onPortPreview,
+    portSource
+  );
   const ports = data.ports;
   const liveData = { ...data, w, h, ports };
   const directRelation = directRelationForHandle(data.kind, {
@@ -193144,7 +193820,9 @@ function SysmlNode({ id: id2, data, selected: selected2, width, height }) {
       children: [
         resizable ? (() => {
           const min2 = resizeMinFor(node.shape, h);
-          return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(NodeResizer, { minWidth: min2.minWidth, minHeight: min2.minHeight, maxHeight: min2.maxHeight, isVisible: true, color: "var(--accent)" });
+          const minWidth = showsControls ? Math.max(min2.minWidth, COLLAPSED_CONTAINER_MIN_WIDTH) : min2.minWidth;
+          const minHeight = Math.max(min2.minHeight, data.featureCompartmentMinHeight ?? 0);
+          return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(NodeResizer, { minWidth, minHeight, maxHeight: min2.maxHeight, isVisible: true, color: "var(--accent)" });
         })() : null,
         /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
           NodeBody,
@@ -193160,12 +193838,25 @@ function SysmlNode({ id: id2, data, selected: selected2, width, height }) {
             onPortContext: ctx.onContextNode
           }
         ),
+        data.kind === "iv" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          "div",
+          {
+            className: "rf-node-header",
+            title: node.name,
+            style: {
+              left: 0,
+              top: 0,
+              height: NODE_COMPARTMENT_TOP,
+              width: containerTitleArea(w, nodeShowsControls(node)).width
+            }
+          }
+        ) : null,
         SIDES.flatMap((side, si) => {
           const n2 = SIDE_NORMAL[side];
           const out = SMALL_GLYPH_SHAPES.has(node.shape) ? 9 : 0;
           const offsets = sideOffsets[si];
           return offsets.map((offset2, i) => {
-            const { x, y } = sideSurfacePoint(node.shape, side, offset2, w, h);
+            const { x, y } = sideSurfacePoint(node.shape, side, offset2, w, h, featureCompartmentHeight);
             return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
               DualHandle,
               {
@@ -193182,7 +193873,7 @@ function SysmlNode({ id: id2, data, selected: selected2, width, height }) {
           });
         }),
         ports.flatMap((ph) => {
-          const rect = portGlyphRect(ph, w, h);
+          const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
           const c = { x: rect.cx, y: rect.cy };
           const startable = directRelationForHandle(data.kind, {
             id: ph.port.id,
@@ -193203,7 +193894,7 @@ function SysmlNode({ id: id2, data, selected: selected2, width, height }) {
           ];
         }),
         ctx.onPortMove ? ports.map((ph) => {
-          const rect = portGlyphRect(ph, w, h);
+          const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
           const nestedChild = ph.port.parentPort !== void 0;
           const strip = portInteractionStrip(rect, ph.side);
           return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
@@ -193237,20 +193928,27 @@ function SysmlNode({ id: id2, data, selected: selected2, width, height }) {
           }
           return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, { children: handles });
         })() : null,
-        ctx.onToggleNestedPort ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(NestedPortToggles, { ports, w, h, onToggle: ctx.onToggleNestedPort }) : null,
-        collapsed ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-          "button",
+        ctx.onToggleNestedPort ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          NestedPortToggles,
           {
-            className: "div-part-toggle nodrag",
-            title: collapsedWhat === "flow" ? "Show the actions inside this one" : "Show internal parts and connections",
-            "aria-label": `Show ${collapsedWhat} of ${node.name}`,
-            style: { position: "absolute", right: 2, top: 2 },
-            onPointerDown: (e) => e.stopPropagation(),
-            onClick: (e) => {
-              e.stopPropagation();
-              ctx.onToggleContainer(id2);
-            },
-            children: "+"
+            ports,
+            w,
+            h,
+            topReserve: featureCompartmentHeight,
+            onToggle: ctx.onToggleNestedPort
+          }
+        ) : null,
+        showsControls ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          ContainerControls,
+          {
+            id: id2,
+            label: node.name,
+            internalNoun,
+            internalsVisible: !hiddenContainer,
+            featureCompartmentsVisible,
+            cornerRadius: nodeCornerRadius(node.shape, node.isDef, h, (node.compartments?.length ?? 0) > 0),
+            onToggleInternals: ctx.onToggleInternals,
+            onToggleFeatureCompartments: ctx.onToggleFeatureCompartments
           }
         ) : null,
         editingHere && ctx.onEditCommit && ctx.onEditCancel ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
@@ -193286,6 +193984,23 @@ function packageFramePath(w, h) {
     "Z"
   ].join(" ");
 }
+function frameFeatureBandPath(w, h, bottom, radius) {
+  const left = 1;
+  const right = Math.max(left, w - 1);
+  const top = 1;
+  const end = Math.max(top, Math.min(bottom, h - 1));
+  const r = Math.max(0, Math.min(radius, (right - left) / 2, end - top));
+  if (r === 0) return `M ${left} ${top} H ${right} V ${end} H ${left} Z`;
+  return [
+    `M ${left} ${top + r}`,
+    `Q ${left} ${top} ${left + r} ${top}`,
+    `H ${right - r}`,
+    `Q ${right} ${top} ${right} ${top + r}`,
+    `V ${end}`,
+    `H ${left}`,
+    "Z"
+  ].join(" ");
+}
 function FrameNode({ id: id2, data, selected: selected2, width, height }) {
   const ctx = useDiagram();
   const frame2 = data.frame;
@@ -193300,13 +194015,30 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
   const isPackage2 = frame2.keyword === "package";
   const isLibraryPackage = isPackage2 && frame2.meta?.library === true;
   const resizable = selected2 && (!isPackage2 || data.kind === "gv");
-  const collapsible = isCollapsibleFrame(data.kind, frame2) && ctx.onToggleContainer;
+  const collapsible = isCollapsibleFrame(data.kind, frame2);
+  const controllable = collapsible && (ctx.onToggleInternals !== void 0 || ctx.onToggleFeatureCompartments !== void 0);
+  const internalNoun = INTERNAL_NOUN[data.kind] ?? "internal parts";
+  const featureCompartmentsVisible = frame2.meta?.featureCompartmentsVisible === true;
+  const featureBandHeight = data.featureCompartmentHeight ?? frameFeatureCompartmentHeight(frame2);
+  const featureCompartmentHeight = featureBandHeight > 0 ? FRAME_TITLE_HEIGHT + featureBandHeight : 0;
+  const bandBottom = containerBandBottom(
+    featureBandHeight > 0 ? frame2 : { compartments: void 0 },
+    FRAME_TITLE_HEIGHT
+  );
   const containerRef = (0, import_react8.useRef)(null);
   const portSource = (pid) => {
     ctx.onPortSelected?.();
     ctx.onReveal(frame2.ports?.find((p) => p.id === pid)?.source, pid);
   };
-  const { dragId, onPortPointerDown } = usePortDrag(containerRef, w, h, ctx.onPortMove, ctx.onPortPreview, portSource);
+  const { dragId, onPortPointerDown } = usePortDrag(
+    containerRef,
+    w,
+    h,
+    featureCompartmentHeight,
+    ctx.onPortMove,
+    ctx.onPortPreview,
+    portSource
+  );
   const ports = data.ports;
   const showPorts = ports.length > 0;
   const isOuterViewFrame = (data.kind === "afv" || data.kind === "stv") && frame2.meta?.anchorFrame === true;
@@ -193345,32 +194077,59 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
         ctx.onContextNode(id2, e.clientX, e.clientY);
       },
       children: [
-        resizable ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(NodeResizer, { minWidth: isPackage2 ? 180 : 80, minHeight: isPackage2 ? 100 : 60, isVisible: true, color: "var(--accent)" }) : null,
+        resizable ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          NodeResizer,
+          {
+            minWidth: isPackage2 ? 180 : 80,
+            minHeight: Math.max(isPackage2 ? 100 : 60, data.featureCompartmentMinHeight ?? 0),
+            isVisible: true,
+            color: "var(--accent)"
+          }
+        ) : null,
         /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("svg", { className: "rf-node-svg", width: w, height: h, style: { overflow: "visible" }, children: [
           /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("rect", { className: "dframe-hover-band", x: 0, y: 0, width: w, height: h, rx: 12, fill: "none", stroke: "transparent" }),
           isPackage2 && data.kind === "gv" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("path", { className: `dframe-rect package${isLibraryPackage ? " library" : ""}${data.isContainer ? " container" : ""}`, d: packageFramePath(w, h) }) : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("rect", { className: `dframe-rect${data.isContainer ? " container" : ""}${frame2.meta?.boundaryBox === true ? " boundary" : ""}${frame2.meta?.parallel === true ? " parallel" : ""}${frame2.meta?.loop === true ? " loop" : ""}${frame2.meta?.performerLane === true ? " performer" : ""}`, x: 0, y: 0, width: w, height: h, rx: frame2.isDef === true ? 0 : 12 }),
+          collapsible ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            "path",
+            {
+              className: "dfeature-band-bg",
+              d: frameFeatureBandPath(w, h, bandBottom, frame2.isDef === true ? 0 : 12)
+            }
+          ) : null,
           (() => {
             const kindFull = `\xAB${frame2.keyword}\xBB${isLibraryPackage ? " (standard library)" : ""}${frame2.meta?.parallel === true ? " \u2225" : ""}${variabilityMark(frame2.keyword)}`;
-            const kindShown = fitKind(kindFull, Math.max(40, w - 40));
-            const labelX = 10 + (kindShown.length + 1) * 7;
-            const labelShown = fitText(frame2.label, Math.max(24, w - labelX - 10), 11);
+            const avail = Math.max(24, containerTitleArea(w, controllable).width - 14);
+            const kindShown = fitKind(kindFull, avail);
+            const mult = data.showMult && frame2.multiplicity ? frame2.multiplicity : void 0;
+            const title = titleNameLine(frame2.label, frame2.type, mult, void 0, avail);
             return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
-              /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-kind", x: 10, y: 16, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-kind", x: 10, y: CONTAINER_TITLE_KIND_BASELINE, children: [
                 /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: kindFull, shown: kindShown }),
                 kindShown
               ] }),
-              /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-label", x: labelX, y: 16, style: { fontSize: 11 }, children: [
-                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: frame2.label, shown: labelShown }),
-                labelShown
+              /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("text", { className: "dnode-label", x: 10, y: CONTAINER_TITLE_NAME_BASELINE, style: { fontSize: 11 }, children: [
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FullTitle, { full: title.full, shown: title.shown }),
+                title.nameShown,
+                title.typeShown ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+                  " : ",
+                  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("tspan", { className: "dnode-type", children: title.typeShown })
+                ] }) : "",
+                mult ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("tspan", { className: "dnode-kind", children: [
+                  " ",
+                  mult
+                ] }) : ""
               ] })
             ] });
           })(),
+          featureBandHeight > 0 ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Compartments, { node: frame2, w, top: FRAME_TITLE_HEIGHT }) : null,
+          collapsible ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ContainerBandRule, { w, y: bandBottom }) : null,
           ports.map((ph) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
             PortGlyph,
             {
               ph,
               w,
               h,
+              topReserve: featureCompartmentHeight,
               showLabels: true,
               selected: selectedPortId === ph.port.id,
               hovered: hoveredPortId === ph.port.id,
@@ -193383,11 +194142,18 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
             ph.port.id
           ))
         ] }),
-        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "rf-frame-header", style: { left: 0, top: 0, width: "100%", height: 22 }, title: frame2.label }),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          "div",
+          {
+            className: "rf-frame-header",
+            style: { left: 0, top: 0, width: "100%", height: FRAME_TITLE_HEIGHT },
+            title: frame2.label
+          }
+        ),
         SIDES.flatMap((side, si) => {
           const offsets = sideOffsets[si];
           return offsets.map((offset2, i) => {
-            const { x, y } = sideXY(side, offset2, w, h);
+            const { x, y } = sidePoint(side, offset2, w, h, featureCompartmentHeight);
             return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
               DualHandle,
               {
@@ -193404,7 +194170,7 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
           });
         }),
         showPorts ? ports.flatMap((ph) => {
-          const rect = portGlyphRect(ph, w, h);
+          const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
           const c = { x: rect.cx, y: rect.cy };
           const startable = directRelationForHandle(data.kind, {
             id: ph.port.id,
@@ -193425,7 +194191,7 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
           ];
         }) : null,
         ctx.onPortMove ? ports.map((ph) => {
-          const rect = portGlyphRect(ph, w, h);
+          const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
           const nestedChild = ph.port.parentPort !== void 0;
           const strip = portInteractionStrip(rect, ph.side);
           return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
@@ -193447,20 +194213,27 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
             `pd-${ph.port.id}`
           );
         }) : null,
-        ctx.onToggleNestedPort ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(NestedPortToggles, { ports, w, h, onToggle: ctx.onToggleNestedPort }) : null,
+        ctx.onToggleNestedPort ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          NestedPortToggles,
+          {
+            ports,
+            w,
+            h,
+            topReserve: featureCompartmentHeight,
+            onToggle: ctx.onToggleNestedPort
+          }
+        ) : null,
         collapsible ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-          "button",
+          ContainerControls,
           {
-            className: "div-part-toggle nodrag",
-            title: data.kind === "afv" ? "Hide the actions inside this one" : "Show compartments",
-            "aria-label": data.kind === "afv" ? `Collapse ${frame2.label}` : `Show compartments of ${frame2.label}`,
-            style: { position: "absolute", right: 2, top: 2 },
-            onPointerDown: (e) => e.stopPropagation(),
-            onClick: (e) => {
-              e.stopPropagation();
-              ctx.onToggleContainer(id2);
-            },
-            children: "\u2212"
+            id: id2,
+            label: frame2.label,
+            internalNoun,
+            internalsVisible: true,
+            featureCompartmentsVisible,
+            cornerRadius: frame2.isDef === true ? 0 : FRAME_USAGE_CORNER_RADIUS,
+            onToggleInternals: ctx.onToggleInternals,
+            onToggleFeatureCompartments: ctx.onToggleFeatureCompartments
           }
         ) : null,
         editing && ctx.onEditCommit && ctx.onEditCancel ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
@@ -193648,9 +194421,9 @@ function resolveViewConfig(settings, view, overrides = {}) {
     gvFilters: new Set(view?.gvFilters ?? []),
     // Case View definitions are shown unless the user turned them off.
     cvShowDefs: view?.cvShowDefs !== false,
-    ivCompartments: view?.ivCompartments ?? {},
+    hiddenInternals: view?.hiddenInternals ?? {},
+    visibleFeatureCompartments: view?.visibleFeatureCompartments ?? {},
     nestedPorts: view?.nestedPorts ?? {},
-    collapsedActions: view?.collapsedActions ?? {},
     showPortLabels: settings.showPortLabels,
     showMultiplicities: settings.showMultiplicities,
     showSubjectAsBoundaryBox: settings.showSubjectAsBoundaryBox,
@@ -193725,9 +194498,9 @@ async function renderDiagramSvg(document2, provider, options) {
     showMult: config.showMultiplicities,
     connectPointSpacing: config.connectPointSpacing,
     subjectBoundary: config.showSubjectAsBoundaryBox,
-    ivCompartments: config.ivCompartments,
+    hiddenInternals: config.hiddenInternals,
+    visibleFeatureCompartments: config.visibleFeatureCompartments,
     nestedPorts: config.nestedPorts,
-    collapsedActions: config.collapsedActions,
     overrides: config.overrides,
     portOverrides: config.portOverrides,
     edgeRoutes: config.edgeRoutes,
@@ -193797,7 +194570,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.14.5" : "dev";
+var VERSION2 = true ? "0.15.1" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;