sysml-diagram 0.21.0 → 0.22.0

package/out/main.js

@@ -161733,9 +161733,16 @@ function nameOf(node) {
   const name = node?.name;
   if (typeof name === "string" && name.length > 0)
     return name;
-  if (node?.$type === "FeatureRedefinitionShorthand") {
-    const leading = node.preRelationships?.[0]?.targets?.[0];
-    return leading ? lastSegment(leading) : void 0;
+  const relational = node;
+  for (const relationship of [
+    ...relational?.preRelationships ?? [],
+    ...relational?.relationships ?? []
+  ]) {
+    if (relationship.kind !== ":>>" && relationship.kind !== "redefines")
+      continue;
+    const target = relationship.targets?.[0];
+    if (target)
+      return lastSegment(target);
   }
   if (node?.$type === "FeatureShorthand") {
     const text = node.$cstNode?.text;
@@ -161752,9 +161759,16 @@ function nameOf(node) {
   return void 0;
 }
 function unwrap(node) {
-  if (node.$type !== "PrefixMetadataMember")
-    return node;
-  return node.element ?? node;
+  let current2 = node;
+  const seen = /* @__PURE__ */ new Set();
+  while ((current2.$type === "PrefixMetadataMember" || current2.$type === "MemberPrefixDecl") && !seen.has(current2)) {
+    seen.add(current2);
+    const element = current2.element;
+    if (!element)
+      break;
+    current2 = element;
+  }
+  return current2;
 }
 function directNamedChildren(node) {
   const result = [];
@@ -161785,12 +161799,32 @@ function isSelfReference(candidate, node) {
 function lastSegment(path10) {
   return path10.split(/::|\./u).pop() ?? path10;
 }
+function simpleRelationName(path10) {
+  let quoted = false;
+  for (let index2 = 0; index2 < path10.length; index2 += 1) {
+    const char = path10[index2];
+    if (quoted) {
+      if (char === "\\")
+        index2 += 1;
+      else if (char === "'")
+        quoted = false;
+      continue;
+    }
+    if (char === "'")
+      quoted = true;
+    else if (char === "." || char === ":" && path10[index2 + 1] === ":")
+      return void 0;
+  }
+  const withoutMultiplicity = path10.replace(/\s*\[[^\]]*\]\s*$/u, "").trim();
+  return withoutMultiplicity ? canonicalEscapedName(withoutMultiplicity) : void 0;
+}
 var FeaturePathResolver = class {
   indexManager;
   descriptions;
   documents;
   locator;
   snapshots = /* @__PURE__ */ new WeakMap();
+  resolvingSpecializations = /* @__PURE__ */ new Set();
   constructor(services) {
     this.indexManager = services?.shared.workspace.IndexManager;
     this.descriptions = services?.workspace.AstNodeDescriptionProvider;
@@ -161893,6 +161927,14 @@ var FeaturePathResolver = class {
     }
     return result;
   }
+  /** Semantic owners reached through typing and specialization. This is used
+   * when an anonymous redefinition has no keyword from which to recover its
+   * feature kind. */
+  // REQ-364: recover the semantic kind of an anonymous local redefinition.
+  inheritedOwners(node) {
+    const root4 = ast_utils_exports.getDocument(node).parseResult.value;
+    return this.typedAndSpecializedOwners(node, this.snapshot(root4));
+  }
   segmentsOf(node) {
     const cst = node.$cstNode;
     if (!cst)
@@ -162038,20 +162080,45 @@ var FeaturePathResolver = class {
     return typed;
   }
   specializationTargets(node, snapshot) {
+    if (this.resolvingSpecializations.has(node))
+      return [];
+    this.resolvingSpecializations.add(node);
     const relNode = node;
     const result = [];
-    for (const relation of [...relNode.preRelationships ?? [], ...relNode.relationships ?? []]) {
-      if (!relation.kind || !SPECIALIZATION_KINDS.has(relation.kind))
-        continue;
-      for (const target of relation.targets ?? []) {
-        const description = this.pickDescription(snapshot.byName.get(target)) ?? this.pickDescription(snapshot.byName.get(lastSegment(target)));
-        const resolved = this.nodeOf(description);
-        if (resolved)
-          result.push(resolved);
+    try {
+      for (const relation of [...relNode.preRelationships ?? [], ...relNode.relationships ?? []]) {
+        if (!relation.kind || !SPECIALIZATION_KINDS.has(relation.kind))
+          continue;
+        for (const target of relation.targets ?? []) {
+          const simple = simpleRelationName(target);
+          const scoped = simple ? this.scopedSpecializationTarget(node, simple, snapshot) : void 0;
+          const description = scoped ? void 0 : this.pickDescription(snapshot.byName.get(target), node) ?? this.pickDescription(snapshot.byName.get(lastSegment(target)), node);
+          const resolved = scoped ?? this.nodeOf(description);
+          if (resolved)
+            result.push(resolved);
+        }
       }
+    } finally {
+      this.resolvingSpecializations.delete(node);
     }
     return result;
   }
+  /** A simple feature specialization is resolved in the visible inventory of
+   * its lexical owner. Only an absent scoped match may fall back to the global
+   * index, which prevents an unrelated same-named feature from winning. */
+  scopedSpecializationTarget(node, name, snapshot) {
+    for (let scope = node.$container; scope; scope = scope.$container) {
+      const local = directNamedChildren(scope).find((candidate) => candidate !== node && nameOf(candidate) === name);
+      if (local)
+        return local;
+      for (const owner of this.typedAndSpecializedOwners(scope, snapshot)) {
+        const inherited = directNamedChildren(owner).find((candidate) => candidate !== node && nameOf(candidate) === name);
+        if (inherited)
+          return inherited;
+      }
+    }
+    return void 0;
+  }
   memberInventoryKnown(node, snapshot) {
     const record = node;
     if (record.isDef === true || node.$type === "ClassDecl" || node.$type === "StructDecl" || node.$type === "EnumDecl" || node.$type === "DatatypeDecl" || node.$type === "FunctionDecl" || node.$type === "PredicateDecl") {
@@ -162243,14 +162310,21 @@ function sourceOf2(node, uri) {
     return { uri, range };
   }
 }
+function isAstDescendantOrSelf(node, ancestor) {
+  for (let current2 = node; current2; current2 = current2.$container) {
+    if (current2 === ancestor)
+      return true;
+  }
+  return false;
+}
 function ivEditMeta(part, instanceId, definition, localUsage, localPath, uri) {
-  const declarationId = qnameOf(part) || instanceId;
+  const declarationId = nameOf2(part) ? qnameOf(part) || instanceId : instanceId;
   const definitionId = definition ? qnameOf(definition) : void 0;
   const localUsageId = localUsage ? qnameOf(localUsage) : void 0;
   return {
     instanceId,
     declarationId,
-    declarationName: nameOf2(part),
+    declarationName: effectiveNameOf(part),
     declarationSource: sourceOf2(part, uri),
     definitionId,
     definitionName: definition ? nameOf2(definition) : void 0,
@@ -162259,7 +162333,10 @@ function ivEditMeta(part, instanceId, definition, localUsage, localPath, uri) {
     localUsageName: localUsage ? nameOf2(localUsage) : void 0,
     localUsageSource: localUsage ? sourceOf2(localUsage, uri) : void 0,
     localUsagePath: [...localPath],
-    expandedFromDefinition: declarationId !== instanceId
+    expandedFromDefinition: declarationId !== instanceId,
+    // A named declaration remains local even when an anonymous `:>>`
+    // wrapper removes its name from the rendered occurrence path.
+    localDeclaration: !!nameOf2(part) && !!localUsage && isAstDescendantOrSelf(part, localUsage)
   };
 }
 var nameOf2 = (node) => {
@@ -162286,10 +162363,7 @@ function boundText(b) {
     return String(b.intVal);
   return b.bound;
 }
-function multText(node) {
-  if (!node)
-    return void 0;
-  const m = node.multiplicity;
+function multiplicityText(m) {
   if (!m)
     return void 0;
   const lo = boundText(m.lower);
@@ -162298,6 +162372,11 @@ function multText(node) {
     return void 0;
   return hi == null || hi === lo ? `[${lo}]` : `[${lo}..${hi}]`;
 }
+function multText(node) {
+  if (!node)
+    return void 0;
+  return multiplicityText(node.multiplicity);
+}
 var typeText = (node) => node.typing?.type?.$refText || void 0;
 var isConjugated = (node) => node.typing?.conjugate === true;
 var isAbstract = (node) => Array.isArray(node.modifiers) && node.modifiers.includes("abstract");
@@ -162428,6 +162507,18 @@ var modifiersOf = (node) => {
   const mods = node.modifiers;
   return Array.isArray(mods) ? mods : [];
 };
+var ANONYMOUS_INTERFACE_NAME = "(anonymous)";
+var isEndMember = (node) => node.$type === "EndDecl" || modifiersOf(node).includes("end");
+function endRowText(node) {
+  const end = node;
+  const name = nameOf2(node) ?? end.innerName;
+  const type = typeText(node) ?? end.innerTyping?.type?.$refText;
+  const mult = multText(node) ?? multiplicityText(end.innerMultiplicity) ?? multiplicityText(end.endMultiplicity);
+  const head2 = `${name ?? ""}${type ? `${name ? " " : ""}: ${type}` : ""}`.trim();
+  if (!head2)
+    return void 0;
+  return `${head2}${mult ? ` ${mult}` : ""}`;
+}
 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);
@@ -162466,6 +162557,16 @@ function specializationTargets(node) {
   }
   return out;
 }
+function featureInheritanceTargets(node) {
+  const n2 = node;
+  const out = [];
+  for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
+    if (rel2.kind === ":>" || rel2.kind === ":>>" || rel2.kind === "specializes" || rel2.kind === "subsets" || rel2.kind === "redefines") {
+      out.push(...rel2.targets ?? []);
+    }
+  }
+  return out;
+}
 function specializationFamily(node) {
   const n2 = node;
   const isDef = n2.isDef === true;
@@ -162562,9 +162663,11 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     if (hit)
       cache.models.delete(cacheKey);
     const model = this.computeDiagramModel(document2, root4, rootSymbol, kind, preferFileOverview, gridPreset, matrixRelationship);
+    const externalRoots = this.externalRootsOf(model, document2.uri.toString());
+    model.dependencies = [document2.uri.toString(), ...externalRoots.keys()];
     cache.models.set(cacheKey, {
       model,
-      externalRoots: this.externalRootsOf(model, document2.uri.toString()),
+      externalRoots,
       indexEpoch: this.indexEpoch
     });
     return model;
@@ -162586,21 +162689,24 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       if (source?.uri && source.uri !== anchorUri)
         uris.add(source.uri);
     };
-    for (const node of model.nodes) {
-      add(node.source);
-      for (const port of node.ports ?? [])
-        add(port.source);
-    }
-    for (const frame2 of model.frames ?? []) {
-      add(frame2.source);
-      for (const port of frame2.ports ?? [])
-        add(port.source);
-    }
-    add(model.ivBoundary?.source);
-    for (const port of model.ivBoundary?.ports ?? [])
-      add(port.source);
-    for (const edge of model.edges)
-      add(edge.source);
+    const seen = /* @__PURE__ */ new Set();
+    const addSources = (value) => {
+      if (!value || typeof value !== "object" || seen.has(value))
+        return;
+      seen.add(value);
+      if (Array.isArray(value)) {
+        for (const item of value)
+          addSources(item);
+        return;
+      }
+      const record = value;
+      if (typeof record.uri === "string" && record.range && typeof record.range === "object") {
+        add(record);
+      }
+      for (const nested of Object.values(record))
+        addSources(nested);
+    };
+    addSources(model);
     return new Map([...uris].map((uri) => [uri, this.externalDocumentRoot(uri)]));
   }
   computeDiagramModel(document2, root4, rootSymbol, kind, preferFileOverview, gridPreset = "requirements", matrixRelationship = "allocation") {
@@ -162926,7 +163032,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           if (local)
             return local;
           const declaringIndex = this.localIndex(this.documentRootOf(scope));
-          for (const inherited of this.inheritedTypesOf(scope, declaringIndex)) {
+          for (const inherited of this.inheritedFeatureOwnersOf(scope, declaringIndex)) {
             const inheritedMember = membersOf(inherited).find((member) => nameOf2(member) === unrooted);
             if (inheritedMember)
               return inheritedMember;
@@ -162991,6 +163097,105 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     }
     return chain;
   }
+  // REQ-061/REQ-192/REQ-364 - the effective feature owners inherited by a
+  // definition or usage. A redefining usage specializes both its explicit type
+  // and the feature it redefines. The latter can contribute its own body and its
+  // type's complete inventory, so following only typing definitions turns an
+  // anonymous `part :>> inheritedPart` into an empty leaf.
+  inheritedFeatureOwnersOf(node, index2, resolving = /* @__PURE__ */ new Set()) {
+    if (resolving.has(node))
+      return [];
+    resolving.add(node);
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set([node]);
+    const queue = [];
+    const add = (candidate) => {
+      if (!candidate || seen.has(candidate))
+        return;
+      seen.add(candidate);
+      chain.push(candidate);
+      queue.push(candidate);
+    };
+    const addTargets = (owner) => {
+      for (const target of featureInheritanceTargets(owner)) {
+        add(this.resolveFeatureInheritanceTarget(owner, target, index2, resolving));
+      }
+    };
+    try {
+      if (node.isDef === true)
+        addTargets(node);
+      else {
+        add(this.resolveType(node, index2));
+        addTargets(node);
+      }
+      while (queue.length > 0) {
+        const owner = queue.shift();
+        if (owner.isDef !== true)
+          add(this.resolveType(owner, index2));
+        addTargets(owner);
+      }
+      return chain;
+    } finally {
+      resolving.delete(node);
+    }
+  }
+  /** Declaration that an anonymous local redefinition specializes. Direct edits
+   * in definition-sync mode address this feature, while child insertion still
+   * addresses the feature's typing definition. */
+  synchronizationDeclarationOf(node, index2) {
+    if (nameOf2(node))
+      return node;
+    const wanted = effectiveNameOf(node);
+    return this.inheritedFeatureOwnersOf(node, index2).find((candidate) => candidate.isDef !== true && effectiveNameOf(candidate) === wanted && (isPartDecl(node) ? isPartDecl(candidate) : isPortDecl(node) ? isPortDecl(candidate) : true));
+  }
+  /** Resolve a usage specialization in its feature scope. A simple `:>> x`
+   * names a sibling supplied by the containing usage or one of its types. A
+   * global simple-name lookup can select the redeclaration itself or an
+   * unrelated namesake, so the containing feature inventory is checked first. */
+  resolveFeatureInheritanceTarget(owner, target, index2, resolving) {
+    const path10 = this.resolvedFeatureInheritancePath(owner, target);
+    if (path10.qualified) {
+      return path10.target === owner ? void 0 : path10.target;
+    }
+    if (owner.isDef !== true) {
+      const wanted = lastSeg(target);
+      const container = owner.$container;
+      if (container) {
+        for (const source of [container, ...this.inheritedFeatureOwnersOf(container, index2, resolving)]) {
+          const inherited = membersOf(source).find((member) => member !== owner && effectiveNameOf(member) === wanted);
+          if (inherited)
+            return inherited;
+        }
+      }
+    }
+    const resolved = path10.target ?? this.resolveSpecializationTarget(owner, target, index2);
+    return resolved === owner ? void 0 : resolved;
+  }
+  /** Resolve a relationship target through the shared feature path service.
+   * Qualified paths must retain every segment because a last-segment lookup can
+   * select an unrelated sibling with the same name. */
+  resolvedFeatureInheritancePath(owner, target) {
+    const relationships = [
+      ...owner.preRelationships ?? [],
+      ...owner.relationships ?? []
+    ];
+    const resolver = this.annotationPathResolver(owner);
+    for (const relationship of relationships) {
+      if (!relationship.kind || ![":>", ":>>", "specializes", "subsets", "redefines"].includes(relationship.kind))
+        continue;
+      for (const [occurrence, written] of (relationship.targets ?? []).entries()) {
+        if (written !== target)
+          continue;
+        const resolution = resolver.resolvePropertyPath(relationship, "targets", occurrence);
+        const segment = resolution.segments.at(-1);
+        return {
+          qualified: resolution.segments.length > 1,
+          target: segment?.target ?? this.annotationDescriptionNode(owner, segment?.description)
+        };
+      }
+    }
+    return { qualified: /::|\./u.test(target) };
+  }
   // issue #233 (PR #239 review) — one supertype path, resolved. A specialization
   // target is path TEXT in this grammar, not a cross-reference, so there is no
   // linked node to prefer the way `resolveType` prefers `typing.type.ref`; the
@@ -163466,7 +163671,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     return this.collectGeometry(node, index2).length > 0;
   }
   hasRenderablePorts(node, index2) {
-    return [node, ...this.inheritedTypesOf(node, index2)].some((source) => membersOf(source).some((m) => isPortDecl(m) && m.isDef !== true));
+    return [node, ...this.inheritedFeatureOwnersOf(node, index2)].some((source) => membersOf(source).some((m) => isPortDecl(m) && m.isDef !== true));
   }
   // REQ-192, issue #233 — the named part usages a part shows when expanded: its
   // own and the ones it inherits, through its typing definition or a `:>`
@@ -163474,7 +163679,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // The predicate form of `childUsagesOf`, so an anchor that only INHERITS
   // internals is recognised as having them.
   hasNestedPartUsages(node, index2) {
-    return [node, ...this.inheritedTypesOf(node, index2)].some((source) => this.nestedUsages(source, isPartDecl).some((n2) => nameOf2(n2) !== void 0));
+    return [node, ...this.inheritedFeatureOwnersOf(node, index2)].some((source) => this.nestedUsages(source, isPartDecl).some((n2) => nameOf2(n2) !== void 0));
   }
   nestedUsages(node, guard) {
     return membersOf(node).filter((m) => guard(m) && m.isDef !== true);
@@ -163513,7 +163718,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const all = [...ast_utils_exports.streamAllContents(scope)];
     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) || isDefinitionNode(n2) && !!nameOf2(n2) || this.isViewlessUsage(n2) && this.isDirectPackageMember(n2) || isPartDecl(n2) && n2.isDef !== true && !!nameOf2(n2) && this.isDirectPackageMember(n2));
+    const isPackageInterfaceUsage = (n2) => isInterfaceDecl(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) || isPackageInterfaceUsage(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))
@@ -163571,7 +163777,12 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         meta: { gvPackageMember: true }
       });
     }
-    const packageUsageNodes = [...viewlessUsageNodes, ...packagePartUsageNodes];
+    const packageInterfaceUsageNodes = all.filter(isPackageInterfaceUsage);
+    for (const u of packageInterfaceUsageNodes) {
+      const def = this.resolveType(u, index2);
+      pushNode(u, "box", false, { type: def && ids.has(def) ? void 0 : typeText(u) });
+    }
+    const packageUsageNodes = [...viewlessUsageNodes, ...packagePartUsageNodes, ...packageInterfaceUsageNodes];
     for (const p of packageNodes) {
       const pn = p;
       pushNode(p, "package", false, {
@@ -164144,7 +164355,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const childUsagesOf = (part) => {
       const out = this.nestedUsages(part, isPartDecl);
       const have = new Set(out.map(effectiveNameOf).filter((x) => !!x));
-      for (const source of this.inheritedTypesOf(part, index2)) {
+      for (const source of this.inheritedFeatureOwnersOf(part, index2)) {
         for (const usage of this.nestedUsages(source, isPartDecl)) {
           const nm = effectiveNameOf(usage);
           if (nm !== void 0) {
@@ -164157,7 +164368,27 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       }
       return out;
     };
-    const effectiveMembersOf = (part) => [part, ...this.inheritedTypesOf(part, index2)].flatMap((source) => membersOf(source));
+    const effectiveMembersOf = (part) => {
+      const effective = [];
+      const claimedNames = /* @__PURE__ */ new Set();
+      for (const source of [part, ...this.inheritedFeatureOwnersOf(part, index2)]) {
+        for (const member of membersOf(source)) {
+          const relationship = member;
+          const emptyPrefixFlow = member.$type === "FlowStmt" && relationship.target !== void 0 && relationship.source === void 0;
+          const emptyPrefixInterface = isInterfaceDecl(member) && relationship.target !== void 0 && relationship.connect === void 0;
+          const namedRelationship = isConnectorDecl(member) || isConnectionDecl(member) || isInterfaceDecl(member) && !emptyPrefixInterface || member.$type === "BindingDecl" || member.$type === "FlowStmt" && !emptyPrefixFlow;
+          if (namedRelationship) {
+            const names = [nameOf2(member), redefinedNameOf(member)].filter((name) => name !== void 0);
+            if (names.some((name) => claimedNames.has(name)))
+              continue;
+            for (const name of names)
+              claimedNames.add(name);
+          }
+          effective.push(member);
+        }
+      }
+      return effective;
+    };
     const childResolver = (childInfos, self2, actionInfos = []) => {
       const localPort = /* @__PURE__ */ new Map();
       const actionPort = /* @__PURE__ */ new Map();
@@ -164235,14 +164466,22 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return { resolve: resolve8, actionPinIds };
     };
     const renderInstance = (part, instanceId, parentFrame, seenTypes, depth, inheritedLocalUsage, inheritedLocalPath = []) => {
-      const ports = this.portsOf(part, index2, uri, instanceId).ports;
-      const typeDef = part.isDef === true ? void 0 : this.resolveType(part, index2);
+      const typeDef = part.isDef === true ? void 0 : this.resolveType(part, index2) ?? this.inheritedFeatureOwnersOf(part, index2).find((owner) => owner.isDef === true);
       const typeQ = typeDef ? qnameOf(typeDef) : void 0;
-      const declarationId = qnameOf(part) || instanceId;
-      const projected = declarationId !== instanceId;
+      const declarationId = nameOf2(part) ? qnameOf(part) || instanceId : instanceId;
+      const projected = nameOf2(part) === void 0 || declarationId !== instanceId;
       const localUsage = part.isDef !== true && !projected ? part : inheritedLocalUsage;
       const localPath = part.isDef !== true && !projected ? [] : inheritedLocalPath;
-      const editMeta = ivEditMeta(part, instanceId, typeDef, localUsage, localPath, uri);
+      const ports = this.portsOf(part, index2, uri, instanceId, localUsage).ports;
+      const syncDeclaration = this.synchronizationDeclarationOf(part, index2);
+      const editMeta = {
+        ...ivEditMeta(part, instanceId, typeDef, localUsage, localPath, uri),
+        ...syncDeclaration && syncDeclaration !== part ? {
+          syncDeclarationId: qnameOf(syncDeclaration),
+          syncDeclarationName: effectiveNameOf(syncDeclaration),
+          syncDeclarationSource: sourceOf2(syncDeclaration, uri)
+        } : {}
+      };
       const children2 = depth < 8 && !(typeQ !== void 0 && seenTypes.has(typeQ)) ? childUsagesOf(part) : [];
       const concretePerformPath = (statement, target) => {
         if (!this.isAnonymousBehaviorReference(statement)) {
@@ -164286,16 +164525,31 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       }).filter((entry, i, list) => list.findIndex((other) => other.key === entry.key) === i) : [];
       const performedActionInfos = performedActions.map(({ act, pinSource, pathSegments, name, key }) => {
         const id2 = `${instanceId}::__perform_${key}`;
+        const inheritedFromDefinition = !!localUsage && !isAstDescendantOrSelf(act, localUsage);
+        const syncDeclaration2 = this.synchronizationDeclarationOf(act, index2);
         return {
           act,
           name,
           id: id2,
           pathSegments,
-          pins: this.actionPinPorts(pinSource, id2, index2, uri)
+          pins: this.actionPinPorts(pinSource, id2, index2, uri),
+          meta: {
+            ...ivEditMeta(act, id2, void 0, localUsage, [...localPath, name], uri),
+            ivAction: true,
+            // A performed action projected from a typed part belongs
+            // to the shared definition. Local IV edits cannot safely
+            // materialize an action redefinition yet.
+            ivInheritedAction: inheritedFromDefinition,
+            ...syncDeclaration2 && syncDeclaration2 !== act ? {
+              syncDeclarationId: qnameOf(syncDeclaration2),
+              syncDeclarationName: effectiveNameOf(syncDeclaration2),
+              syncDeclarationSource: sourceOf2(syncDeclaration2, uri)
+            } : {}
+          }
         };
       });
       const emitOwnedActions = (frameOf) => {
-        for (const { act, name, id: actId, pins } of performedActionInfos) {
+        for (const { act, name, id: actId, pins, meta } of performedActionInfos) {
           nodes.push({
             id: actId,
             name,
@@ -164307,7 +164561,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
             ports: pins,
             frame: frameOf,
             source: sourceOf2(act, uri),
-            meta: { ivAction: true }
+            meta
           });
         }
       };
@@ -164334,7 +164588,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         }
         emitOwnedActions(instanceId);
         const resolver = childResolver(childInfos, { usage: part, id: instanceId }, performedActionInfos);
-        this.emitInterconnectEdges(effectiveMembersOf(part), resolver.resolve, children2, index2, uri, nodes, edges, eRef, instanceId, resolver.actionPinIds);
+        this.emitInterconnectEdges(effectiveMembersOf(part), resolver.resolve, children2, index2, uri, nodes, edges, eRef, instanceId, resolver.actionPinIds, part);
       } else {
         nodes.push({
           id: instanceId,
@@ -164350,12 +164604,37 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           source: sourceOf2(part, uri),
           meta: editMeta
         });
+        const resolver = childResolver([], { usage: part, id: instanceId });
+        this.emitInterconnectEdges(effectiveMembersOf(part), resolver.resolve, [], index2, uri, nodes, edges, eRef, instanceId, resolver.actionPinIds, part);
       }
     };
     const packageOfRoot = (root4) => enclosingPackage(root4) ?? scope;
+    const rootBaseId = (root4) => qnameOf(root4) || nameOf2(root4) || `__root_${root4.$cstNode?.offset ?? 0}__`;
+    const rootsByBaseId = /* @__PURE__ */ new Map();
+    for (const root4 of roots) {
+      const base = rootBaseId(root4);
+      rootsByBaseId.set(base, [...rootsByBaseId.get(base) ?? [], root4]);
+    }
+    const rootOccurrenceIds = /* @__PURE__ */ new Map();
+    for (const [base, sameNameRoots] of rootsByBaseId) {
+      if (sameNameRoots.length === 1) {
+        rootOccurrenceIds.set(sameNameRoots[0], base);
+        continue;
+      }
+      const discriminatorCounts = /* @__PURE__ */ new Map();
+      const inSourceOrder = [...sameNameRoots].sort((a2, b) => (a2.$cstNode?.offset ?? 0) - (b.$cstNode?.offset ?? 0));
+      for (const root4 of inSourceOrder) {
+        const semanticIdentity = [typeText(root4), ...featureInheritanceTargets(root4)].filter((part) => !!part).join("_") || root4.$type;
+        const discriminator = semanticIdentity.replace(/[^A-Za-z0-9_]+/gu, "_").replace(/^_+|_+$/gu, "") || "part";
+        const occurrence = discriminatorCounts.get(discriminator) ?? 0;
+        discriminatorCounts.set(discriminator, occurrence + 1);
+        const suffix = occurrence === 0 ? discriminator : `${discriminator}_${occurrence + 1}`;
+        rootOccurrenceIds.set(root4, `${base}::__occurrence_${suffix}`);
+      }
+    }
     const rootInfos = [];
     for (const root4 of roots) {
-      const id2 = qnameOf(root4) || nameOf2(root4) || `__root_${nodes.length + frames.length}__`;
+      const id2 = rootOccurrenceIds.get(root4) ?? rootBaseId(root4);
       renderInstance(root4, id2, opts.packageFrames ? ensurePkgFrame(enclosingPackage(root4)) : void 0, /* @__PURE__ */ new Set(), 0, root4.isDef === true ? void 0 : root4, []);
       rootInfos.push({ usage: root4, id: id2, pkg: packageOfRoot(root4) });
     }
@@ -164364,7 +164643,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         const localInfos = rootInfos.filter((r) => r.pkg === pkg && r.usage.isDef !== true);
         const localRoots = localInfos.map((r) => r.usage);
         const resolver = childResolver(localInfos);
-        this.emitInterconnectEdges(membersOf(pkg), resolver.resolve, localRoots, index2, uri, nodes, edges, eRef, void 0, resolver.actionPinIds);
+        this.emitInterconnectEdges(membersOf(pkg), resolver.resolve, localRoots, index2, uri, nodes, edges, eRef, void 0, resolver.actionPinIds, pkg);
       }
     }
     return { nodes, edges, frames };
@@ -164397,8 +164676,23 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // single Interconnection View (called once over the anchor's whole subtree)
   // and the package overview (called once per container part, tagging any
   // synthetic n-ary dot with that container's frame id).
-  emitInterconnectEdges(members, resolveEnd, parts, index2, uri, nodes, edges, eRef, frameId, actionPinIds = /* @__PURE__ */ new Set()) {
+  emitInterconnectEdges(members, resolveEnd, parts, index2, uri, nodes, edges, eRef, frameId, actionPinIds = /* @__PURE__ */ new Set(), memberOwner) {
     const memberList2 = [...members];
+    const relationshipFields = (source) => {
+      let directMember = source;
+      while (directMember.$container && directMember.$container !== memberOwner) {
+        directMember = directMember.$container;
+      }
+      const inherited = !!memberOwner && directMember.$container !== memberOwner;
+      const meta = {
+        ...inherited ? { ivInheritedRelation: true } : {},
+        ...frameId ? { ivRelationshipOwnerId: frameId } : {}
+      };
+      return {
+        source: sourceOf2(source, uri),
+        ...Object.keys(meta).length > 0 ? { meta } : {}
+      };
+    };
     const supportsEndpoints = (kind, ids) => {
       const pinCount = ids.filter((id2) => actionPinIds.has(id2)).length;
       if (pinCount === 0)
@@ -164424,7 +164718,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           label,
           endLabelFrom: multText(resolvedEnds[0].end),
           endLabelTo: multText(resolvedEnds[1].end),
-          source: sourceOf2(src, uri)
+          ...relationshipFields(src)
         });
         return;
       }
@@ -164441,7 +164735,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           isDef: false,
           label,
           endLabelTo: multText(end),
-          source: sourceOf2(src, uri)
+          ...relationshipFields(src)
         });
       }
     };
@@ -164486,7 +164780,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
                 to: endId,
                 kind: "connect",
                 endLabelTo: multText(end),
-                source: sourceOf2(m, uri)
+                ...relationshipFields(m)
               });
             }
           }
@@ -164506,7 +164800,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
               // REQ-179 — connector end multiplicities (`connect [1] a to [0..*] b;`)
               endLabelFrom: multText(srcEnd),
               endLabelTo: multText(tgtEnd),
-              source: sourceOf2(m, uri)
+              ...relationshipFields(m)
             });
           }
         }
@@ -164524,7 +164818,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
             to,
             kind: "flow",
             label: this.flowPayloadText(fm) ?? typeText(m) ?? nameOf2(m),
-            source: sourceOf2(m, uri)
+            ...relationshipFields(m)
           });
         }
       } else if (m.$type === "BindStmt" || m.$type === "BindingConnectorStmt" || m.$type === "BindingDecl") {
@@ -164547,29 +164841,63 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
             // of its own (issue #120 review).
             endLabelFrom: multText(leftEnd) ?? multText(bn),
             endLabelTo: multText(rightEnd),
-            source: sourceOf2(m, uri)
+            ...relationshipFields(m)
           });
         }
       } else if (isInterfaceDecl(m) && m.isDef !== true) {
         const clause = m.connect;
         if (clause) {
-          const from = resolveEnd(this.connectorEndPath(clause.source) ?? "");
-          const to = resolveEnd(this.connectorEndPath(clause.target) ?? "");
-          if (from && to && supportsEndpoints("interface", [from, to])) {
-            const name = nameOf2(m);
-            const type = typeText(m);
-            const label = ["\xABinterface\xBB", nameOf2(m) ?? "", typeText(m) ? `: ${typeText(m)}` : ""].filter(Boolean).join(" ").trim();
+          const rawEnds = clause.ends?.length ? clause.ends : [clause.source, clause.target];
+          const resolvedEnds = rawEnds.map((end) => ({ id: resolveEnd(this.connectorEndPath(end) ?? ""), end })).filter((x) => !!x.id);
+          const name = nameOf2(m);
+          const type = typeText(m);
+          const label = ["\xABinterface\xBB", nameOf2(m) ?? "", typeText(m) ? `: ${typeText(m)}` : ""].filter(Boolean).join(" ").trim();
+          const docks = resolvedEnds.length === rawEnds.length && supportsEndpoints("interface", resolvedEnds.map(({ id: id2 }) => id2));
+          if (docks && resolvedEnds.length === 2) {
             edges.push({
               id: `e${eRef.n++}`,
-              from,
-              to,
+              from: resolvedEnds[0].id,
+              to: resolvedEnds[1].id,
               kind: "interface",
               name,
               type,
               isDef: false,
               label,
-              endLabelFrom: multText(clause.source),
-              endLabelTo: multText(clause.target),
+              endLabelFrom: multText(resolvedEnds[0].end),
+              endLabelTo: multText(resolvedEnds[1].end),
+              ...relationshipFields(m)
+            });
+          } else if (docks && resolvedEnds.length > 2) {
+            const dotId = `__nary_${eRef.n}__`;
+            nodes.push(dot(dotId, label, m));
+            for (const { id: endId, end } of resolvedEnds) {
+              edges.push({
+                id: `e${eRef.n++}`,
+                from: dotId,
+                to: endId,
+                kind: "interface",
+                name,
+                type,
+                isDef: false,
+                label,
+                endLabelTo: multText(end),
+                ...relationshipFields(m)
+              });
+            }
+          } else if (resolvedEnds.length < rawEnds.length) {
+            nodes.push({
+              id: `__interface_${eRef.n++}__`,
+              // The box carries its type in its own `type` field, so
+              // naming an anonymous usage after that type would read
+              // as `FuelInterface : FuelInterface`.
+              name: nameOf2(m) ?? ANONYMOUS_INTERFACE_NAME,
+              keyword: "interface",
+              isDef: false,
+              shape: "box",
+              type: typeText(m),
+              multiplicity: multText(m),
+              frame: frameId,
+              compartments: this.interfaceFallbackCompartments(m, uri, index2),
               source: sourceOf2(m, uri)
             });
           }
@@ -164597,7 +164925,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
                 isDef: false,
                 label,
                 endLabelTo: multText(end),
-                source: sourceOf2(m, uri)
+                ...relationshipFields(m)
               });
             }
           }
@@ -164616,7 +164944,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
               label,
               endLabelFrom: multText(clause.source),
               endLabelTo: multText(clause.target),
-              source: sourceOf2(m, uri)
+              ...relationshipFields(m)
             });
           }
         }
@@ -164637,7 +164965,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const all = [...ast_utils_exports.streamAllContents(scope)];
     const isUsagePart = (n2) => isPartDecl(n2) && n2.isDef !== true && nameOf2(n2) !== void 0;
     const isDefPart = (n2) => isPartDecl(n2) && n2.isDef === true && nameOf2(n2) !== void 0;
-    const hasInternalParts = (d) => [d, ...this.inheritedTypesOf(d, index2)].some((source) => this.nestedUsages(source, isPartDecl).length > 0);
+    const hasInternalParts = (d) => [d, ...this.inheritedFeatureOwnersOf(d, index2)].some((source) => this.nestedUsages(source, isPartDecl).length > 0);
     const insideAPart = (n2) => {
       let c = n2.$container;
       while (c && c !== scope) {
@@ -168354,7 +168682,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   }
   // REQ-175, REQ-193 — collect a node's ports (own + inherited from its type
   // def) as stubs, plus a "usageName.portName" → portId resolution map.
-  portsOf(node, index2, uri, ownerId) {
+  portsOf(node, index2, uri, ownerId, localUsage) {
     const ports = [];
     const map3 = /* @__PURE__ */ new Map();
     const visibleNames = /* @__PURE__ */ new Set();
@@ -168366,23 +168694,50 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const portId = parentPortId ? `${parentPortId}.${pn}` : `${ownerId}.${pn}`;
       const rel2 = parentPath ? `${parentPath}.${pn}` : pn;
       let direction = directionOf(portNode);
-      const portTypeDef = this.resolveType(portNode, index2);
+      const inheritedOwners = this.inheritedFeatureOwnersOf(portNode, index2);
+      const directPortTypeDef = this.resolveType(portNode, index2);
+      const inheritedPortUsages = inheritedOwners.filter((owner) => isPortDecl(owner) && owner.isDef !== true);
+      const inheritedTyping = inheritedPortUsages.map((owner) => ({ owner, type: this.resolveType(owner, index2) })).find((entry) => entry.type !== void 0);
+      const portTypeDef = directPortTypeDef ?? inheritedTyping?.type ?? inheritedOwners.find((owner) => isPortDecl(owner) && owner.isDef === true);
+      const inheritedDirection = inheritedPortUsages.map(directionOf).find((candidate) => candidate !== void 0);
+      direction ??= inheritedDirection;
+      const referenceTraitOf = (candidate) => {
+        const modifiers2 = candidate.modifiers ?? [];
+        if (modifiers2.includes("ref"))
+          return true;
+        if (modifiers2.includes("composite"))
+          return false;
+        return void 0;
+      };
+      const inheritedReference = inheritedPortUsages.map(referenceTraitOf).find((candidate) => candidate !== void 0);
+      const reference = referenceTraitOf(portNode) ?? inheritedReference;
+      const hasDirectTyping = portNode.typing !== void 0;
+      const effectiveConjugated = hasDirectTyping ? isConjugated(portNode) : inheritedTyping ? isConjugated(inheritedTyping.owner) : false;
       if (!direction) {
         const conjugated = isConjugated(portNode);
-        const dirs = /* @__PURE__ */ new Set([
-          ...this.ownDirectedFeatureDirections(portNode, conjugated),
-          ...portTypeDef ? this.effectivePortDirections(portTypeDef, index2, conjugated) : []
-        ]);
+        const dirs = this.ownDirectedFeatureDirections(portNode, conjugated);
+        for (const inheritedUsage of inheritedPortUsages) {
+          const inheritedConjugated = conjugated !== isConjugated(inheritedUsage);
+          for (const inheritedDirection2 of this.ownDirectedFeatureDirections(inheritedUsage, inheritedConjugated)) {
+            dirs.add(inheritedDirection2);
+          }
+        }
+        const typeConjugated = directPortTypeDef ? conjugated : inheritedTyping ? conjugated !== isConjugated(inheritedTyping.owner) : conjugated;
+        if (portTypeDef) {
+          for (const inheritedDirection2 of this.effectivePortDirections(portTypeDef, index2, typeConjugated)) {
+            dirs.add(inheritedDirection2);
+          }
+        }
         direction = dirs.size === 1 ? [...dirs][0] : dirs.size > 1 ? "inout" : void 0;
       }
       const port = {
         id: portId,
         name: pn,
-        type: typeText(portNode),
+        type: typeText(portNode) ?? (inheritedTyping ? typeText(inheritedTyping.owner) : void 0),
         direction,
-        conjugated: isConjugated(portNode) || void 0,
+        conjugated: effectiveConjugated || void 0,
         // REQ-194 — reference ports render with a dashed outline
-        ref: (portNode.modifiers ?? []).includes("ref") || void 0,
+        ref: reference || void 0,
         isDef: portNode.isDef === true,
         // issue #108 — a nested port carries its parent's id so the webview
         // stacks it on the parent glyph and docks connectors on it.
@@ -168397,18 +168752,27 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         // projection origin to choose a direct edit or a usage-local
         // `port :>> name { ... }` materialization.
         meta: {
-          declarationId: qnameOf(portNode) || portId,
+          declarationId: nameOf2(portNode) ? qnameOf(portNode) || portId : portId,
           declarationName: pn,
           inheritedFromType,
+          localDeclaration: !inheritedFromType && !!nameOf2(portNode) && !!localUsage && isAstDescendantOrSelf(portNode, localUsage),
           definitionId: portTypeDef ? qnameOf(portTypeDef) : void 0,
           definitionName: portTypeDef ? nameOf2(portTypeDef) : void 0,
-          definitionSource: portTypeDef ? sourceOf2(portTypeDef, uri) : void 0
+          definitionSource: portTypeDef ? sourceOf2(portTypeDef, uri) : void 0,
+          ...(() => {
+            const syncDeclaration = this.synchronizationDeclarationOf(portNode, index2);
+            return syncDeclaration && syncDeclaration !== portNode ? {
+              syncDeclarationId: qnameOf(syncDeclaration),
+              syncDeclarationName: effectiveNameOf(syncDeclaration),
+              syncDeclarationSource: sourceOf2(syncDeclaration, uri)
+            } : {};
+          })()
         }
       };
       if (usageName)
         map3.set(`${usageName}.${rel2}`, portId);
       map3.set(`${ownerId}.${rel2}`, portId);
-      return { port, portTypeDef };
+      return { port, portTypeDef, inheritedOwners };
     };
     const addNested = (portNode, made, inheritedFromType, path10, depth, seenTypes) => {
       if (depth > NESTED_PORT_MAX_DEPTH)
@@ -168420,8 +168784,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const nestedSources = [
         // declared in this port usage's body: as local as its parent is
         ...membersOf(portNode).map((member) => ({ member, inherited: inheritedFromType })),
-        // declared in the port's type: always a projection of that type
-        ...made.portTypeDef && !repeatedType ? membersOf(made.portTypeDef).map((member) => ({ member, inherited: true })) : []
+        // every effective owner contributes its body, nearest first
+        ...!repeatedType ? made.inheritedOwners.flatMap((owner) => membersOf(owner).map((member) => ({ member, inherited: true }))) : []
       ];
       for (const { member, inherited } of nestedSources) {
         if (!isPortDecl(member) || member.isDef === true)
@@ -168451,7 +168815,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     for (const m of membersOf(node))
       if (isPortDecl(m) && m.isDef !== true)
         addPort(m, false);
-    for (const inherited of this.inheritedTypesOf(node, index2)) {
+    for (const inherited of this.inheritedFeatureOwnersOf(node, index2)) {
       for (const m of membersOf(inherited))
         if (isPortDecl(m) && m.isDef !== true)
           addPort(m, true);
@@ -168554,20 +168918,20 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   inheritedItems(node, index2, uri) {
     if (node.isDef === true)
       return [];
-    const def = this.resolveType(node, index2);
-    if (!def)
-      return [];
-    const localRedefined = /* @__PURE__ */ new Set();
-    for (const m of membersOf(node)) {
-      for (const rel2 of [...m.preRelationships ?? [], ...m.relationships ?? []]) {
-        if (rel2.kind === ":>>" || rel2.kind === "redefines") {
-          for (const t of rel2.targets ?? [])
-            localRedefined.add(lastSeg(t));
-        }
+    const hiddenNames = new Set(membersOf(node).map(effectiveNameOf).filter((name) => name !== void 0));
+    const inherited = [];
+    for (const owner of this.inheritedFeatureOwnersOf(node, index2)) {
+      for (const member of membersOf(owner)) {
+        const name = effectiveNameOf(member);
+        if (!name || hiddenNames.has(name))
+          continue;
+        hiddenNames.add(name);
+        if (!isAttributeDecl(member) || member.isDef === true)
+          continue;
+        inherited.push({ member, source: sourceOf2(member, uri) });
       }
     }
-    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((member) => ({ member, source: sourceOf2(member, uri) }));
+    return inherited;
   }
   compartmentsFor(node, uri, index2, featureRows = false, includeInherited = true) {
     const members = membersOf(node);
@@ -168612,6 +168976,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     } else if (subjectMandatory) {
       add("subject", [{ text: "\u26A0 none declared" }]);
     }
+    add("ends", members.filter(isEndMember).map((m) => item(m, endRowText(m) ?? statementText(m))));
     add("attributes", [
       ...usages(isAttributeDecl).map((a2) => item(a2)),
       ...inheritedRows((member) => isAttributeDecl(member) && isOrdinaryMember(member))
@@ -168621,6 +168986,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       add("ports", usages(isPortDecl).map((m) => item(m)));
       add("parts", usages(isPartDecl).filter(notPortion).map((m) => item(m)));
     }
+    add("interfaces", members.filter((m) => isInterfaceDecl(m) && m.isDef !== true && isOrdinaryMember(m)).map((m) => item(m, this.interfaceRowText(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)));
@@ -168716,6 +169082,44 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     add("satisfies", members.filter((m) => m.$type === "SatisfyStmt").map((m) => item(m, String(m.target ?? ""))));
     return out.length ? out : void 0;
   }
+  // REQ-195 — Interface and binding guidance (`interfaces` row text)
+  // issue #110 — the textual row (and node label) of an interface usage:
+  // `name : Type connect a.p to b.q`. The connect ends are kept because this
+  // row is the depiction a reader falls back to when the edge is not drawn, and
+  // without them an anonymous typed usage would read as its type alone. The two
+  // keyword-less shorthands (`interface a.p to b.q;` and an n-ary
+  // `connect (a, b, c)`) are spelled the same way.
+  interfaceRowText(node) {
+    const n2 = node;
+    const type = typeText(node);
+    const mult = multText(node);
+    const name = nameOf2(node) ?? ANONYMOUS_INTERFACE_NAME;
+    const head2 = `${name}${type ? ` : ${type}` : ""}${mult ? ` ${mult}` : ""}`;
+    const clause = n2.connect;
+    const ends = clause?.ends?.length ? `connect (${clause.ends.map((end) => this.connectorEndPath(end) ?? "?").join(", ")})` : clause ? `connect ${this.connectorEndPath(clause.source) ?? "?"} to ${this.connectorEndPath(clause.target) ?? "?"}` : n2.target !== void 0 ? `${[nameOf2(node) ?? "", ...n2.srcSegs ?? []].filter(Boolean).join(".")} to ${this.featurePath(n2.target) ?? "?"}` : void 0;
+    if (ends && !clause)
+      return ends;
+    return [head2, ends].filter(Boolean).join(" ");
+  }
+  // REQ-195 — Interface and binding guidance (usage-node fallback body)
+  // issue #110 — the body of the `«interface»` usage node the IV draws when the
+  // connect ends do not dock on the canvas. The written end paths ARE the
+  // information the missing edge would have carried, so they read as the node's
+  // `ends` compartment (OMG SysML 8.2.3.14), after any end members it declares.
+  interfaceFallbackCompartments(node, uri, index2) {
+    const clause = node.connect;
+    const paths = clause?.ends?.length ? clause.ends.map((end) => this.connectorEndPath(end) ?? "?") : clause ? [this.connectorEndPath(clause.source) ?? "?", this.connectorEndPath(clause.target) ?? "?"] : [];
+    const compartments = [...this.compartmentsFor(node, uri, index2) ?? []];
+    if (!paths.length)
+      return compartments.length ? compartments : void 0;
+    const items = paths.map((text) => ({ text }));
+    const existing = compartments.find((compartment) => compartment.title === "ends");
+    if (existing)
+      existing.items = [...existing.items, ...items];
+    else
+      compartments.push({ title: "ends", items });
+    return compartments;
+  }
   refText(v) {
     if (typeof v === "string")
       return v;
@@ -182204,7 +182608,8 @@ function portGlyphRect(g, w, h, topReserve = 0) {
     y: cy - height / 2,
     width,
     height,
-    elongated: across > natural
+    elongated: across > natural,
+    proxy: g.port.meta?.proxy === true
   };
 }
 function hostMarkAcrossShift(rect) {
@@ -182212,7 +182617,7 @@ function hostMarkAcrossShift(rect) {
   return -(rect.across / 2 - NESTED_PORT_HOST_CLEAR / 2);
 }
 function portDockAlongShift(rect) {
-  if (!rect.elongated) return 0;
+  if (!rect.elongated || rect.proxy) return 0;
   return rect.along / 2 - NESTED_PORT_END_PAD / 2;
 }
 function portDockAt(rect, side, dockSide) {
@@ -182906,8 +183311,8 @@ function collapseNestedPorts(model, expanded2) {
   }).filter((e) => {
     if (e.from === e.to) return false;
     const key = `${e.from}\0${e.to}\0${e.kind}\0${e.label ?? ""}`;
-    if (seenEdge.has(key)) return false;
-    seenEdge.add(key);
+    if (seenEdge.has(`${key}:${e.id}`)) return false;
+    seenEdge.add(`${key}:${e.id}`);
     return true;
   });
   return {
@@ -182956,11 +183361,17 @@ function assignPortHandles(ports, overrides, ownerShape) {
         label + reserved
       ),
       across: portGlyphAcross(kidMetrics.map((k) => k.across))
+    } : isProxyPort(port) ? {
+      along: Math.max(
+        natural,
+        tw(`${port.conjugated ? "~" : ""}${port.name}`, 9) + 2 * NESTED_PORT_END_PAD + (port.direction ? NESTED_PORT_CHEVRON_RUN : 0)
+      ),
+      across: portGlyphAcross()
     } : { along: natural + reserved, across: natural };
     metrics.set(port.id, m);
     return m;
   };
-  const alongOf = (port) => hasToggle(port) ? metricsOf(port).along : void 0;
+  const alongOf = (port) => hasToggle(port) || isProxyPort(port) ? metricsOf(port).along : void 0;
   const place = (list, side) => {
     const n2 = list.length;
     const alongs = list.map(alongOf);
@@ -183219,6 +183630,50 @@ function applyBehaviorFilters(model, filters) {
   const edges = model.edges.filter((e) => !(model.kind === "afv" && !filters.definedBy && e.kind === "definedBy") && !hiddenPortIds.has(e.from) && !hiddenPortIds.has(e.to) && liveIds.has(e.from) && liveIds.has(e.to));
   return { ...model, frames: nextFrames, nodes: withoutOrphanedAnnotations(model, nodes, edges), edges };
 }
+function isProxyPort(port) {
+  return port.meta?.proxy === true;
+}
+var PROXY_LAYOUT_PREFIX = "proxy:";
+function proxyPortFor(port, path10, hostId) {
+  const stand = {
+    ...port,
+    name: path10,
+    layoutKey: `${PROXY_LAYOUT_PREFIX}${hostId}:${port.layoutKey ?? port.id}`,
+    meta: { ...port.meta, proxy: true, proxyFor: port.id, proxyPath: path10, proxyName: port.name }
+  };
+  delete stand.parentPort;
+  return stand;
+}
+function proxyPathOf(port, ownerId, hostId, containerLabel, containerOf, portById) {
+  const segments = [port.name];
+  const seenPorts = /* @__PURE__ */ new Set([port.id]);
+  for (let cur = port.parentPort; cur !== void 0 && !seenPorts.has(cur); cur = portById.get(cur)?.parentPort) {
+    seenPorts.add(cur);
+    const parent = portById.get(cur);
+    if (!parent) break;
+    segments.unshift(parent.name);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let cur = ownerId; cur !== void 0 && cur !== hostId && !seen.has(cur); cur = containerOf(cur)) {
+    seen.add(cur);
+    const label = containerLabel(cur);
+    if (label) segments.unshift(label);
+  }
+  return segments.join(".");
+}
+function proxyPortsByHost(referenced, hostOf, ownerOf, containerLabel, containerOf, portById) {
+  const byHost = /* @__PURE__ */ new Map();
+  for (const portId of referenced) {
+    const host = hostOf.get(portId);
+    const entry = ownerOf.get(portId);
+    if (host === void 0 || entry === void 0) continue;
+    const path10 = proxyPathOf(entry.port, entry.owner, host, containerLabel, containerOf, portById);
+    const list = byHost.get(host);
+    if (list) list.push(proxyPortFor(entry.port, path10, host));
+    else byHost.set(host, [proxyPortFor(entry.port, path10, host)]);
+  }
+  return byHost;
+}
 function collapseIvModel(model, hiddenInternals) {
   const frames = model.frames ?? [];
   if (!frames.length) return model;
@@ -183248,12 +183703,72 @@ function collapseIvModel(model, hiddenInternals) {
   };
   const hiddenFrameIds = new Set(frames.filter((f) => belongsToCollapsedRoot(f.id, false)).map((f) => f.id));
   const hiddenNodeIds = new Set(model.nodes.filter((n2) => belongsToCollapsedRoot(n2.frame ?? n2.parent, true)).map((n2) => n2.id));
-  const hiddenEndpoints = /* @__PURE__ */ new Set([...hiddenFrameIds, ...hiddenNodeIds]);
-  for (const f of frames) if (hiddenFrameIds.has(f.id)) for (const p of f.ports ?? []) hiddenEndpoints.add(p.id);
-  for (const n2 of model.nodes) if (hiddenNodeIds.has(n2.id)) for (const p of n2.ports ?? []) hiddenEndpoints.add(p.id);
+  const nodeById = new Map(model.nodes.map((n2) => [n2.id, n2]));
+  const containerOf = (id2) => {
+    const frame2 = frameById.get(id2);
+    if (frame2) return frame2.parent;
+    const node = nodeById.get(id2);
+    return node ? node.frame ?? node.parent : void 0;
+  };
+  const containerLabel = (id2) => frameById.get(id2)?.label ?? nodeById.get(id2)?.name;
+  const rootFor = (id2) => {
+    const seen = /* @__PURE__ */ new Set();
+    for (let cur = id2; cur !== void 0 && !seen.has(cur); cur = containerOf(cur)) {
+      if (roots.has(cur)) return cur;
+      seen.add(cur);
+    }
+    return void 0;
+  };
+  const ownerOfHiddenPort = /* @__PURE__ */ new Map();
+  for (const f of frames) if (hiddenFrameIds.has(f.id)) for (const p of f.ports ?? []) ownerOfHiddenPort.set(p.id, { port: p, owner: f.id });
+  for (const n2 of model.nodes) if (hiddenNodeIds.has(n2.id)) for (const p of n2.ports ?? []) ownerOfHiddenPort.set(p.id, { port: p, owner: n2.id });
+  const hiddenPortById = new Map([...ownerOfHiddenPort].map(([id2, entry]) => [id2, entry.port]));
+  const proxyHost = /* @__PURE__ */ new Map();
+  for (const [portId, entry] of ownerOfHiddenPort) {
+    const root4 = rootFor(entry.owner);
+    if (root4 !== void 0) proxyHost.set(portId, root4);
+  }
+  const bodyDock = /* @__PURE__ */ new Map();
+  for (const id2 of [...hiddenFrameIds, ...hiddenNodeIds]) {
+    const root4 = rootFor(id2);
+    if (root4 !== void 0) bodyDock.set(id2, root4);
+  }
+  const hidden = /* @__PURE__ */ new Set([...hiddenFrameIds, ...hiddenNodeIds, ...ownerOfHiddenPort.keys()]);
+  const containerRootOf = (id2) => proxyHost.get(id2) ?? bodyDock.get(id2);
+  const seenEdge = /* @__PURE__ */ new Set();
+  const edges = model.edges.filter((e) => {
+    const fromRoot = containerRootOf(e.from);
+    const toRoot = containerRootOf(e.to);
+    if (fromRoot !== void 0 && fromRoot === toRoot) return false;
+    return !(hidden.has(e.from) && fromRoot === void 0) && !(hidden.has(e.to) && toRoot === void 0);
+  }).map((e) => {
+    const from = bodyDock.get(e.from) ?? e.from;
+    const to = bodyDock.get(e.to) ?? e.to;
+    return from === e.from && to === e.to ? e : { ...e, from, to };
+  }).filter((e) => {
+    if (e.from === e.to) return false;
+    const key = `${e.from}\0${e.to}\0${e.kind}\0${e.label ?? ""}`;
+    if (seenEdge.has(`${key}:${e.id}`)) return false;
+    seenEdge.add(`${key}:${e.id}`);
+    return true;
+  });
+  const referenced = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (proxyHost.has(e.from)) referenced.add(e.from);
+    if (proxyHost.has(e.to)) referenced.add(e.to);
+  }
+  const proxies = proxyPortsByHost(
+    referenced,
+    proxyHost,
+    ownerOfHiddenPort,
+    containerLabel,
+    containerOf,
+    hiddenPortById
+  );
   const collapsedNodes = [...roots].flatMap((id2) => {
     const f = frameById.get(id2);
     if (!f) return [];
+    const stand = proxies.get(id2) ?? [];
     return [{
       id: f.id,
       layoutKey: f.layoutKey,
@@ -183263,7 +183778,7 @@ function collapseIvModel(model, hiddenInternals) {
       shape: "box",
       type: f.type,
       multiplicity: f.multiplicity,
-      ports: f.ports,
+      ports: stand.length ? [...f.ports ?? [], ...stand] : f.ports,
       compartments: f.compartments,
       frame: f.parent,
       source: f.source,
@@ -183274,7 +183789,7 @@ function collapseIvModel(model, hiddenInternals) {
     ...model,
     nodes: [...model.nodes.filter((n2) => !hiddenNodeIds.has(n2.id)), ...collapsedNodes],
     frames: frames.filter((f) => !roots.has(f.id) && !hiddenFrameIds.has(f.id)),
-    edges: model.edges.filter((e) => !hiddenEndpoints.has(e.from) && !hiddenEndpoints.has(e.to))
+    edges
   };
 }
 function isCollapsibleActionFrame(frame2) {
@@ -183356,13 +183871,18 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
   };
   const roots = new Set([...requested].filter((id2) => rootOf(frameById.get(id2)?.parent) === void 0));
   const dockOf = /* @__PURE__ */ new Map();
+  const proxyHost = /* @__PURE__ */ new Map();
+  const ownerOfHiddenPort = /* @__PURE__ */ new Map();
   const hiddenFrameIds = /* @__PURE__ */ new Set();
   for (const f of frames) {
     const root4 = roots.has(f.id) ? rootOf(f.parent) : rootOf(f.id);
     if (root4 === void 0) continue;
     hiddenFrameIds.add(f.id);
     dockOf.set(f.id, root4);
-    for (const p of f.ports ?? []) dockOf.set(p.id, root4);
+    for (const p of f.ports ?? []) {
+      proxyHost.set(p.id, root4);
+      ownerOfHiddenPort.set(p.id, { port: p, owner: f.id });
+    }
   }
   const hiddenNodeIds = /* @__PURE__ */ new Set();
   for (const n2 of model.nodes) {
@@ -183370,15 +183890,59 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
     if (root4 === void 0) continue;
     hiddenNodeIds.add(n2.id);
     dockOf.set(n2.id, root4);
-    for (const p of n2.ports ?? []) dockOf.set(p.id, root4);
+    for (const p of n2.ports ?? []) {
+      proxyHost.set(p.id, root4);
+      ownerOfHiddenPort.set(p.id, { port: p, owner: n2.id });
+    }
   }
   for (const id2 of roots) {
     dockOf.delete(id2);
-    for (const p of frameById.get(id2)?.ports ?? []) dockOf.delete(p.id);
+    for (const p of frameById.get(id2)?.ports ?? []) {
+      proxyHost.delete(p.id);
+      ownerOfHiddenPort.delete(p.id);
+    }
   }
+  const nodeById = new Map(model.nodes.map((n2) => [n2.id, n2]));
+  const containerOf = (id2) => {
+    const frame2 = frameById.get(id2);
+    if (frame2) return frame2.parent;
+    return nodeById.get(id2)?.frame;
+  };
+  const containerLabel = (id2) => frameById.get(id2)?.label ?? nodeById.get(id2)?.name;
+  const hiddenPortById = new Map([...ownerOfHiddenPort].map(([id2, entry]) => [id2, entry.port]));
+  const containerRootOf = (id2) => proxyHost.get(id2) ?? dockOf.get(id2);
+  const seenEdge = /* @__PURE__ */ new Set();
+  const edges = model.edges.filter((e) => {
+    const fromRoot = containerRootOf(e.from);
+    return fromRoot === void 0 || fromRoot !== containerRootOf(e.to);
+  }).map((e) => {
+    const from = dockOf.get(e.from) ?? e.from;
+    const to = dockOf.get(e.to) ?? e.to;
+    return from === e.from && to === e.to ? e : { ...e, from, to };
+  }).filter((e) => {
+    if (e.from === e.to) return false;
+    const key = `${e.from}\0${e.to}\0${e.kind}\0${e.label ?? ""}`;
+    if (seenEdge.has(`${key}:${e.id}`)) return false;
+    seenEdge.add(`${key}:${e.id}`);
+    return true;
+  });
+  const referenced = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (proxyHost.has(e.from)) referenced.add(e.from);
+    if (proxyHost.has(e.to)) referenced.add(e.to);
+  }
+  const proxies = proxyPortsByHost(
+    referenced,
+    proxyHost,
+    ownerOfHiddenPort,
+    containerLabel,
+    containerOf,
+    hiddenPortById
+  );
   const collapsedNodes = [...roots].flatMap((id2) => {
     const f = frameById.get(id2);
     if (!f) return [];
+    const stand = proxies.get(id2) ?? [];
     return [{
       id: f.id,
       layoutKey: f.layoutKey,
@@ -183388,25 +183952,13 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
       shape: collapsedShape,
       type: f.type,
       multiplicity: f.multiplicity,
-      ports: f.ports,
+      ports: stand.length ? [...f.ports ?? [], ...stand] : f.ports,
       compartments: f.compartments,
       frame: f.parent,
       source: f.source,
       meta: { ...f.meta, internalsHidden: true }
     }];
   });
-  const seenEdge = /* @__PURE__ */ new Set();
-  const edges = model.edges.map((e) => {
-    const from = dockOf.get(e.from) ?? e.from;
-    const to = dockOf.get(e.to) ?? e.to;
-    return from === e.from && to === e.to ? e : { ...e, from, to };
-  }).filter((e) => {
-    if (e.from === e.to) return false;
-    const key = `${e.from} ${e.to} ${e.kind} ${e.label ?? ""}`;
-    if (seenEdge.has(key)) return false;
-    seenEdge.add(key);
-    return true;
-  });
   return {
     ...model,
     nodes: [...model.nodes.filter((n2) => !hiddenNodeIds.has(n2.id)), ...collapsedNodes],
@@ -183564,7 +184116,7 @@ function modelToFlow(model, opts) {
     const base = isGeo ? { w: 24, h: 24 } : nodeSize(canvasNode, opts.direction);
     const sizeOverride = ov[n2.layoutKey ?? n2.id];
     const compactCollapsed = canvasNode.meta?.internalsHidden === true;
-    const presentationOverride = compactCollapsed && sizeOverride ? { ...sizeOverride, h: void 0 } : sizeOverride;
+    const presentationOverride = compactCollapsed && sizeOverride ? { ...sizeOverride, w: void 0, h: void 0 } : sizeOverride;
     const projectedSize = isCircularControlShape(canvasNode.shape) ? base : isForkJoinShape(canvasNode.shape) ? forkJoinSizeWithOverride(presentationOverride, opts.direction) : sizeWithOverride(
       base,
       presentationOverride,
@@ -183573,7 +184125,20 @@ function modelToFlow(model, opts) {
         h: visibleFeatureH > 0 ? base.h : 24
       }
     );
-    const size = model.kind === "gv" && canvasNode.shape !== "package" ? { ...projectedSize, w: Math.min(projectedSize.w, GV_NODE_MAX_WIDTH) } : projectedSize;
+    const compactPortHandles = compactCollapsed ? assignPortHandles(canvasNode.ports, opts.portOverrides, canvasNode.shape) : [];
+    const compactPortWidth = Math.max(
+      portedSideLength(compactPortHandles, "top"),
+      portedSideLength(compactPortHandles, "bottom")
+    );
+    const compactPortHeight = Math.max(
+      portedSideLength(compactPortHandles, "left"),
+      portedSideLength(compactPortHandles, "right")
+    );
+    const size = model.kind === "gv" && canvasNode.shape !== "package" ? { ...projectedSize, w: Math.min(projectedSize.w, GV_NODE_MAX_WIDTH) } : compactCollapsed ? {
+      ...projectedSize,
+      w: Math.max(compactPortWidth, Math.min(projectedSize.w, GV_NODE_MAX_WIDTH)),
+      h: Math.max(compactPortHeight, projectedSize.h)
+    } : projectedSize;
     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,
@@ -197549,6 +198114,12 @@ body {
 
 /* REQ-194 \u2014 port variants: dashed reference ports, direction chevrons */
 .dnode-port.ref { stroke-dasharray: 2 2; }
+/* REQ-400 \u2014 a PROXY stands in for a port inside collapsed contents.
+ * It is drawn hollow with a fine dotted outline, so it reads as a place a
+ * connector docks rather than as an element that is really on the boundary. Its
+ * dot pattern is deliberately finer than the reference port's dash. */
+.dnode-port.proxy { fill: none; stroke-dasharray: 1 2; stroke-width: 1.2; }
+.dnode-port.proxy.selected { fill: var(--accent); fill-opacity: 0.35; }
 /* REQ-376 \u2014 an action pin takes the OUTLINE and explicit fill of the action it sits
  * on rather than the flow colour (user direction 2026-08-09). Its rounded corners and its
  * direction arrow come from the shared port path in nodes.tsx. */
@@ -198534,6 +199105,21 @@ function sizeOf(node) {
     h: node.measured?.height ?? node.height ?? node.data.h
   };
 }
+function exportedNodeColorClass(node) {
+  const frame2 = node.data.frame;
+  if (frame2) {
+    return diagramElementColorClass(diagramElementColorTypeForFrame(frame2.keyword, {
+      boundary: frame2.meta?.boundaryBox === true,
+      exhibitor: frame2.meta?.exhibitBoundary === true,
+      loop: frame2.meta?.loop === true,
+      parallel: frame2.meta?.parallel === true,
+      performer: frame2.meta?.performerLane === true,
+      structured: frame2.meta?.structuredControl === true
+    }));
+  }
+  const semantic = node.data.node;
+  return diagramElementColorClass(semantic ? diagramElementColorTypeForNode(semantic.shape, semantic.keyword) : "default");
+}
 function labelExtent(text) {
   return { w: Math.max(8, text.length * 6.2) / 2, h: 7 };
 }
@@ -198569,7 +199155,7 @@ function buildDiagramSvg(options) {
       extend2(p.x + background.x, p.y + background.y, background.width, background.height);
     }
     const body = nodeMarkup(node);
-    if (body) nodeParts.push(`<g transform="translate(${Math.round(p.x)},${Math.round(p.y)})">${body}</g>`);
+    if (body) nodeParts.push(`<g transform="translate(${Math.round(p.x)},${Math.round(p.y)})" class="${exportedNodeColorClass(node)}">${body}</g>`);
   }
   if (!isFinite(minX)) return null;
   const edgeParts = [];
@@ -198952,6 +199538,7 @@ function normalizeSideCar(value) {
       const next = {};
       if (state.mode !== void 0) next.mode = state.mode;
       if (state.zoom !== void 0) next.zoom = state.zoom;
+      if (state.showGrid !== void 0) next.showGrid = state.showGrid;
       const dir = sanitizeDirection(state.direction);
       if (dir !== void 0) next.direction = dir;
       if (state.hiddenInternals !== void 0) next.hiddenInternals = state.hiddenInternals;
@@ -200373,6 +200960,7 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
       len
     };
   })() : void 0;
+  const proxy = rect.proxy;
   return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
     "g",
     {
@@ -200382,7 +200970,7 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
         e.stopPropagation();
         onSelect(ph.port.id);
       } : void 0,
-      onContextMenu: onContext ? (e) => {
+      onContextMenu: onContext && !proxy ? (e) => {
         e.preventDefault();
         e.stopPropagation();
         onContext(ph.port.id, e.clientX, e.clientY);
@@ -200405,7 +200993,7 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
         /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
           "rect",
           {
-            className: `dnode-port${ph.port.pin ? " pin" : ""}${ph.port.ref ? " ref" : ""}${rect.elongated ? " host" : ""}${selected2 ? " selected" : ""}${hovered ? " hovered" : ""}${moving ? " moving" : ""}${connectTargetSide ? " connect-target" : ""}`,
+            className: `dnode-port${ph.port.pin ? " pin" : ""}${ph.port.ref ? " ref" : ""}${rect.elongated ? " host" : ""}${proxy ? " proxy" : ""}${selected2 ? " selected" : ""}${hovered ? " hovered" : ""}${moving ? " moving" : ""}${connectTargetSide ? " connect-target" : ""}`,
             x: rect.x,
             y: rect.y,
             width: rect.width,
@@ -200418,7 +201006,7 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
           d === "out" || d === "inout" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("path", { className: "dport-dir head", d: arrowHead(1) }) : "",
           d === "in" || d === "inout" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("path", { className: "dport-dir head", d: arrowHead(-1) }) : ""
         ] }) : "",
-        selected2 && connectStart && !connectTargetSide ? (() => {
+        selected2 && connectStart && !connectTargetSide && !proxy ? (() => {
           const px = x + v.x * (half + PORT_PLUS_GAP);
           const py = y + v.y * (half + PORT_PLUS_GAP);
           return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("g", { className: "dport-plus", children: [
@@ -200868,7 +201456,8 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
           node.shape === "initial" || node.shape === "final" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "rf-circular-control-hit", "aria-hidden": "true" }) : null,
           ports.flatMap((ph) => {
             const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
-            const startable = directRelationForHandle(data.kind, {
+            const proxied = isProxyPort(ph.port);
+            const startable = !proxied && directRelationForHandle(data.kind, {
               id: ph.port.id,
               name: ph.port.name,
               keyword: ph.port.pin ? "pin" : "port",
@@ -200889,7 +201478,8 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
                   x: outer.x,
                   y: outer.y,
                   kind: "port",
-                  active: revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === ph.side,
+                  connectable: !proxied,
+                  active: !proxied && (revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === ph.side),
                   startable
                 },
                 `${ph.port.id}-out`
@@ -200902,7 +201492,8 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
                   x: inner.x,
                   y: inner.y,
                   kind: "port",
-                  active: revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === innerSide,
+                  connectable: !proxied,
+                  active: !proxied && (revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === innerSide),
                   startable
                 },
                 `${ph.port.id}-in`
@@ -200912,17 +201503,21 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
           ctx.onPortMove ? ports.map((ph) => {
             const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
             const nestedChild = ph.port.parentPort !== void 0;
+            const proxyPort = isProxyPort(ph.port);
             const strip = portInteractionStrip(rect, ph.side);
             return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
               "div",
               {
                 className: "port-drag-hit nodrag",
                 style: { position: "absolute", left: strip.cx, top: strip.cy, width: strip.w, height: strip.h, transform: "translate(-50%,-50%)" },
-                title: nestedChild ? `${ph.port.name} - click to select; drag a dot to connect (moves with its parent port)` : `${ph.port.name} - drag the centre to move along the edge; drag a dot to connect; click to select`,
+                title: proxyPort ? `${ph.port.name} - a proxy for a port inside the collapsed contents; drag the centre to move it, click to select the port it stands for` : nestedChild ? `${ph.port.name} - click to select; drag a dot to connect (moves with its parent port)` : `${ph.port.name} - drag the centre to move along the edge; drag a dot to connect; click to select`,
                 onPointerEnter: () => setHoveredPortId(ph.port.id),
                 onPointerLeave: () => setHoveredPortId((cur) => cur === ph.port.id ? void 0 : cur),
                 onPointerDown: (e) => onPortPointerDown(ph.port.id, e, { side: ph.side, offset: ph.offset }, !nestedChild),
-                onContextMenu: (e) => {
+                onContextMenu: proxyPort ? (e) => {
+                  e.preventDefault();
+                  e.stopPropagation();
+                } : (e) => {
                   e.preventDefault();
                   e.stopPropagation();
                   ctx.onContextNode(ph.port.id, e.clientX, e.clientY);
@@ -201349,7 +201944,8 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
         }),
         showPorts ? ports.flatMap((ph) => {
           const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
-          const startable = directRelationForHandle(data.kind, {
+          const proxied = isProxyPort(ph.port);
+          const startable = !proxied && directRelationForHandle(data.kind, {
             id: ph.port.id,
             name: ph.port.name,
             keyword: ph.port.pin ? "pin" : "port",
@@ -201370,7 +201966,8 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
                 x: outer.x,
                 y: outer.y,
                 kind: "port",
-                active: revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === ph.side,
+                connectable: !proxied,
+                active: !proxied && (revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === ph.side),
                 startable
               },
               `${ph.port.id}-out`
@@ -201383,7 +201980,8 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
                 x: inner.x,
                 y: inner.y,
                 kind: "port",
-                active: revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === innerSide,
+                connectable: !proxied,
+                active: !proxied && (revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === innerSide),
                 startable
               },
               `${ph.port.id}-in`
@@ -201393,17 +201991,21 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
         ctx.onPortMove ? ports.map((ph) => {
           const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
           const nestedChild = ph.port.parentPort !== void 0;
+          const proxyPort = isProxyPort(ph.port);
           const strip = portInteractionStrip(rect, ph.side);
           return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
             "div",
             {
               className: "port-drag-hit nodrag",
               style: { position: "absolute", left: strip.cx, top: strip.cy, width: strip.w, height: strip.h, transform: "translate(-50%,-50%)" },
-              title: nestedChild ? `${ph.port.name} - click to select; drag a dot to connect (moves with its parent port)` : `${ph.port.name} - drag the centre to move along the edge; drag a dot to connect; click to select`,
+              title: proxyPort ? `${ph.port.name} - a proxy for a port inside the collapsed contents; drag the centre to move it, click to select the port it stands for` : nestedChild ? `${ph.port.name} - click to select; drag a dot to connect (moves with its parent port)` : `${ph.port.name} - drag the centre to move along the edge; drag a dot to connect; click to select`,
               onPointerEnter: () => setHoveredPortId(ph.port.id),
               onPointerLeave: () => setHoveredPortId((cur) => cur === ph.port.id ? void 0 : cur),
               onPointerDown: (e) => onPortPointerDown(ph.port.id, e, { side: ph.side, offset: ph.offset }, !nestedChild),
-              onContextMenu: (e) => {
+              onContextMenu: proxyPort ? (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+              } : (e) => {
                 e.preventDefault();
                 e.stopPropagation();
                 ctx.onContextNode(ph.port.id, e.clientX, e.clientY);
@@ -201777,7 +202379,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.21.0" : "dev";
+var VERSION2 = true ? "0.22.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;