sysml-diagram 0.22.0 → 0.24.0

package/out/main.js

@@ -161289,6 +161289,10 @@ function applyTransform(m, p) {
     m.r[6] * p[0] + m.r[7] * p[1] + m.r[8] * p[2] + m.t[2]
   ];
 }
+function isUnrotated(m) {
+  const id2 = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+  return m.r.every((v, i) => Math.abs(v - id2[i]) < 1e-6);
+}
 function yawOf(m) {
   if (Math.abs(m.r[2]) > 1e-6 || Math.abs(m.r[5]) > 1e-6)
     return void 0;
@@ -162227,6 +162231,91 @@ var FeaturePathResolver = class {
   }
 };
 
+// ../language-server/out/src/platform/platform.js
+var current;
+function setPlatform(platform) {
+  current = platform;
+}
+function getPlatform() {
+  if (!current)
+    throw new Error("SysML: no platform installed - the entry point must call setPlatform() first.");
+  return current;
+}
+function hasPlatform() {
+  return current !== void 0;
+}
+
+// ../language-server/out/src/services/library-index-manager.js
+var SysmlIndexManager = class extends DefaultIndexManager {
+  constructor(services) {
+    super(services);
+  }
+  // REQ-075, REQ-383 — `libraryRoot` is a URI and the concrete file URIs come
+  // from the platform, because the two hosts index the same library under
+  // different schemes (`file:` on the desktop, `sysml-lib:` in a worker).
+  loadPrecomputedLibraryIndex(index2, libraryRoot) {
+    const platform = getPlatform();
+    let symbolCount = 0;
+    for (const file of index2.files) {
+      const documentUri = platform.libraryUri(libraryRoot, file.path);
+      const descriptions = file.symbols.map((symbol) => this.deserializeSymbol(symbol, documentUri));
+      const uri = documentUri.toString();
+      this.symbolIndex.set(uri, descriptions);
+      this.symbolByTypeIndex.clear(uri);
+      symbolCount += descriptions.length;
+    }
+    return symbolCount;
+  }
+  deserializeSymbol(symbol, documentUri) {
+    return {
+      name: symbol.name,
+      type: symbol.type,
+      path: symbol.path,
+      documentUri,
+      nameSegment: symbol.nameSegment,
+      selectionSegment: symbol.selectionSegment,
+      // REQ-068 — preserve declared visibility for wildcard re-export.
+      ...symbol.isPrivate ? { isPrivate: true } : {},
+      ...symbol.visibility ? { visibility: symbol.visibility } : {},
+      // issue #152 — a re-exported alias is not owned nesting.
+      ...symbol.derivedKind ? { derivedKind: symbol.derivedKind } : {},
+      // REQ-242 — issue #103 — keeps type completion to definitions.
+      ...symbol.isUsage ? { isUsage: true } : {}
+    };
+  }
+};
+function isSysmlIndexManager(value) {
+  return typeof value.loadPrecomputedLibraryIndex === "function";
+}
+var libraryRoots = /* @__PURE__ */ new Set();
+var ROOT_SEPARATOR = "\0";
+function normalizeLibraryPath(p) {
+  return p.replace(/\\/gu, "/").replace(/\/+$/u, "").toLowerCase();
+}
+function registerLibraryRoot(root4) {
+  const uri = typeof root4 === "string" ? root4.length > 0 ? URI2.file(root4) : void 0 : root4;
+  if (!uri)
+    return;
+  libraryRoots.add(`${uri.scheme}${ROOT_SEPARATOR}${normalizeLibraryPath(uri.path)}`);
+}
+function isInsideDir(fsPath, dir) {
+  return fsPath === dir || fsPath.startsWith(`${dir}/`);
+}
+function isStandardLibraryUri(uri) {
+  const fsPath = normalizeLibraryPath(uri.path);
+  for (const entry of libraryRoots) {
+    const separator = entry.indexOf(ROOT_SEPARATOR);
+    if (entry.slice(0, separator) !== uri.scheme)
+      continue;
+    if (isInsideDir(fsPath, entry.slice(separator + 1)))
+      return true;
+  }
+  return fsPath.split("/").some((segment) => segment === "sysml.library");
+}
+function isLibraryDocument(doc) {
+  return doc.isLibraryDocument === true || isStandardLibraryUri(doc.uri);
+}
+
 // ../language-server/out/src/services/namespace-kind.js
 var KERML_CLASSIFIER_DECL_TYPES = /* @__PURE__ */ new Set([
   "AssociationDecl",
@@ -162372,6 +162461,112 @@ function multiplicityText(m) {
     return void 0;
   return hi == null || hi === lo ? `[${lo}]` : `[${lo}..${hi}]`;
 }
+function connectionEndMultiplicity(node) {
+  if (!node)
+    return void 0;
+  const n2 = node;
+  const multiplicity = n2.innerMultiplicity ?? n2.multiplicity ?? n2.endMultiplicity;
+  if (!multiplicity)
+    return void 0;
+  const lo = boundText(multiplicity.lower);
+  const hi = boundText(multiplicity.upper);
+  if (lo == null && hi == null)
+    return void 0;
+  return hi == null || hi === lo ? `[${lo}]` : `[${lo}..${hi}]`;
+}
+function isEmptyPrefixFlow(node) {
+  const fm = node;
+  return node.$type === "FlowStmt" && fm.target !== void 0 && fm.source === void 0;
+}
+function flowStmtName(node) {
+  return isEmptyPrefixFlow(node) ? void 0 : effectiveNameOf(node);
+}
+function flowKeyword(fm) {
+  return `${fm.succession === true ? "succession " : ""}${fm.flowKind === "message" ? "message" : "flow"}`;
+}
+function flowTransferredFeature(ends) {
+  const sourceFeature = ends.source ? lastSeg(ends.source) : void 0;
+  const targetFeature = ends.target ? lastSeg(ends.target) : void 0;
+  return sourceFeature === targetFeature ? sourceFeature : sourceFeature ?? targetFeature;
+}
+function flowDecorationMeta(carried) {
+  const drawn = carried.filter((flow) => !flow.message);
+  if (!drawn.length)
+    return {};
+  return {
+    flowDecorations: drawn.map(({ keyword, label, name, reversed, row }) => ({
+      keyword,
+      ...label ? { label } : {},
+      ...name ? { name } : {},
+      reversed,
+      ...row.source ? { source: row.source } : {}
+    }))
+  };
+}
+var END_PROPERTY_ADORNMENTS = /* @__PURE__ */ new Set(["abstract", "derived", "readonly", "ordered", "nonunique"]);
+var uniqueStrings = (values2) => [...new Set([...values2].filter((value) => !!value))];
+function formatConnectionEndAdornment(notation) {
+  const adornment = [
+    notation.direction,
+    ...notation.properties ?? [],
+    notation.subsets?.length ? `subsets ${notation.subsets.join(", ")}` : void 0,
+    notation.redefines?.length ? `redefines ${notation.redefines.join(", ")}` : void 0
+  ].filter((value) => !!value).join(" ");
+  return adornment || void 0;
+}
+function mergeConnectionEndNotation(local, inherited) {
+  const notation = {
+    role: local.role ?? inherited?.role,
+    multiplicity: local.multiplicity ?? inherited?.multiplicity,
+    direction: local.direction ?? inherited?.direction,
+    properties: uniqueStrings([...local.properties ?? [], ...inherited?.properties ?? []]),
+    subsets: uniqueStrings([...local.subsets ?? [], ...inherited?.subsets ?? []]),
+    redefines: uniqueStrings([...local.redefines ?? [], ...inherited?.redefines ?? []]),
+    type: local.type ?? inherited?.type
+  };
+  notation.adornment = formatConnectionEndAdornment(notation);
+  return notation;
+}
+function connectionEndNotationClaims(notation) {
+  return uniqueStrings([
+    notation.role,
+    ...(notation.redefines ?? []).map(lastSeg)
+  ]);
+}
+function connectionEndSpecializesRole(notation, role) {
+  const wanted = lastSeg(role);
+  return [...notation.subsets ?? [], ...notation.redefines ?? []].some((target) => lastSeg(target) === wanted);
+}
+function declaredConnectionEndNotation(node) {
+  const n2 = node;
+  const modifiers2 = [
+    ...n2.modifiers ?? [],
+    ...n2.postModifiers ?? [],
+    ...n2.trailingQuals ?? [],
+    ...n2.innerTrailingQuals ?? []
+  ];
+  const direction = modifiers2.find((value) => value === "in" || value === "out" || value === "inout");
+  const properties = uniqueStrings(modifiers2.filter((value) => END_PROPERTY_ADORNMENTS.has(value)));
+  const subsets = [];
+  const redefines = [];
+  for (const relationship of [...n2.relationships ?? [], ...n2.innerRelationships ?? []]) {
+    const targets = relationship.targets ?? [];
+    if (relationship.kind === ":>" || relationship.kind === "subsets") {
+      subsets.push(...targets);
+    } else if (relationship.kind === ":>>" || relationship.kind === "redefines") {
+      redefines.push(...targets);
+    }
+  }
+  return mergeConnectionEndNotation({
+    role: n2.innerName ?? nameOf2(node) ?? redefines.map(lastSeg).find(Boolean),
+    multiplicity: connectionEndMultiplicity(node),
+    direction,
+    properties,
+    subsets: uniqueStrings(subsets),
+    redefines: uniqueStrings(redefines),
+    type: n2.innerTyping?.type?.$refText ?? n2.typing?.type?.$refText
+  }, void 0);
+}
 function multText(node) {
   if (!node)
     return void 0;
@@ -162782,17 +162977,40 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       else
         drawn.set(k, [target]);
     };
-    for (const n2 of model.nodes) {
-      claim(n2.source, { id: n2.id, parent: n2.parent, frame: n2.frame });
+    const claimNode = (n2, definitionLayer2 = false) => {
+      claim(n2.source, { id: n2.id, parent: n2.parent, frame: n2.frame, definitionLayer: definitionLayer2 });
       for (const port of n2.ports ?? []) {
-        claim(port.source, { id: port.id, parent: n2.parent, frame: n2.frame, port: true });
+        if (port.meta?.connectionEndPin === true)
+          continue;
+        claim(port.source, {
+          id: port.id,
+          parent: n2.parent,
+          frame: n2.frame,
+          port: true,
+          definitionLayer: definitionLayer2
+        });
       }
-    }
-    for (const f of model.frames ?? []) {
-      claim(f.source, { id: f.id, frame: f.id });
+    };
+    const claimFrame = (f, definitionLayer2 = false) => {
+      claim(f.source, { id: f.id, frame: f.id, definitionLayer: definitionLayer2 });
       for (const port of f.ports ?? []) {
-        claim(port.source, { id: port.id, frame: f.id, port: true });
+        if (port.meta?.connectionEndPin === true)
+          continue;
+        claim(port.source, { id: port.id, frame: f.id, port: true, definitionLayer: definitionLayer2 });
       }
+    };
+    for (const n2 of model.nodes) {
+      claimNode(n2);
+    }
+    for (const f of model.frames ?? []) {
+      claimFrame(f);
+    }
+    const definitionLayer = model.layers?.definitions;
+    for (const n2 of definitionLayer?.nodes ?? []) {
+      claimNode(n2, true);
+    }
+    for (const f of definitionLayer?.frames ?? []) {
+      claimFrame(f, true);
     }
     if (model.ivBoundary) {
       claim(model.ivBoundary.source, { id: model.ivBoundary.id, frame: model.ivBoundary.id });
@@ -162804,15 +163022,22 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return model;
     const nodes = [...model.nodes];
     const edges = [...model.edges];
+    const definitionNodes = [...definitionLayer?.nodes ?? []];
+    const definitionEdges = [...definitionLayer?.edges ?? []];
     let noteCount = 0;
-    let edgeCount = edges.length;
+    let edgeCount = [...edges, ...definitionEdges].reduce((next, edge) => {
+      const match = /^e(\d+)$/u.exec(edge.id);
+      return match ? Math.max(next, Number(match[1]) + 1) : next;
+    }, 0);
     const note = (annotation) => {
       const targets = drawn.get(key(sourceOf2(annotation.owner, uri)) ?? "")?.filter((target) => annotation.keyword !== "doc" || docAsNote || target.port);
       if (!targets?.length)
         return;
       for (const target of targets) {
         const id2 = `__note_${noteCount++}__`;
-        nodes.push({
+        const targetNodes = target.definitionLayer ? definitionNodes : nodes;
+        const targetEdges = target.definitionLayer ? definitionEdges : edges;
+        targetNodes.push({
           id: id2,
           name: annotation.label,
           keyword: annotation.keyword,
@@ -162825,7 +163050,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           ...target.frame ? { frame: target.frame } : {},
           source: sourceOf2(annotation.annotation, uri)
         });
-        edges.push({
+        targetEdges.push({
           id: `e${edgeCount++}`,
           from: id2,
           to: target.id,
@@ -162843,7 +163068,23 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           note(annotation);
       }
     }
-    return noteCount ? { ...model, nodes, edges } : model;
+    if (!noteCount)
+      return model;
+    return {
+      ...model,
+      nodes,
+      edges,
+      ...definitionLayer ? {
+        layers: {
+          ...model.layers,
+          definitions: {
+            ...definitionLayer,
+            nodes: definitionNodes,
+            edges: definitionEdges
+          }
+        }
+      } : {}
+    };
   }
   // REQ-224 — Detect the file/anchor-specific view kinds that will render
   // substantive diagram content. The extension uses this to limit the
@@ -163670,8 +163911,27 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   hasGeometryObject(node, index2) {
     return this.collectGeometry(node, index2).length > 0;
   }
+  // REQ-360 — Package overview
+  /** Package overviews contain layouts, not inventories of unplaced shape types. */
+  hasPlacedGeometryObject(node, index2) {
+    return this.collectGeometry(node, index2).some((candidate) => candidate.geo !== void 0);
+  }
+  // REQ-360 — Package overview
+  /** Collapse a wrapper whose only direct object owns the actual layout. */
+  hasGeometryOverviewLayout(node, index2) {
+    const placed = this.collectGeometry(node, index2).filter((candidate) => candidate.geo !== void 0);
+    if (placed.length === 0)
+      return false;
+    const direct = placed.filter((candidate) => !candidate.name.includes("."));
+    if (direct.length !== 1)
+      return true;
+    const prefix = `${direct[0].name}.`;
+    return !placed.some((candidate) => candidate.name.startsWith(prefix));
+  }
   hasRenderablePorts(node, index2) {
-    return [node, ...this.inheritedFeatureOwnersOf(node, index2)].some((source) => membersOf(source).some((m) => isPortDecl(m) && m.isDef !== true));
+    if (membersOf(node).some((member) => isPortDecl(member) && member.isDef !== true))
+      return true;
+    return this.inheritedFeatureOwnersOf(node, index2).some((source) => membersOf(source).some((member) => isPortDecl(member) && member.isDef !== true && !this.isInheritedLibraryBackboneFeature(source, member, index2)));
   }
   // 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 `:>`
@@ -163679,11 +163939,51 @@ 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.inheritedFeatureOwnersOf(node, index2)].some((source) => this.nestedUsages(source, isPartDecl).some((n2) => nameOf2(n2) !== void 0));
+    return this.structuralChildUsagesOf(node, index2).some((usage) => nameOf2(usage) !== void 0);
   }
   nestedUsages(node, guard) {
     return membersOf(node).filter((m) => guard(m) && m.isDef !== true);
   }
+  // REQ-192 - standard-library definitions contribute real inherited structure,
+  // but their recursive backbone features are collecting roles, not additional
+  // concrete children of every typed usage. For example, SpatialItem declares
+  // `subSpatialParts : SpatialItem`, and Part declares `start : Part`. Expanding
+  // either role as another occurrence recursively materializes the library model
+  // instead of the user's composition. A local redefinition remains visible.
+  isInheritedLibraryBackboneFeature(source, usage, index2) {
+    if (!isLibraryDocument(ast_utils_exports.getDocument(usage)))
+      return false;
+    if (modifiersOf(usage).includes("abstract"))
+      return true;
+    const ownerType = source.isDef === true ? source : this.resolveType(source, index2);
+    const usageType = this.resolveType(usage, index2);
+    if (!ownerType || !usageType)
+      return false;
+    if (ownerType === usageType)
+      return true;
+    return this.inheritedFeatureOwnersOf(ownerType, index2).includes(usageType) || this.inheritedFeatureOwnersOf(usageType, index2).includes(ownerType);
+  }
+  /** The concrete structural children projected by IV, with the same nearest-name
+   * fold used for other effective inventories. Authored subsets of an inherited
+   * library collection stay visible; only the inherited recursive role is hidden. */
+  structuralChildUsagesOf(part, index2) {
+    const out = this.nestedUsages(part, isPartDecl);
+    const have = new Set(out.map(effectiveNameOf).filter((name) => !!name));
+    for (const source of this.inheritedFeatureOwnersOf(part, index2)) {
+      for (const usage of this.nestedUsages(source, isPartDecl)) {
+        if (this.isInheritedLibraryBackboneFeature(source, usage, index2))
+          continue;
+        const name = effectiveNameOf(usage);
+        if (name !== void 0) {
+          if (have.has(name))
+            continue;
+          have.add(name);
+        }
+        out.push(usage);
+      }
+    }
+    return out;
+  }
   // issue #109 — usages of kinds with NO dedicated usage view (constraint /
   // calc / occurrence / item / attribute). Nested in an element they surface as
   // owner compartments (compartmentsFor); declared as direct package members
@@ -163718,8 +164018,13 @@ 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 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 isDirectPackageInterfaceUsage = (n2) => isInterfaceDecl(n2) && n2.isDef !== true && this.isDirectPackageMember(n2);
+    const isPackageInterfaceUsage = (n2) => {
+      const usage = n2;
+      const emptyPrefix = usage.target !== void 0 && usage.connect === void 0;
+      return isDirectPackageInterfaceUsage(n2) && !emptyPrefix && !!nameOf2(n2);
+    };
+    const hasOwnedMemberNode = all.some((n2) => isPackage(n2) && !!nameOf2(n2) || isDefinitionNode(n2) && !!nameOf2(n2) || this.isViewlessUsage(n2) && this.isDirectPackageMember(n2) || isDirectPackageInterfaceUsage(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))
@@ -163880,6 +164185,77 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         }
       }
     }
+    for (const definition of defNodes.filter(isConnectionDecl)) {
+      const definitionId = ids.get(definition);
+      if (!definitionId)
+        continue;
+      const effectiveEnds = this.connectionEndNotationsOf(definition, index2);
+      const resolvedEnds = effectiveEnds.map((notation) => {
+        const target = notation.type ? resolveDrawnByText(notation.type) : void 0;
+        return target && ids.has(target) ? { id: ids.get(target), notation } : void 0;
+      });
+      if (resolvedEnds.length < 2 || resolvedEnds.some((end) => !end))
+        continue;
+      const completeEnds = resolvedEnds.filter((end) => !!end);
+      const definitionNode = nodes.find((node) => node.id === definitionId);
+      const hasElaboration = !!definitionNode?.compartments?.length || specializationFamily(definition).length > 0;
+      if (definitionNode) {
+        definitionNode.meta = {
+          ...definitionNode.meta,
+          connectionDefinitionGraphical: true,
+          ...hasElaboration ? { connectionDefinitionElaboration: true } : {}
+        };
+      }
+      const common = {
+        kind: "connect",
+        name: nameOf2(definition),
+        isDef: true,
+        label: `\xABconnection def\xBB ${nameOf2(definition) ?? ""}`.trim(),
+        source: sourceOf2(definition, uri),
+        meta: { connectionDefinitionGraphical: true },
+        ...hasElaboration ? { elaboration: definitionId } : {}
+      };
+      if (completeEnds.length === 2) {
+        edges.push({
+          id: `e${e++}`,
+          from: completeEnds[0].id,
+          to: completeEnds[1].id,
+          ...common,
+          endRoleFrom: completeEnds[0].notation.role,
+          endLabelFrom: completeEnds[0].notation.multiplicity,
+          endAdornmentFrom: completeEnds[0].notation.adornment,
+          endRoleTo: completeEnds[1].notation.role,
+          endLabelTo: completeEnds[1].notation.multiplicity,
+          endAdornmentTo: completeEnds[1].notation.adornment
+        });
+      } else {
+        const hubId = `${definitionId}::__connection__`;
+        nodes.push({
+          id: hubId,
+          name: nameOf2(definition) ?? "",
+          keyword: "connection def",
+          isDef: true,
+          shape: "dot",
+          ...packageOf2(definition),
+          source: sourceOf2(definition, uri),
+          meta: {
+            connectionDefinitionGraphical: true,
+            connectionDefinitionHub: true,
+            naryConnectionHub: true
+          }
+        });
+        completeEnds.forEach((end, indexOfEnd) => edges.push({
+          id: `e${e++}`,
+          from: hubId,
+          to: end.id,
+          ...common,
+          ...indexOfEnd === 0 ? {} : { label: void 0, elaboration: void 0 },
+          endRoleTo: end.notation.role,
+          endLabelTo: end.notation.multiplicity,
+          endAdornmentTo: end.notation.adornment
+        }));
+      }
+    }
     for (const rs of all.filter((m) => m.$type === "StandaloneRelationshipDecl")) {
       const rn = rs;
       const from = resolveDrawnByText(String(rn.source ?? ""));
@@ -164296,6 +164672,270 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const o = v;
     return this.featurePath(o.reference) ?? this.featurePath(o.path) ?? o.$cstNode?.text?.replace(/\[[^\]]*\]/g, "").trim();
   }
+  connectorEndRole(v) {
+    if (!v || typeof v !== "object")
+      return void 0;
+    const end = v;
+    if (!end.reference)
+      return void 0;
+    const role = this.featurePath(end.path);
+    return role ? lastSeg(role) : void 0;
+  }
+  // REQ-192, issue #111: connection and interface definitions may specialize
+  // definitions that own their ends. Fold those ends nearest-first, just like
+  // the rest of the effective IV inventory. A local end shadows an inherited
+  // end by role or explicit redefinition and inherits notation it omits.
+  connectionEndNotationsOf(owner, index2) {
+    if (!owner)
+      return [];
+    const inheritedOwners = owner.isDef === true ? [] : this.inheritedFeatureOwnersOf(owner, index2);
+    const definition = owner.isDef === true ? owner : this.resolveType(owner, index2) ?? inheritedOwners.find((candidate) => candidate.isDef === true && candidate.$type === owner.$type);
+    if (!definition)
+      return [];
+    const selected2 = [];
+    for (const source of [definition, ...this.inheritedFeatureOwnersOf(definition, index2)]) {
+      for (const end of membersOf(source).filter(isEndMember)) {
+        const notation = declaredConnectionEndNotation(end);
+        const claims = new Set(connectionEndNotationClaims(notation));
+        const existing = selected2.find((candidate) => [...claims].some((claim) => candidate.claims.has(claim)));
+        if (existing) {
+          existing.notation = mergeConnectionEndNotation(existing.notation, notation);
+          for (const claim of connectionEndNotationClaims(existing.notation))
+            existing.claims.add(claim);
+          continue;
+        }
+        const inheritedRole = notation.role;
+        const specialized = inheritedRole ? selected2.filter((candidate) => connectionEndSpecializesRole(candidate.notation, inheritedRole)) : [];
+        if (specialized.length > 0) {
+          for (const candidate of specialized) {
+            candidate.notation = mergeConnectionEndNotation(candidate.notation, notation);
+            for (const claim of connectionEndNotationClaims(candidate.notation))
+              candidate.claims.add(claim);
+          }
+          continue;
+        }
+        selected2.push({ notation, claims });
+      }
+    }
+    return selected2.map(({ notation }) => notation);
+  }
+  matchingConnectionEndNotation(notations, role, ordinal) {
+    const wanted = role ? lastSeg(role) : void 0;
+    if (wanted) {
+      return notations.find((notation) => connectionEndNotationClaims(notation).some((claim) => lastSeg(claim) === wanted));
+    }
+    return notations[ordinal];
+  }
+  declaredConnectionEndBinding(node) {
+    const n2 = node;
+    for (const relationship of [...n2.relationships ?? [], ...n2.innerRelationships ?? []]) {
+      if (relationship.kind !== "::>" && relationship.kind !== "references")
+        continue;
+      for (const [occurrence, target] of (relationship.targets ?? []).entries()) {
+        if (!target)
+          continue;
+        return {
+          path: target,
+          binding: {
+            host: relationship,
+            property: "targets",
+            occurrence
+          }
+        };
+      }
+    }
+    return {};
+  }
+  connectorEndBinding(end) {
+    if (!end || typeof end !== "object" || !("$type" in end))
+      return void 0;
+    const connectorEnd = end;
+    if (connectorEnd.$type !== "ConnectorEnd")
+      return void 0;
+    return {
+      host: connectorEnd,
+      property: connectorEnd.reference ? "reference" : "path",
+      occurrence: 0
+    };
+  }
+  canonicalConnectionBindingTarget(target, seen = /* @__PURE__ */ new Set()) {
+    if (!isAliasDecl(target))
+      return target;
+    if (seen.has(target))
+      return void 0;
+    seen.add(target);
+    const resolution = this.annotationPathResolver(target).resolvePropertyPath(target, "target");
+    if (resolution.unresolvedIndex !== void 0 || resolution.indeterminateIndex !== void 0)
+      return void 0;
+    const terminal = resolution.segments.at(-1);
+    const aliasTarget = terminal?.target ?? this.annotationDescriptionNode(target, terminal?.description);
+    return aliasTarget ? this.canonicalConnectionBindingTarget(aliasTarget, seen) : void 0;
+  }
+  explicitFeatureAncestorsOf(node, index2) {
+    const ancestors = [];
+    const seen = /* @__PURE__ */ new Set([node]);
+    const queue = [node];
+    while (queue.length > 0) {
+      const current2 = queue.shift();
+      for (const path10 of featureInheritanceTargets(current2)) {
+        const target = this.resolveFeatureInheritanceTarget(current2, path10, index2, /* @__PURE__ */ new Set());
+        if (!target || seen.has(target))
+          continue;
+        seen.add(target);
+        ancestors.push(target);
+        queue.push(target);
+      }
+    }
+    return ancestors;
+  }
+  /** REQ-192: whether the declared path resolves to the exact rendered
+   * occurrence path. The ordinary IV endpoint resolver remains forgiving for
+   * issue #62; inherited visibility also checks every semantic receiver so a
+   * path such as `outside.p` cannot borrow another visible `inside.p` merely
+   * because both ports share one definition. */
+  connectionUsageEndBindingMatches(end, renderedPath, ownerPath, index2) {
+    if (!end.binding || !renderedPath || !ownerPath)
+      return false;
+    const resolution = this.annotationPathResolver(end.binding.host).resolvePropertyPath(end.binding.host, end.binding.property, end.binding.occurrence);
+    if (resolution.unresolvedIndex !== void 0 || resolution.indeterminateIndex !== void 0)
+      return false;
+    const semanticPath = [];
+    const resolver = this.annotationPathResolver(end.binding.host);
+    let canonicalOwner;
+    for (const segment of resolution.segments) {
+      const target = canonicalOwner ? resolver.visibleMembers(canonicalOwner).find((candidate) => effectiveNameOf(candidate) === segment.text) : segment.target ?? this.annotationDescriptionNode(end.binding.host, segment.description);
+      if (!target)
+        return false;
+      const canonical = this.canonicalConnectionBindingTarget(target);
+      if (!canonical)
+        return false;
+      if (canonicalOwner || isAliasDecl(target))
+        canonicalOwner = canonical;
+      if (isPackage(canonical) || isDocument(canonical) || canonical.$type === "NamespaceDecl")
+        continue;
+      semanticPath.push(canonical);
+    }
+    if (semanticPath.length === 0)
+      return false;
+    const sameDeclaration = (candidate, expected) => {
+      if (candidate === expected)
+        return true;
+      const candidateCst = candidate.$cstNode;
+      const expectedCst = expected.$cstNode;
+      if (!candidateCst || !expectedCst || candidate.$type !== expected.$type || candidateCst.offset !== expectedCst.offset || candidateCst.end !== expectedCst.end) {
+        return false;
+      }
+      try {
+        return ast_utils_exports.getDocument(candidate).uri.toString() === ast_utils_exports.getDocument(expected).uri.toString();
+      } catch {
+        return false;
+      }
+    };
+    const matches = (candidatePath, allowRootRebinding) => candidatePath.length === semanticPath.length && candidatePath.every((candidate, at) => {
+      const expected = semanticPath[at];
+      if (sameDeclaration(candidate, expected) || this.explicitFeatureAncestorsOf(candidate, index2).some((ancestor) => sameDeclaration(ancestor, expected))) {
+        return true;
+      }
+      return allowRootRebinding && at === 0 && this.inheritedFeatureOwnersOf(candidate, index2).some((ancestor) => sameDeclaration(ancestor, expected));
+    });
+    const relativePath = renderedPath.slice(ownerPath.length);
+    const ownerRootedPath = renderedPath.slice(Math.max(0, ownerPath.length - 1));
+    const result = matches(relativePath, false) || matches(ownerRootedPath, true) || matches(renderedPath, true) || semanticPath.length === 1 && matches(renderedPath.slice(-1), false);
+    return result;
+  }
+  /** REQ-192: the ends written directly on one explicit connection usage.
+   * This keeps the concrete binding path beside its notation so inheritance
+   * can fold both pieces of the effective end together. */
+  declaredConnectionUsageEndsOf(owner, index2) {
+    const clause = owner.connect;
+    if (clause) {
+      const rawEnds = clause.ends?.length ? clause.ends : [clause.source, clause.target].filter((end) => end !== void 0);
+      return rawEnds.map((end, ordinal) => ({
+        notation: this.connectorEndNotation(owner, end, index2, ordinal),
+        path: this.connectorEndPath(end),
+        binding: this.connectorEndBinding(end),
+        ordinal
+      }));
+    }
+    const effective = this.connectionEndNotationsOf(owner, index2);
+    return membersOf(owner).filter(isEndMember).map((end, ordinal) => {
+      const local = declaredConnectionEndNotation(end);
+      const declaredBinding = this.declaredConnectionEndBinding(end);
+      return {
+        notation: mergeConnectionEndNotation(local, this.matchingConnectionEndNotation(effective, local.role, ordinal)),
+        ...declaredBinding,
+        ordinal
+      };
+    });
+  }
+  /** REQ-192/195: an explicit connection or interface usage redefinition
+   * inherits any end binding it does not replace. Sources are nearest first.
+   * Role and redefinition claims identify corresponding ends, with source-local
+   * ordinal as the fallback. */
+  effectiveConnectionUsageEndsOf(owner, index2) {
+    const declared = [];
+    for (const source of [owner, ...this.inheritedFeatureOwnersOf(owner, index2)]) {
+      if (source.$type !== owner.$type || !isConnectionDecl(source) && !isInterfaceDecl(source) || source.isDef === true)
+        continue;
+      for (const candidate of this.declaredConnectionUsageEndsOf(source, index2)) {
+        const claims = connectionEndNotationClaims(candidate.notation).map(lastSeg);
+        let existingIndex = claims.length > 0 ? declared.findIndex((current2) => connectionEndNotationClaims(current2.notation).map(lastSeg).some((claim) => claims.includes(claim))) : -1;
+        if (existingIndex < 0) {
+          const ordinalIndex = declared.findIndex((current2) => current2.ordinal === candidate.ordinal);
+          const ordinalClaims = ordinalIndex >= 0 ? connectionEndNotationClaims(declared[ordinalIndex].notation).map(lastSeg) : [];
+          if (claims.length === 0 || ordinalClaims.length === 0)
+            existingIndex = ordinalIndex;
+        }
+        if (existingIndex < 0) {
+          declared.push(candidate);
+          continue;
+        }
+        const nearer = declared[existingIndex];
+        const inheritsPath = nearer.path === void 0;
+        declared[existingIndex] = {
+          ...nearer,
+          notation: mergeConnectionEndNotation(nearer.notation, candidate.notation),
+          path: nearer.path ?? candidate.path,
+          binding: inheritsPath ? candidate.binding : nearer.binding
+        };
+      }
+    }
+    const effective = this.connectionEndNotationsOf(owner, index2);
+    const selectedDeclared = /* @__PURE__ */ new Set();
+    const ends = effective.map((notation, ordinal) => {
+      const claims = connectionEndNotationClaims(notation).map(lastSeg);
+      let declaredIndex = declared.findIndex((candidate, candidateIndex) => !selectedDeclared.has(candidateIndex) && connectionEndNotationClaims(candidate.notation).map(lastSeg).some((claim) => claims.includes(claim)));
+      if (declaredIndex < 0 && declared[ordinal] && !selectedDeclared.has(ordinal)) {
+        const declaredClaims = connectionEndNotationClaims(declared[ordinal].notation).map(lastSeg);
+        if (claims.length === 0 || declaredClaims.length === 0)
+          declaredIndex = ordinal;
+      }
+      const concrete = declaredIndex >= 0 ? declared[declaredIndex] : void 0;
+      if (declaredIndex >= 0)
+        selectedDeclared.add(declaredIndex);
+      return {
+        notation: mergeConnectionEndNotation(concrete?.notation ?? {}, notation),
+        path: concrete?.path,
+        binding: concrete?.binding,
+        ordinal
+      };
+    });
+    for (const [declaredIndex, candidate] of declared.entries()) {
+      if (selectedDeclared.has(declaredIndex))
+        continue;
+      ends.push({ ...candidate, ordinal: ends.length });
+    }
+    return ends;
+  }
+  connectorEndNotation(owner, rawEnd, index2, ordinal = 0) {
+    const explicit = rawEnd && typeof rawEnd === "object" && "$type" in rawEnd ? connectionEndMultiplicity(rawEnd) : void 0;
+    const role = this.connectorEndRole(rawEnd);
+    const inherited = this.matchingConnectionEndNotation(this.connectionEndNotationsOf(owner, index2), role, ordinal);
+    return mergeConnectionEndNotation({
+      role,
+      multiplicity: explicit ?? inherited?.multiplicity
+    }, inherited);
+  }
   // FlowStmt ends for both spec forms (OMG SysML 8.2.2.16): explicit
   // `from a to b`, and the keyword-less shorthand `flow a.x to b.y;` whose
   // source is parsed as name + dotted segments.
@@ -164308,6 +164948,27 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     }
     return { source: void 0, target: fm.target ? String(fm.target) : void 0 };
   }
+  // REQ-401 — the `flows-compartment` row of one flow or message usage (OMG
+  // SysML 8.2.3.16). Rebuilt from the declaration instead of copied from the
+  // source text, because a flow may carry a BODY (`flow a.x to b.y { doc ... }`)
+  // whose whole text would otherwise be inlined into one compartment row.
+  // `ends` overrides the declared endpoints with the concrete ones a relationship
+  // usage rebinds them to (REQ-402).
+  // REQ-401 — Flow notation: on-connection decoration, port docking, and the flow usage node
+  flowRowText(flow, ends) {
+    const fm = flow;
+    const declared = ends ?? this.flowStmtEnds(fm);
+    const type = typeText(flow);
+    const payload = this.flowPayloadText(fm);
+    return [
+      flowKeyword(fm),
+      flowStmtName(flow),
+      type ? `: ${type}` : void 0,
+      payload ? `of ${payload}` : void 0,
+      declared.source ? `from ${declared.source}` : void 0,
+      declared.target ? `to ${declared.target}` : void 0
+    ].filter(Boolean).join(" ");
+  }
   // Payload text of a flow/message (`of Fuel` / `of f : Fuel`) per OMG SysML
   // 8.2.2.16 PayloadFeature.
   flowPayloadText(fm) {
@@ -164317,6 +164978,87 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const typeRef = p.type?.$refText ?? p.typing?.type?.$refText;
     return typeRef ? lastSeg(typeRef) : p.name;
   }
+  // REQ-402 — the flows a connection or interface usage CARRIES. A flow declared
+  // in a `connection def` / `interface def` body (OMG SysML 8.2.3.16, and the
+  // `Flow Interface Example` of the training corpus) is transported by every
+  // usage of that definition; it is not a transfer of its own between two
+  // unrelated features. Each end path is rebound through the usage's own end
+  // bindings, so the definition-local `supplierPort.fuelSupply` reads as the
+  // concrete `tankAssy.fuelTankPort.fuelSupply` this usage connects, and the
+  // transfer direction is expressed relative to the usage's own end ordinals so
+  // it survives whichever notation the relationship is drawn in.
+  // REQ-402 — Flows carried by a connection or interface usage
+  carriedFlowsOf(usage, ends, index2, uri) {
+    const ordinalByRole = /* @__PURE__ */ new Map();
+    const pathByRole = /* @__PURE__ */ new Map();
+    for (const end of ends) {
+      const role = end.notation.role;
+      if (!role)
+        continue;
+      if (!ordinalByRole.has(role))
+        ordinalByRole.set(role, end.ordinal);
+      if (end.path && !pathByRole.has(role))
+        pathByRole.set(role, end.path);
+    }
+    const rebind = (path10) => {
+      if (!path10)
+        return void 0;
+      const segs = path10.split(".");
+      const bound = pathByRole.get(segs[0]);
+      return bound ? [bound, ...segs.slice(1)].join(".") : path10;
+    };
+    const carried = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const source of [usage, ...this.inheritedFeatureOwnersOf(usage, index2)]) {
+      for (const member of membersOf(source)) {
+        if (member.$type !== "FlowStmt" || member.isDef === true)
+          continue;
+        const fm = member;
+        const flowEnds = this.flowStmtEnds(fm);
+        const name = flowStmtName(member);
+        const payload = this.flowPayloadText(fm);
+        const key = name ?? `\0${flowEnds.source ?? ""}\0${flowEnds.target ?? ""}\0${payload ?? typeText(member) ?? ""}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        const fromOrdinal = flowEnds.source ? ordinalByRole.get(flowEnds.source.split(".")[0]) : void 0;
+        const from = rebind(flowEnds.source);
+        const to = rebind(flowEnds.target);
+        carried.push({
+          flow: member,
+          keyword: flowKeyword(fm),
+          label: payload ?? typeText(member) ?? flowTransferredFeature(flowEnds),
+          name,
+          // The decoration rides the relationship, whose drawn direction
+          // runs from its first end to its second.
+          reversed: fromOrdinal !== void 0 && fromOrdinal > 0,
+          inherited: source !== usage,
+          message: fm.flowKind === "message",
+          row: {
+            text: this.flowRowText(member, { source: from, target: to }),
+            source: sourceOf2(member, uri)
+          }
+        });
+      }
+    }
+    return carried;
+  }
+  // REQ-402 — merge the transfers a relationship usage carries from its
+  // definitions into the `flows` compartment its own body already contributes,
+  // so one heading holds every transfer the usage transports.
+  // REQ-402 — Flows carried by a connection or interface usage
+  withCarriedFlowRows(compartments, carried) {
+    const rows = carried.filter((flow) => flow.inherited).map((flow) => flow.row);
+    if (!rows.length)
+      return compartments;
+    const out = [...compartments ?? []];
+    const existing = out.findIndex((compartment) => compartment.title === "flows");
+    if (existing >= 0)
+      out[existing] = { ...out[existing], items: [...out[existing].items, ...rows] };
+    else
+      out.push({ title: "flows", items: rows });
+    return out;
+  }
   // REQ-192/360/363 — the ONE recursive Interconnection View renderer. Given the
   // top-level `roots` to draw, it renders each part instance and nests its
   // internals recursively, drilling into a usage's type DEFINITION (+
@@ -164329,7 +165071,13 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const nodes = [];
     const edges = [];
     const frames = [];
+    const primaryTarget = { nodes, edges, frames };
+    const definitionTarget = { nodes: [], edges: [], frames: [] };
     const eRef = { n: 0 };
+    const drawnPartIds = /* @__PURE__ */ new Set();
+    const endpointProvenance = /* @__PURE__ */ new Map();
+    const typedPartUsages = [];
+    const definitionRootIds = /* @__PURE__ */ new Map();
     const enclosingPackage = (n2) => {
       let c = n2.$container;
       while (c && c !== scope) {
@@ -164352,29 +165100,14 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       pkgFrame.set(pkg, id2);
       return id2;
     };
-    const childUsagesOf = (part) => {
-      const out = this.nestedUsages(part, isPartDecl);
-      const have = new Set(out.map(effectiveNameOf).filter((x) => !!x));
-      for (const source of this.inheritedFeatureOwnersOf(part, index2)) {
-        for (const usage of this.nestedUsages(source, isPartDecl)) {
-          const nm = effectiveNameOf(usage);
-          if (nm !== void 0) {
-            if (have.has(nm))
-              continue;
-            have.add(nm);
-          }
-          out.push(usage);
-        }
-      }
-      return out;
-    };
+    const childUsagesOf = (part) => this.structuralChildUsagesOf(part, index2);
     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 emptyPrefixFlow = isEmptyPrefixFlow(member);
           const emptyPrefixInterface = isInterfaceDecl(member) && relationship.target !== void 0 && relationship.connect === void 0;
           const namedRelationship = isConnectorDecl(member) || isConnectionDecl(member) || isInterfaceDecl(member) && !emptyPrefixInterface || member.$type === "BindingDecl" || member.$type === "FlowStmt" && !emptyPrefixFlow;
           if (namedRelationship) {
@@ -164394,6 +165127,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const actionPort = /* @__PURE__ */ new Map();
       const localNode = /* @__PURE__ */ new Map();
       const actionPinIds = /* @__PURE__ */ new Set();
+      const structuralPortIds = /* @__PURE__ */ new Set();
       const addActionPort = (key, id2) => {
         if (!actionPort.has(key))
           actionPort.set(key, id2);
@@ -164411,6 +165145,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           localPort.set(`${id2}.${rel2}`, port.id);
           if (bare)
             localPort.set(rel2, port.id);
+          structuralPortIds.add(port.id);
         }
       };
       for (const { usage, id: id2 } of childInfos)
@@ -164457,25 +165192,40 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
             return actionPort.get(firstLast) ?? void 0;
           if (localPort.has(firstLast))
             return localPort.get(firstLast);
+          const rootId = localNode.get(segs[0]);
+          const nestedId = rootId ? `${rootId}::${segs.slice(1).join("::")}` : void 0;
+          if (nestedId && drawnPartIds.has(nestedId))
+            return nestedId;
         }
         const bare = bareName2.get(segs[segs.length - 1]);
         if (bare)
           return bare;
         return segs.length === 1 ? localNode.get(segs[0]) : void 0;
       };
-      return { resolve: resolve8, actionPinIds };
+      return { resolve: resolve8, actionPinIds, structuralPortIds };
     };
-    const renderInstance = (part, instanceId, parentFrame, seenTypes, depth, inheritedLocalUsage, inheritedLocalPath = []) => {
+    const renderInstance = (part, instanceId, parentFrame, seenTypes, depth, inheritedLocalUsage, inheritedLocalPath = [], target = primaryTarget, definitionLayerRoot = false, occurrenceInherited = false, parentOccurrencePath = []) => {
+      drawnPartIds.add(instanceId);
+      const occurrencePath = [...parentOccurrencePath, part];
+      endpointProvenance.set(instanceId, occurrencePath);
       const typeDef = part.isDef === true ? void 0 : this.resolveType(part, index2) ?? this.inheritedFeatureOwnersOf(part, index2).find((owner) => owner.isDef === true);
+      if (typeDef && isPartDecl(typeDef) && typeDef.isDef === true && part.isDef !== true) {
+        typedPartUsages.push({ usage: part, id: instanceId, definition: typeDef });
+      }
       const typeQ = typeDef ? qnameOf(typeDef) : void 0;
       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 ports = this.portsOf(part, index2, uri, instanceId, localUsage).ports;
+      const projectedPorts = this.portsOf(part, index2, uri, instanceId, localUsage);
+      const ports = projectedPorts.ports;
+      for (const [id2, origin] of projectedPorts.origins) {
+        endpointProvenance.set(id2, [...occurrencePath, ...origin]);
+      }
       const syncDeclaration = this.synchronizationDeclarationOf(part, index2);
       const editMeta = {
         ...ivEditMeta(part, instanceId, typeDef, localUsage, localPath, uri),
+        ...definitionLayerRoot ? { ivPartDef: true } : {},
         ...syncDeclaration && syncDeclaration !== part ? {
           syncDeclarationId: qnameOf(syncDeclaration),
           syncDeclarationName: effectiveNameOf(syncDeclaration),
@@ -164483,7 +165233,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         } : {}
       };
       const children2 = depth < 8 && !(typeQ !== void 0 && seenTypes.has(typeQ)) ? childUsagesOf(part) : [];
-      const concretePerformPath = (statement, target) => {
+      const concretePerformPath = (statement, target2) => {
         if (!this.isAnonymousBehaviorReference(statement)) {
           return qnameOf(statement) || nameOf2(statement) || "perform";
         }
@@ -164491,7 +165241,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         const featureStart = segments.findIndex((segment, at) => at > 0 && segment.separator === ".");
         if (featureStart > 0) {
           const writtenPath = segments.map((segment) => segment.text).join("::");
-          const targetName = qnameOf(target);
+          const targetName = qnameOf(target2);
           if (targetName === writtenPath || targetName.endsWith(`::${writtenPath}`)) {
             return targetName;
           }
@@ -164510,7 +165260,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
             return [qnameOf(root4), ...segments.slice(featureStart).map((segment) => segment.text)].join("::");
           }
         }
-        return qnameOf(target) || nameOf2(target) || segments.map((segment) => segment.text).join("::");
+        return qnameOf(target2) || nameOf2(target2) || segments.map((segment) => segment.text).join("::");
       };
       const performedActions = depth < 8 && !(typeQ !== void 0 && seenTypes.has(typeQ)) ? effectiveMembersOf(part).filter((m) => m.$type === "PerformStmt" && !!nameOf2(m)).map((act) => {
         const pinSource = this.performTargetOf(act, index2) ?? act;
@@ -164550,7 +165300,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       });
       const emitOwnedActions = (frameOf) => {
         for (const { act, name, id: actId, pins, meta } of performedActionInfos) {
-          nodes.push({
+          target.nodes.push({
             id: actId,
             name,
             keyword: keywordFor(act),
@@ -164566,7 +165316,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         }
       };
       if (children2.length > 0 || performedActions.length > 0) {
-        frames.push({
+        target.frames.push({
           id: instanceId,
           label: effectiveNameOf(part) ?? lastSeg(instanceId),
           keyword: keywordFor(part),
@@ -164584,13 +165334,13 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         const nextSeen = typeQ ? /* @__PURE__ */ new Set([...seenTypes, typeQ]) : seenTypes;
         const childInfos = children2.map((cu) => ({ usage: cu, id: `${instanceId}::${effectiveNameOf(cu) ?? lastSeg(qnameOf(cu) || "")}` }));
         for (const { usage, id: id2 } of childInfos) {
-          renderInstance(usage, id2, instanceId, nextSeen, depth + 1, localUsage, [...localPath, effectiveNameOf(usage) ?? lastSeg(id2)]);
+          renderInstance(usage, id2, instanceId, nextSeen, depth + 1, localUsage, [...localPath, effectiveNameOf(usage) ?? lastSeg(id2)], target, false, occurrenceInherited || !isAstDescendantOrSelf(usage, part), occurrencePath);
         }
         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, part);
+        this.emitInterconnectEdges(effectiveMembersOf(part), resolver.resolve, children2, index2, uri, target.nodes, target.edges, eRef, instanceId, resolver.actionPinIds, resolver.structuralPortIds, part, occurrenceInherited, endpointProvenance);
       } else {
-        nodes.push({
+        target.nodes.push({
           id: instanceId,
           name: effectiveNameOf(part) ?? lastSeg(instanceId),
           keyword: keywordFor(part),
@@ -164605,7 +165355,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           meta: editMeta
         });
         const resolver = childResolver([], { usage: part, id: instanceId });
-        this.emitInterconnectEdges(effectiveMembersOf(part), resolver.resolve, [], index2, uri, nodes, edges, eRef, instanceId, resolver.actionPinIds, part);
+        this.emitInterconnectEdges(effectiveMembersOf(part), resolver.resolve, [], index2, uri, target.nodes, target.edges, eRef, instanceId, resolver.actionPinIds, resolver.structuralPortIds, part, occurrenceInherited, endpointProvenance);
       }
     };
     const packageOfRoot = (root4) => enclosingPackage(root4) ?? scope;
@@ -164635,18 +165385,53 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const rootInfos = [];
     for (const root4 of roots) {
       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, []);
+      const rootIsDefinition = root4.isDef === true;
+      if (rootIsDefinition)
+        definitionRootIds.set(root4, id2);
+      renderInstance(root4, id2, opts.packageFrames ? ensurePkgFrame(enclosingPackage(root4)) : void 0, /* @__PURE__ */ new Set(), 0, root4.isDef === true ? void 0 : root4, [], primaryTarget, opts.packageFrames && rootIsDefinition);
       rootInfos.push({ usage: root4, id: id2, pkg: packageOfRoot(root4) });
     }
+    for (let cursor = 0; cursor < typedPartUsages.length; cursor++) {
+      const { definition } = typedPartUsages[cursor];
+      if (definitionRootIds.has(definition))
+        continue;
+      const definitionId = qnameOf(definition) || nameOf2(definition);
+      if (!definitionId)
+        continue;
+      definitionRootIds.set(definition, definitionId);
+      renderInstance(definition, definitionId, void 0, /* @__PURE__ */ new Set(), 0, void 0, [], definitionTarget, true);
+    }
+    const linkedDefinitions = /* @__PURE__ */ new Set();
+    for (const { id: id2, definition } of typedPartUsages) {
+      const definitionId = definitionRootIds.get(definition);
+      if (!definitionId || id2 === definitionId)
+        continue;
+      const key = `${id2}\0${definitionId}`;
+      if (linkedDefinitions.has(key))
+        continue;
+      linkedDefinitions.add(key);
+      definitionTarget.edges.push({
+        id: `e${eRef.n++}`,
+        from: id2,
+        to: definitionId,
+        kind: "definedBy",
+        meta: { ivDefinedBy: true }
+      });
+    }
     if (opts.packageFrames) {
       for (const pkg of [scope, ...[...ast_utils_exports.streamAllContents(scope)].filter(isPackage)]) {
         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, pkg);
+        this.emitInterconnectEdges(membersOf(pkg), resolver.resolve, localRoots, index2, uri, nodes, edges, eRef, void 0, resolver.actionPinIds, resolver.structuralPortIds, pkg, false, endpointProvenance);
       }
     }
-    return { nodes, edges, frames };
+    const definitionLayer = definitionTarget.nodes.length > 0 || definitionTarget.edges.length > 0 || definitionTarget.frames.length > 0 ? {
+      nodes: definitionTarget.nodes,
+      edges: definitionTarget.edges,
+      ...definitionTarget.frames.length ? { frames: definitionTarget.frames } : {}
+    } : void 0;
+    return { nodes, edges, frames, definitionLayer };
   }
   // REQ-192 — Interconnection View for a single part/part-def anchor: the anchor
   // is the (non-collapsible) container frame and its internals nest inside it,
@@ -164654,7 +165439,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   buildInterconnectionView(ctx) {
     const anchor = ctx.anchor;
     const anchorId = qnameOf(anchor) || nameOf2(anchor) || "__anchor__";
-    const { nodes, edges, frames } = this.renderIvRoots(ctx, [anchor], { packageFrames: false });
+    const { nodes, edges, frames, definitionLayer } = this.renderIvRoots(ctx, [anchor], { packageFrames: false });
     if (anchor.isDef === true && frames.length === 0 && nodes.every((n2) => !n2.ports?.length && !n2.compartments?.length)) {
       return this.model("iv", anchor, [], []);
     }
@@ -164668,6 +165453,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     }
     const model = this.model("iv", anchor, nodes, edges);
     model.frames = frames;
+    if (definitionLayer)
+      model.layers = { definitions: definitionLayer };
     model.meta = { ...model.meta, unified: true, groupMode: "nested" };
     return model;
   }
@@ -164676,14 +165463,16 @@ 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(), memberOwner) {
+  emitInterconnectEdges(members, resolveEnd, parts, index2, uri, nodes, edges, eRef, frameId, actionPinIds = /* @__PURE__ */ new Set(), structuralPortIds = /* @__PURE__ */ new Set(), memberOwner, memberOwnerInherited = false, endpointProvenance = /* @__PURE__ */ new Map()) {
     const memberList2 = [...members];
+    const pendingFlows = [];
+    const firstEdge = edges.length;
     const relationshipFields = (source) => {
       let directMember = source;
       while (directMember.$container && directMember.$container !== memberOwner) {
         directMember = directMember.$container;
       }
-      const inherited = !!memberOwner && directMember.$container !== memberOwner;
+      const inherited = memberOwnerInherited || !!memberOwner && directMember.$container !== memberOwner;
       const meta = {
         ...inherited ? { ivInheritedRelation: true } : {},
         ...frameId ? { ivRelationshipOwnerId: frameId } : {}
@@ -164694,12 +165483,38 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       };
     };
     const supportsEndpoints = (kind, ids) => {
+      if (kind === "interface") {
+        return ids.length > 0 && ids.every((id2) => structuralPortIds.has(id2));
+      }
       const pinCount = ids.filter((id2) => actionPinIds.has(id2)).length;
       if (pinCount === 0)
         return true;
       return ids.length === 2 && pinCount === 2 && (kind === "flow" || kind === "binding");
     };
-    const dot = (id2, name, src) => ({ id: id2, name, keyword: "connection", isDef: false, shape: "dot", frame: frameId, source: sourceOf2(src, uri) });
+    const dot = (id2, name, src) => ({
+      id: id2,
+      name,
+      keyword: "connection",
+      isDef: false,
+      shape: "dot",
+      frame: frameId,
+      source: sourceOf2(src, uri),
+      meta: { naryConnectionHub: true }
+    });
+    const connectionUsageNodeId = (connection) => {
+      const source = sourceOf2(connection, uri);
+      const ownerId = frameId ?? (qnameOf(memberOwner ?? connection) || "iv");
+      const semanticName = frameId ? effectiveNameOf(connection) : qnameOf(connection);
+      const suffix = semanticName ?? (source ? `${source.range.start.line}_${source.range.start.character}` : `${eRef.n}`);
+      return `${ownerId}::__connection_${suffix}`;
+    };
+    const interfaceUsageNodeId = (interfaceUsage) => {
+      const source = sourceOf2(interfaceUsage, uri);
+      const ownerId = frameId ?? (qnameOf(memberOwner ?? interfaceUsage) || "iv");
+      const semanticName = frameId ? effectiveNameOf(interfaceUsage) : qnameOf(interfaceUsage);
+      const suffix = semanticName ?? (source ? `${source.range.start.line}_${source.range.start.character}` : `${eRef.n}`);
+      return `${ownerId}::__interface_${suffix}`;
+    };
     const emitConnector = (rawEnds, src, label, name, type) => {
       const resolvedEnds = rawEnds.map((end) => ({ id: resolveEnd(this.connectorEndPath(end) ?? ""), end })).filter((x) => !!x.id);
       if (resolvedEnds.length < 2)
@@ -164707,6 +165522,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       if (!supportsEndpoints("connect", resolvedEnds.map(({ id: id2 }) => id2)))
         return;
       if (resolvedEnds.length === 2) {
+        const fromNotation = this.connectorEndNotation(src, resolvedEnds[0].end, index2, 0);
+        const toNotation = this.connectorEndNotation(src, resolvedEnds[1].end, index2, 1);
         edges.push({
           id: `e${eRef.n++}`,
           from: resolvedEnds[0].id,
@@ -164716,15 +165533,20 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           type,
           isDef: false,
           label,
-          endLabelFrom: multText(resolvedEnds[0].end),
-          endLabelTo: multText(resolvedEnds[1].end),
+          endRoleFrom: fromNotation.role,
+          endLabelFrom: fromNotation.multiplicity,
+          endAdornmentFrom: fromNotation.adornment,
+          endRoleTo: toNotation.role,
+          endLabelTo: toNotation.multiplicity,
+          endAdornmentTo: toNotation.adornment,
           ...relationshipFields(src)
         });
         return;
       }
       const dotId = `__nary_${eRef.n}__`;
       nodes.push(dot(dotId, label ?? "", src));
-      for (const { id: endId, end } of resolvedEnds) {
+      for (const [ordinal, { id: endId, end }] of resolvedEnds.entries()) {
+        const notation = this.connectorEndNotation(src, end, index2, ordinal);
         edges.push({
           id: `e${eRef.n++}`,
           from: dotId,
@@ -164734,7 +165556,9 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           type,
           isDef: false,
           label,
-          endLabelTo: multText(end),
+          endRoleTo: notation.role,
+          endLabelTo: notation.multiplicity,
+          endAdornmentTo: notation.adornment,
           ...relationshipFields(src)
         });
       }
@@ -164769,21 +165593,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       } else if (m.$type === "ConnectStmt") {
         const cs = m;
         if (cs.ends?.length) {
-          const resolvedEnds = cs.ends.map((p) => ({ id: resolveEnd(this.connectorEndPath(p) ?? ""), end: p })).filter((x) => !!x.id);
-          if (resolvedEnds.length >= 2 && supportsEndpoints("connect", resolvedEnds.map(({ id: id2 }) => id2))) {
-            const dotId = `__nary_${eRef.n}__`;
-            nodes.push(dot(dotId, "", m));
-            for (const { id: endId, end } of resolvedEnds) {
-              edges.push({
-                id: `e${eRef.n++}`,
-                from: dotId,
-                to: endId,
-                kind: "connect",
-                endLabelTo: multText(end),
-                ...relationshipFields(m)
-              });
-            }
-          }
+          emitConnector(cs.ends, m);
         } else {
           const srcEnd = m.source;
           const tgtEnd = m.target;
@@ -164791,6 +165601,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           const from = resolveEnd(srcPath);
           const to = resolveEnd(this.connectorEndPath(tgtEnd) ?? "");
           if (from && to && supportsEndpoints("connect", [from, to])) {
+            const fromNotation = this.connectorEndNotation(m, srcEnd, index2, 0);
+            const toNotation = this.connectorEndNotation(m, tgtEnd, index2, 1);
             edges.push({
               id: `e${eRef.n++}`,
               from,
@@ -164798,29 +165610,19 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
               kind: "connect",
               label: this.flowItemLabel(srcPath, parts, index2),
               // REQ-179 — connector end multiplicities (`connect [1] a to [0..*] b;`)
-              endLabelFrom: multText(srcEnd),
-              endLabelTo: multText(tgtEnd),
+              endRoleFrom: fromNotation.role,
+              endLabelFrom: fromNotation.multiplicity,
+              endAdornmentFrom: fromNotation.adornment,
+              endRoleTo: toNotation.role,
+              endLabelTo: toNotation.multiplicity,
+              endAdornmentTo: toNotation.adornment,
               ...relationshipFields(m)
             });
           }
         }
       } else if (m.$type === "FlowStmt") {
-        const fm = m;
-        if (fm.flowKind === "message")
-          continue;
-        const { source, target } = this.flowStmtEnds(fm);
-        const from = resolveEnd(source ?? "");
-        const to = resolveEnd(target ?? "");
-        if (from && to && supportsEndpoints("flow", [from, to])) {
-          edges.push({
-            id: `e${eRef.n++}`,
-            from,
-            to,
-            kind: "flow",
-            label: this.flowPayloadText(fm) ?? typeText(m) ?? nameOf2(m),
-            ...relationshipFields(m)
-          });
-        }
+        if (m.isDef !== true)
+          pendingFlows.push(m);
       } else if (m.$type === "BindStmt" || m.$type === "BindingConnectorStmt" || m.$type === "BindingDecl") {
         const bn = m;
         const leftEnd = bn.left ?? bn.source;
@@ -164845,110 +165647,284 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           });
         }
       } else if (isInterfaceDecl(m) && m.isDef !== true) {
-        const clause = m.connect;
-        if (clause) {
-          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) {
+        const interfaceUsage = m;
+        if (interfaceUsage.target !== void 0 && interfaceUsage.connect === void 0) {
+          const sourcePath = [nameOf2(m) ?? "", ...interfaceUsage.srcSegs ?? []].filter(Boolean).join(".");
+          const targetPath = this.featurePath(interfaceUsage.target) ?? "";
+          const from = resolveEnd(sourcePath);
+          const to = resolveEnd(targetPath);
+          if (from && to && supportsEndpoints("interface", [from, to])) {
             edges.push({
               id: `e${eRef.n++}`,
-              from: resolvedEnds[0].id,
-              to: resolvedEnds[1].id,
+              from,
+              to,
               kind: "interface",
-              name,
-              type,
               isDef: false,
-              label,
-              endLabelFrom: multText(resolvedEnds[0].end),
-              endLabelTo: multText(resolvedEnds[1].end),
+              label: "\xABinterface\xBB",
               ...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)
-              });
+          }
+          continue;
+        }
+        const name = effectiveNameOf(m);
+        const inheritedType = this.inheritedFeatureOwnersOf(m, index2).filter((candidate) => isInterfaceDecl(candidate) && candidate.isDef !== true).map(typeText).find((candidate) => !!candidate);
+        const type = typeText(m) ?? inheritedType;
+        const usageEnds = this.effectiveConnectionUsageEndsOf(m, index2);
+        const usageId = interfaceUsageNodeId(m);
+        const usageSource = sourceOf2(m, uri);
+        const relationship = relationshipFields(m);
+        const resolvedUsageEnds = usageEnds.flatMap((end, ordinal) => {
+          const targetId = end.path ? resolveEnd(end.path) : void 0;
+          return targetId && supportsEndpoints("interface", [targetId]) ? [{ end, ordinal, targetId }] : [];
+        });
+        const inherited = relationship.meta?.ivInheritedRelation === true;
+        const visibleUsageEnds = inherited ? resolvedUsageEnds.filter(({ end, targetId }) => this.connectionUsageEndBindingMatches(end, endpointProvenance.get(targetId), frameId ? endpointProvenance.get(frameId) : void 0, index2)) : resolvedUsageEnds;
+        if (inherited && visibleUsageEnds.length === 0)
+          continue;
+        const resolvedOrdinals = new Set(visibleUsageEnds.map(({ ordinal }) => ordinal));
+        const ownerNode = frameId ? nodes.find((node) => node.id === frameId) : void 0;
+        const usageFrame = ownerNode ? ownerNode.frame : frameId;
+        const ports = usageEnds.map((end, ordinal) => {
+          const role = end.notation.role;
+          const direction = end.notation.direction === "in" || end.notation.direction === "out" || end.notation.direction === "inout" ? end.notation.direction : void 0;
+          return {
+            id: `${usageId}::__end_${ordinal}`,
+            name: role ?? `end${ordinal + 1}`,
+            type: end.notation.type,
+            direction,
+            isDef: false,
+            pin: false,
+            source: usageSource,
+            meta: {
+              // The shared renderer uses this presentation marker for
+              // the outline-coloured dot and its single outward dock.
+              connectionEndPin: true,
+              interfaceEndPort: true,
+              connectionUsageId: usageId,
+              interfaceUsageId: usageId,
+              connectionEndOrdinal: ordinal,
+              ...role ? { connectionEndRole: role } : {},
+              ...resolvedOrdinals.has(ordinal) ? { connectionEndBound: true } : {},
+              ...end.notation.multiplicity ? { connectionEndMultiplicity: end.notation.multiplicity } : {},
+              ...end.notation.adornment ? { connectionEndAdornment: end.notation.adornment } : {}
             }
-          } 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)
-            });
+          };
+        });
+        const carriedFlows = this.carriedFlowsOf(m, usageEnds, index2, uri);
+        nodes.push({
+          id: usageId,
+          name: name ?? ANONYMOUS_INTERFACE_NAME,
+          keyword: "interface",
+          isDef: false,
+          shape: "box",
+          type,
+          multiplicity: multText(m),
+          ports,
+          ...usageFrame ? { frame: usageFrame } : {},
+          compartments: this.withCarriedFlowRows(this.compartmentsFor(m, uri, index2), carriedFlows),
+          source: usageSource,
+          meta: {
+            ...relationship.meta ?? {},
+            interfaceUsage: true,
+            ...name ? { explicitRelationshipName: name } : {},
+            ...flowDecorationMeta(carriedFlows)
           }
+        });
+        for (const { end, ordinal, targetId } of visibleUsageEnds) {
+          const role = end.notation.role;
+          edges.push({
+            id: `e${eRef.n++}`,
+            from: ports[ordinal].id,
+            to: targetId,
+            kind: "interface",
+            name,
+            type,
+            isDef: false,
+            endRoleFrom: role,
+            endLabelFrom: end.notation.multiplicity,
+            endAdornmentFrom: end.notation.adornment,
+            source: relationship.source,
+            meta: {
+              ...relationship.meta ?? {},
+              interfaceUsageEnd: true,
+              interfaceUsageId: usageId,
+              connectionUsageId: usageId,
+              connectionEndOrdinal: ordinal,
+              ...role ? { connectionEndRole: role } : {}
+            }
+          });
         }
       } else if (isConnectionDecl(m) && m.isDef !== true) {
-        const clause = m.connect;
-        if (!clause)
+        const name = effectiveNameOf(m);
+        const inheritedType = this.inheritedFeatureOwnersOf(m, index2).filter((candidate) => isConnectionDecl(candidate) && candidate.isDef !== true).map(typeText).find((candidate) => !!candidate);
+        const type = typeText(m) ?? inheritedType;
+        const usageEnds = this.effectiveConnectionUsageEndsOf(m, index2);
+        const usageId = connectionUsageNodeId(m);
+        const usageSource = sourceOf2(m, uri);
+        const relationship = relationshipFields(m);
+        const resolvedUsageEnds = usageEnds.flatMap((end, ordinal) => {
+          const targetId = end.path ? resolveEnd(end.path) : void 0;
+          return targetId && supportsEndpoints("connect", [targetId]) ? [{ end, ordinal, targetId }] : [];
+        });
+        const inherited = relationship.meta?.ivInheritedRelation === true;
+        const visibleUsageEnds = inherited ? resolvedUsageEnds.filter(({ end, targetId }) => this.connectionUsageEndBindingMatches(end, endpointProvenance.get(targetId), frameId ? endpointProvenance.get(frameId) : void 0, index2)) : resolvedUsageEnds;
+        if (inherited && visibleUsageEnds.length === 0) {
           continue;
-        const name = nameOf2(m);
-        const type = typeText(m);
-        const label = name ?? type;
-        if (clause.ends?.length) {
-          const resolvedEnds = clause.ends.map((p) => ({ id: resolveEnd(this.connectorEndPath(p) ?? ""), end: p })).filter((x) => !!x.id);
-          if (resolvedEnds.length >= 2 && supportsEndpoints("connect", resolvedEnds.map(({ id: id2 }) => id2))) {
-            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: "connect",
-                name,
-                type,
-                isDef: false,
-                label,
-                endLabelTo: multText(end),
-                ...relationshipFields(m)
-              });
+        }
+        const resolvedOrdinals = new Set(visibleUsageEnds.map(({ ordinal }) => ordinal));
+        const ownerNode = frameId ? nodes.find((node) => node.id === frameId) : void 0;
+        const usageFrame = ownerNode ? ownerNode.frame : frameId;
+        const ports = usageEnds.map((end, ordinal) => {
+          const role = end.notation.role;
+          const direction = end.notation.direction === "in" || end.notation.direction === "out" || end.notation.direction === "inout" ? end.notation.direction : void 0;
+          return {
+            id: `${usageId}::__end_${ordinal}`,
+            name: role ?? `end${ordinal + 1}`,
+            type: end.notation.type,
+            direction,
+            isDef: false,
+            pin: true,
+            source: usageSource,
+            meta: {
+              connectionEndPin: true,
+              connectionUsageId: usageId,
+              connectionEndOrdinal: ordinal,
+              ...role ? { connectionEndRole: role } : {},
+              ...resolvedOrdinals.has(ordinal) ? { connectionEndBound: true } : {},
+              ...end.notation.multiplicity ? { connectionEndMultiplicity: end.notation.multiplicity } : {},
+              ...end.notation.adornment ? { connectionEndAdornment: end.notation.adornment } : {}
             }
+          };
+        });
+        const carriedFlows = this.carriedFlowsOf(m, usageEnds, index2, uri);
+        nodes.push({
+          id: usageId,
+          name: name ?? "connection",
+          keyword: "connection",
+          isDef: false,
+          shape: "box",
+          type,
+          ports,
+          ...usageFrame ? { frame: usageFrame } : {},
+          compartments: this.withCarriedFlowRows(this.compartmentsFor(m, uri, index2), carriedFlows),
+          source: usageSource,
+          meta: {
+            ...relationship.meta ?? {},
+            connectionUsage: true,
+            ...name ? { explicitRelationshipName: name } : {},
+            ...flowDecorationMeta(carriedFlows)
           }
-        } else {
-          const from = resolveEnd(this.connectorEndPath(clause.source) ?? "");
-          const to = resolveEnd(this.connectorEndPath(clause.target) ?? "");
-          if (from && to && supportsEndpoints("connect", [from, to])) {
-            edges.push({
-              id: `e${eRef.n++}`,
-              from,
-              to,
-              kind: "connect",
-              name,
-              type,
-              isDef: false,
+        });
+        for (const { end, ordinal, targetId } of visibleUsageEnds) {
+          const role = end.notation.role;
+          edges.push({
+            id: `e${eRef.n++}`,
+            from: ports[ordinal].id,
+            to: targetId,
+            kind: "connect",
+            name,
+            type,
+            isDef: false,
+            endRoleFrom: role,
+            endLabelFrom: end.notation.multiplicity,
+            endAdornmentFrom: end.notation.adornment,
+            source: relationship.source,
+            meta: {
+              ...relationship.meta ?? {},
+              connectionUsageEnd: true,
+              connectionUsageId: usageId,
+              connectionEndOrdinal: ordinal,
+              ...role ? { connectionEndRole: role } : {}
+            }
+          });
+        }
+      }
+    }
+    const resolveFlowEnd = (pathText) => {
+      const direct = resolveEnd(pathText);
+      if (direct)
+        return { id: direct, docked: false };
+      const parts2 = pathText.split(/(::|\.)/u).filter((part) => part.length > 0);
+      for (let length2 = parts2.length - 2; length2 >= 1; length2 -= 2) {
+        const carrier = resolveEnd(parts2.slice(0, length2).join(""));
+        if (carrier)
+          return { id: carrier, docked: true };
+      }
+      return void 0;
+    };
+    const transportFor = (from, to) => edges.slice(firstEdge).find((edge) => (edge.kind === "connect" || edge.kind === "interface") && (edge.from === from && edge.to === to || edge.from === to && edge.to === from));
+    const flowUsageNodeId = (flow) => {
+      const src = sourceOf2(flow, uri);
+      const ownerId = frameId ?? (qnameOf(memberOwner ?? flow) || "iv");
+      const suffix = (frameId ? flowStmtName(flow) : qnameOf(flow)) ?? (src ? `${src.range.start.line}_${src.range.start.character}` : `${eRef.n}`);
+      return `${ownerId}::__flow_${suffix}`;
+    };
+    for (const m of pendingFlows) {
+      const fm = m;
+      const message = fm.flowKind === "message";
+      const keyword = flowKeyword(fm);
+      const { source, target } = this.flowStmtEnds(fm);
+      const flowName = flowStmtName(m);
+      const sourceEnd = message ? void 0 : resolveFlowEnd(source ?? "");
+      const targetEnd = message ? void 0 : resolveFlowEnd(target ?? "");
+      const selfDock = sourceEnd !== void 0 && sourceEnd.id === targetEnd?.id && (sourceEnd.docked || targetEnd.docked);
+      const from = selfDock ? void 0 : sourceEnd?.id;
+      const to = selfDock ? void 0 : targetEnd?.id;
+      const transferred = flowTransferredFeature({ source, target });
+      const label = this.flowPayloadText(fm) ?? typeText(m) ?? transferred ?? flowName;
+      if (from && to && supportsEndpoints("flow", [from, to])) {
+        const transport = transportFor(from, to);
+        if (transport) {
+          const decorations = Array.isArray(transport.meta?.flowDecorations) ? transport.meta.flowDecorations : [];
+          transport.meta = {
+            ...transport.meta ?? {},
+            flowDecorations: [...decorations, {
+              keyword,
               label,
-              endLabelFrom: multText(clause.source),
-              endLabelTo: multText(clause.target),
-              ...relationshipFields(m)
-            });
-          }
+              ...flowName ? { name: flowName } : {},
+              reversed: transport.from === to,
+              source: sourceOf2(m, uri)
+            }]
+          };
+          continue;
         }
+        edges.push({
+          id: `e${eRef.n++}`,
+          from,
+          to,
+          kind: "flow",
+          label,
+          ...relationshipFields(m)
+        });
+        continue;
       }
+      if (message || !flowName)
+        continue;
+      const ownerNode = frameId ? nodes.find((node) => node.id === frameId) : void 0;
+      const ends = [
+        ...source ? [{ text: `from ${source}` }] : [],
+        ...target ? [{ text: `to ${target}` }] : []
+      ];
+      nodes.push({
+        id: flowUsageNodeId(m),
+        name: flowName,
+        keyword,
+        isDef: false,
+        shape: "box",
+        type: typeText(m),
+        multiplicity: multText(m),
+        ...ownerNode ? { frame: ownerNode.frame } : frameId ? { frame: frameId } : {},
+        compartments: [
+          ...label ? [{ title: "payload", items: [{ text: label }] }] : [],
+          ...ends.length ? [{ title: "ends", items: ends }] : []
+        ],
+        source: sourceOf2(m, uri),
+        meta: {
+          ...relationshipFields(m).meta ?? {},
+          flowUsage: true,
+          explicitRelationshipName: flowName
+        }
+      });
     }
   }
   // ── iv overview (REQ-360) — recursive nested Interconnection View over a
@@ -164997,9 +165973,11 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     if (roots.length === 0) {
       roots = all.filter((d) => isDefPart(d) && !insideAPart(d) && !insideAnOccurrence(d) && hasInternalParts(d)).sort(byName);
     }
-    const { nodes, edges, frames } = this.renderIvRoots(ctx, roots, { packageFrames: true });
+    const { nodes, edges, frames, definitionLayer } = this.renderIvRoots(ctx, roots, { packageFrames: true });
     const model = this.model("iv", scope, nodes, edges);
     model.frames = frames;
+    if (definitionLayer)
+      model.layers = { definitions: definitionLayer };
     model.meta = { ...model.meta, overview: true, groupMode: "nested" };
     model.root = { ...model.root, keyword: "package", name: nameOf2(scope) ?? model.root.name };
     if (nodes.length === 0 && frames.length === 0) {
@@ -165011,7 +165989,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // (non-package) single view of `kind`; each renders as one overview tile.
   collectOverviewAnchors(scope, kind, index2) {
     const all = [...ast_utils_exports.streamAllContents(scope)];
-    const isNaturalAnchor = (n2) => !isPackage(n2) && !isDocument(n2) && (this.hasAnchorContent(n2, kind, index2) || kind === "afv" && this.isAfvScaffoldAnchor(n2)) && (kind !== "sv" || this.hasSequenceInteraction(n2));
+    const isNaturalAnchor = (n2) => !isPackage(n2) && !isDocument(n2) && ((kind === "gev" ? this.hasGeometryOverviewLayout(n2, index2) : this.hasAnchorContent(n2, kind, index2)) || kind === "afv" && this.isAfvScaffoldAnchor(n2)) && (kind !== "sv" || this.hasSequenceInteraction(n2));
     const naturalAnchors = all.filter(isNaturalAnchor);
     const hasNaturalDescendant = (candidate) => naturalAnchors.some((natural) => {
       for (let cur = natural.$container; cur && cur !== scope; cur = cur.$container) {
@@ -165072,7 +166050,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const scopeQ = qnameOf(ctx.anchor);
     const collected = this.collectOverviewAnchors(ctx.anchor, kind, ctx.index).sort((a2, b) => (qnameOf(a2) || nameOf2(a2) || "").localeCompare(qnameOf(b) || nameOf2(b) || ""));
     const sequenceScaffold = kind === "sv" && this.nestedUsages(ctx.anchor, isPartDecl).some((n2) => nameOf2(n2) !== void 0);
-    const anchors = collected.length > 0 ? collected : kind === "gev" || sequenceScaffold ? [ctx.anchor] : [];
+    const useScopeFallback = kind === "gev" ? this.hasPlacedGeometryObject(ctx.anchor, ctx.index) : sequenceScaffold;
+    const anchors = collected.length > 0 ? collected : useScopeFallback ? [ctx.anchor] : [];
     const nodes = [];
     const edges = [];
     const frames = [];
@@ -166307,9 +167286,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           const to = resolvePin(ends.target, occurrenceContext);
           if (from && to) {
             const kind = fm.succession === true ? "successionFlow" : "flow";
-            const sourceFeature = ends.source ? lastSeg(ends.source) : void 0;
-            const targetFeature = ends.target ? lastSeg(ends.target) : void 0;
-            const transferredFeature = sourceFeature === targetFeature ? sourceFeature : sourceFeature ?? targetFeature;
+            const transferredFeature = flowTransferredFeature(ends);
             edges.push({
               id: `e${e++}`,
               from,
@@ -168024,18 +169001,31 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       geo.sizeZ = Math.abs(sizeZ);
     if (radius !== void 0)
       geo.radius = Math.abs(radius);
-    const yaw = state.fromFrame ? yawOf(state.world) : 0;
-    if (local.rot !== void 0)
+    const localYaw = local.rot === void 0 ? void 0 : rotationTransform([0, 0, 1], local.rot);
+    const orientedWorld = localYaw ? composeTransforms(state.world, localYaw) : state.world;
+    const yaw = yawOf(orientedWorld);
+    if (!state.fromFrame && local.rot !== void 0)
       geo.rot = local.rot;
     else if (yaw !== void 0 && yaw !== 0)
       geo.rot = yaw;
-    let approx = state.approx;
-    if (yaw === void 0)
-      approx ??= "the composed frame rotates this object out of the upright axis; its position is exact, its orientation is not depicted";
+    if (state.fromFrame && !isUnrotated(orientedWorld)) {
+      const r = orientedWorld.r.map(roundGeo);
+      geo.orientation = [
+        r[0],
+        r[1],
+        r[2],
+        r[3],
+        r[4],
+        r[5],
+        r[6],
+        r[7],
+        r[8]
+      ];
+    }
     if (state.fromFrame)
       geo.frame = true;
-    if (approx)
-      geo.approx = approx;
+    if (state.approx)
+      geo.approx = state.approx;
     return geo;
   }
   // issue #107 — a node's OWN placement relative to its parent frame: the
@@ -168128,7 +169118,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return {
         present: true,
         transform: translationTransform(origin),
-        approx: reoriented ? "its frame declares basisDirections; the position is exact, the re-orientation is not depicted" : void 0,
+        approx: reoriented ? "its frame declares basisDirections that this workspace cannot evaluate numerically" : void 0,
         unit,
         sourcePath
       };
@@ -168685,9 +169675,10 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   portsOf(node, index2, uri, ownerId, localUsage) {
     const ports = [];
     const map3 = /* @__PURE__ */ new Map();
+    const origins = /* @__PURE__ */ new Map();
     const visibleNames = /* @__PURE__ */ new Set();
     const usageName = effectiveNameOf(node);
-    const makePort = (portNode, inheritedFromType, parentPortId, parentPath) => {
+    const makePort = (portNode, inheritedFromType, parentPortId, parentPath, parentOrigin = []) => {
       const pn = effectiveNameOf(portNode);
       if (!pn)
         return void 0;
@@ -168772,7 +169763,9 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       if (usageName)
         map3.set(`${usageName}.${rel2}`, portId);
       map3.set(`${ownerId}.${rel2}`, portId);
-      return { port, portTypeDef, inheritedOwners };
+      const origin = [...parentOrigin, portNode];
+      origins.set(portId, origin);
+      return { port, portTypeDef, inheritedOwners, origin };
     };
     const addNested = (portNode, made, inheritedFromType, path10, depth, seenTypes) => {
       if (depth > NESTED_PORT_MAX_DEPTH)
@@ -168783,18 +169776,20 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const nestedSeen = /* @__PURE__ */ new Set();
       const nestedSources = [
         // declared in this port usage's body: as local as its parent is
-        ...membersOf(portNode).map((member) => ({ member, inherited: inheritedFromType })),
+        ...membersOf(portNode).map((member) => ({ member, inherited: inheritedFromType, source: portNode })),
         // every effective owner contributes its body, nearest first
-        ...!repeatedType ? made.inheritedOwners.flatMap((owner) => membersOf(owner).map((member) => ({ member, inherited: true }))) : []
+        ...!repeatedType ? made.inheritedOwners.flatMap((owner) => membersOf(owner).map((member) => ({ member, inherited: true, source: owner }))) : []
       ];
-      for (const { member, inherited } of nestedSources) {
+      for (const { member, inherited, source } of nestedSources) {
         if (!isPortDecl(member) || member.isDef === true)
           continue;
+        if (inherited && this.isInheritedLibraryBackboneFeature(source, member, index2))
+          continue;
         const nn = effectiveNameOf(member);
         if (!nn || nestedSeen.has(nn))
           continue;
         nestedSeen.add(nn);
-        const child = makePort(member, inherited, made.port.id, path10);
+        const child = makePort(member, inherited, made.port.id, path10, made.origin);
         if (!child)
           continue;
         ports.push(child.port);
@@ -168816,11 +169811,12 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       if (isPortDecl(m) && m.isDef !== true)
         addPort(m, false);
     for (const inherited of this.inheritedFeatureOwnersOf(node, index2)) {
-      for (const m of membersOf(inherited))
-        if (isPortDecl(m) && m.isDef !== true)
+      for (const m of membersOf(inherited)) {
+        if (isPortDecl(m) && m.isDef !== true && !this.isInheritedLibraryBackboneFeature(inherited, m, index2))
           addPort(m, true);
+      }
     }
-    return { ports, map: map3 };
+    return { ports, map: map3, origins };
   }
   // REQ-100, issue #132 — the effective directions of a port type's directed
   // features, following the specialization chain and flipping `in`↔`out` across
@@ -168986,7 +169982,9 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       add("ports", usages(isPortDecl).map((m) => item(m)));
       add("parts", usages(isPartDecl).filter(notPortion).map((m) => item(m)));
     }
+    add("connections", members.filter((member) => isConnectionDecl(member) && member.isDef !== true && isOrdinaryMember(member)).map((member) => item(member, this.featureText(member) || "(anonymous connection)")));
     add("interfaces", members.filter((m) => isInterfaceDecl(m) && m.isDef !== true && isOrdinaryMember(m)).map((m) => item(m, this.interfaceRowText(m))));
+    add("flows", members.filter((m) => m.$type === "FlowStmt" && m.isDef !== true && isOrdinaryMember(m)).map((m) => item(m, this.flowRowText(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)));
@@ -169101,25 +170099,6 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       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;
@@ -169642,91 +170621,6 @@ function outlineGroupForType(astType) {
   return CATEGORY_TO_OUTLINE_GROUP[categoryForType(astType)] ?? "structure";
 }
 
-// ../language-server/out/src/platform/platform.js
-var current;
-function setPlatform(platform) {
-  current = platform;
-}
-function getPlatform() {
-  if (!current)
-    throw new Error("SysML: no platform installed - the entry point must call setPlatform() first.");
-  return current;
-}
-function hasPlatform() {
-  return current !== void 0;
-}
-
-// ../language-server/out/src/services/library-index-manager.js
-var SysmlIndexManager = class extends DefaultIndexManager {
-  constructor(services) {
-    super(services);
-  }
-  // REQ-075, REQ-383 — `libraryRoot` is a URI and the concrete file URIs come
-  // from the platform, because the two hosts index the same library under
-  // different schemes (`file:` on the desktop, `sysml-lib:` in a worker).
-  loadPrecomputedLibraryIndex(index2, libraryRoot) {
-    const platform = getPlatform();
-    let symbolCount = 0;
-    for (const file of index2.files) {
-      const documentUri = platform.libraryUri(libraryRoot, file.path);
-      const descriptions = file.symbols.map((symbol) => this.deserializeSymbol(symbol, documentUri));
-      const uri = documentUri.toString();
-      this.symbolIndex.set(uri, descriptions);
-      this.symbolByTypeIndex.clear(uri);
-      symbolCount += descriptions.length;
-    }
-    return symbolCount;
-  }
-  deserializeSymbol(symbol, documentUri) {
-    return {
-      name: symbol.name,
-      type: symbol.type,
-      path: symbol.path,
-      documentUri,
-      nameSegment: symbol.nameSegment,
-      selectionSegment: symbol.selectionSegment,
-      // REQ-068 — preserve declared visibility for wildcard re-export.
-      ...symbol.isPrivate ? { isPrivate: true } : {},
-      ...symbol.visibility ? { visibility: symbol.visibility } : {},
-      // issue #152 — a re-exported alias is not owned nesting.
-      ...symbol.derivedKind ? { derivedKind: symbol.derivedKind } : {},
-      // REQ-242 — issue #103 — keeps type completion to definitions.
-      ...symbol.isUsage ? { isUsage: true } : {}
-    };
-  }
-};
-function isSysmlIndexManager(value) {
-  return typeof value.loadPrecomputedLibraryIndex === "function";
-}
-var libraryRoots = /* @__PURE__ */ new Set();
-var ROOT_SEPARATOR = "\0";
-function normalizeLibraryPath(p) {
-  return p.replace(/\\/gu, "/").replace(/\/+$/u, "").toLowerCase();
-}
-function registerLibraryRoot(root4) {
-  const uri = typeof root4 === "string" ? root4.length > 0 ? URI2.file(root4) : void 0 : root4;
-  if (!uri)
-    return;
-  libraryRoots.add(`${uri.scheme}${ROOT_SEPARATOR}${normalizeLibraryPath(uri.path)}`);
-}
-function isInsideDir(fsPath, dir) {
-  return fsPath === dir || fsPath.startsWith(`${dir}/`);
-}
-function isStandardLibraryUri(uri) {
-  const fsPath = normalizeLibraryPath(uri.path);
-  for (const entry of libraryRoots) {
-    const separator = entry.indexOf(ROOT_SEPARATOR);
-    if (entry.slice(0, separator) !== uri.scheme)
-      continue;
-    if (isInsideDir(fsPath, entry.slice(separator + 1)))
-      return true;
-  }
-  return fsPath.split("/").some((segment) => segment === "sysml.library");
-}
-function isLibraryDocument(doc) {
-  return doc.isLibraryDocument === true || isStandardLibraryUri(doc.uri);
-}
-
 // ../language-server/out/src/services/document-symbol-provider.js
 var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([":>", "specializes"]);
 var REDEFINITION_KINDS = /* @__PURE__ */ new Set([":>>", "redefines"]);
@@ -176575,7 +177469,7 @@ ${baseIndent}}`;
       return;
     const expected = interfaceEndTypes(definition);
     const connect = decl.connect;
-    const written = [connect?.source, connect?.target];
+    const written = connect?.ends?.length ? connect.ends : [connect?.source, connect?.target];
     if (expected.length !== written.length)
       return;
     for (let position = 0; position < written.length; position += 1) {
@@ -182522,7 +183416,9 @@ 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;
+var CONNECTION_END_GLYPH_SIZE = 12;
 function endpointGlyphSize(endpoint) {
+  if (endpoint.meta?.connectionEndPin === true) return CONNECTION_END_GLYPH_SIZE;
   return endpoint.pin ? ACTION_PIN_GLYPH_SIZE : PORT_GLYPH_SIZE;
 }
 var NESTED_PORT_GAP = 8;
@@ -182643,9 +183539,9 @@ function portDockSides(side) {
 }
 var PORT_MOVE_STRIP_ALONG = 24;
 var PORT_CONNECT_DOT_HIT = 10;
-function portInteractionStrip(rect, side) {
+function portInteractionStrip(rect, side, singleOutwardHandle = false) {
   const vertical = side === "left" || side === "right";
-  const across = Math.max(1, rect.across - PORT_CONNECT_DOT_HIT);
+  const across = singleOutwardHandle ? rect.across : Math.max(1, rect.across - PORT_CONNECT_DOT_HIT);
   const run = Math.max(PORT_MOVE_STRIP_ALONG, rect.along);
   return {
     cx: rect.cx,
@@ -182731,6 +183627,10 @@ function sideLength(side, w, h, topReserve = 0) {
 }
 var SENDACCEPT_NOTCH = 14;
 var CIRCULAR_CONTROL_RADII = {
+  // REQ-192 - the n-ary connection hub is the same kind of fixed circular
+  // canvas control as an AFV start node. Its wrapper, handles, saved size,
+  // and painted outline therefore share one exact radius.
+  dot: CONNECTION_END_GLYPH_SIZE / 2,
   initial: 6,
   final: 8,
   terminate: 8
@@ -182954,6 +183854,15 @@ function gvModeEdges(model, mode) {
 function isGvUsageNode(n2) {
   return n2.meta?.gvUsage === true;
 }
+function isConnectionDefinitionHub(n2) {
+  return n2.meta?.connectionDefinitionHub === true;
+}
+function isGraphicalConnectionDefinitionCard(n2) {
+  return n2.meta?.connectionDefinitionGraphical === true && n2.meta?.connectionDefinitionHub !== true && n2.meta?.connectionDefinitionElaboration !== true;
+}
+function isGraphicalConnectionDefinitionEdge(edge) {
+  return edge.meta?.connectionDefinitionGraphical === true;
+}
 var GV_BOXED_USAGE_COMPARTMENTS = /* @__PURE__ */ new Set(["parts", "occurrences", "timeslices", "snapshots", "individuals"]);
 function stripBoxedUsageCompartments(nodes) {
   let changed = false;
@@ -182970,11 +183879,16 @@ function applyGvMode(model, mode) {
   if (model.kind !== "gv") return model;
   const edges = gvModeEdges(model, mode);
   if (mode === "group") {
-    const nodes2 = model.nodes.filter((n2) => !isGvUsageNode(n2));
+    const nodes2 = model.nodes.filter((n2) => !isGvUsageNode(n2) && !isConnectionDefinitionHub(n2));
     return { ...model, nodes: nodes2, edges };
   }
-  const nodes = stripBoxedUsageCompartments(model.nodes);
-  return nodes === model.nodes && edges === model.edges ? model : { ...model, nodes, edges };
+  const cardIsVisible = (node) => !isGraphicalConnectionDefinitionCard(node);
+  const graphicalNodes = model.nodes.every(cardIsVisible) ? model.nodes : model.nodes.filter(cardIsVisible);
+  const nodes = stripBoxedUsageCompartments(graphicalNodes);
+  const nodeIds = new Set(nodes.map((node) => node.id));
+  const edgeIsVisible = (edge) => nodeIds.has(edge.from) && nodeIds.has(edge.to);
+  const visibleEdges = edges.every(edgeIsVisible) ? edges : edges.filter(edgeIsVisible);
+  return nodes === model.nodes && visibleEdges === model.edges ? model : { ...model, nodes, edges: visibleEdges };
 }
 var GV_CATEGORIES = [
   { key: "package", label: "Packages" },
@@ -182994,6 +183908,7 @@ var GV_CATEGORIES = [
 ];
 function gvNodeCategory(node) {
   if (node.shape === "package") return "package";
+  if (isConnectionDefinitionHub(node)) return "interface";
   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();
   if (k === "" || k === "def") return "item";
@@ -183035,13 +183950,13 @@ function withoutOrphanedAnnotations(original, nodes, edges) {
 function applyGvFilters(model, hidden) {
   if (model.kind !== "gv" || hidden.size === 0) return model;
   const nodes = model.nodes.filter((n2) => n2.shape === "package" || !hidden.has(gvNodeCategory(n2)));
-  if (nodes.length === model.nodes.length) return model;
   const keptIds = /* @__PURE__ */ new Set();
   for (const n2 of nodes) {
     keptIds.add(n2.id);
     for (const p of n2.ports ?? []) keptIds.add(p.id);
   }
-  const edges = model.edges.filter((e) => keptIds.has(e.from) && keptIds.has(e.to));
+  const edges = model.edges.filter((e) => !(hidden.has("interface") && isGraphicalConnectionDefinitionEdge(e)) && keptIds.has(e.from) && keptIds.has(e.to));
+  if (nodes.length === model.nodes.length && edges.length === model.edges.length) return model;
   return { ...model, nodes: withoutOrphanedAnnotations(model, nodes, edges), edges };
 }
 var PAD = 10;
@@ -183127,6 +184042,13 @@ function compartmentWidth(node) {
   return w;
 }
 function nodeForCanvas(node) {
+  if (node.meta?.connectionUsage === true || node.meta?.interfaceUsage === true) {
+    const compartments2 = node.compartments?.filter((compartment) => compartment.title === "doc" || compartment.title === "flows");
+    return {
+      ...node,
+      compartments: compartments2?.length ? compartments2 : void 0
+    };
+  }
   if (!/\bconstraint(?:\s+def)?$/u.test(node.keyword.trim().toLowerCase())) return node;
   const compartments = node.compartments?.filter((compartment) => compartment.title !== "expression");
   return {
@@ -183164,13 +184086,12 @@ function nodeSize(node, direction) {
     // connector attaching at the node edge meets the visible circle.
     case "initial":
     case "final":
+    case "dot":
       return circularControlSize(node.shape);
     // OMG SysML v2.1 Part 1, Table 15: the terminate control node is an
     // unlabeled circled X, regardless of its optional semantic target.
     case "terminate":
       return circularControlSize(node.shape);
-    case "dot":
-      return { w: 14, h: 14 };
     case "decision":
     case "merge":
       return { w: Math.max(64, Math.ceil((twKind(node.name) + 8) / 0.7)), h: 48 };
@@ -183210,9 +184131,10 @@ function nodeSize(node, direction) {
   );
   const featureH = nodeFeatureCompartmentReserve(node);
   const compactContainer = node.meta?.internalsHidden === true;
-  const portRunHeight = portRows ? compactContainer ? portRows * 24 + 8 : 40 + portRows * 24 + 8 : 0;
+  const connectionUsage = node.meta?.connectionUsage === true || node.meta?.interfaceUsage === true;
+  const portRunHeight = connectionUsage ? portRows ? portRows * 18 + 6 : 0 : portRows ? compactContainer ? portRows * 24 + 8 : 40 + portRows * 24 + 8 : 0;
   const bodyH = Math.max(
-    BOX_H,
+    connectionUsage ? 42 : BOX_H,
     featureH === 0 ? NODE_COMPARTMENT_TOP + compartmentHeight(node) : 0,
     portRunHeight,
     portedSideLength(ph, "left"),
@@ -183437,6 +184359,18 @@ function assignPortHandles(ports, overrides, ownerShape) {
   for (const parent of topHandles) placeChildren(parent);
   return [...topHandles, ...nestedHandles];
 }
+var CONNECTION_BLOCK_GEOMETRY_VERSION = 2;
+function connectionUsageHeightOverride(node, height, connectionBlockVersion) {
+  if (height === void 0 || node?.meta?.connectionUsage !== true) return height;
+  if ((connectionBlockVersion ?? 0) >= CONNECTION_BLOCK_GEOMETRY_VERSION) return height;
+  const handles = assignPortHandles(node.ports, void 0, node.shape);
+  const rows = Math.max(
+    handles.filter((handle) => handle.side === "left").length,
+    handles.filter((handle) => handle.side === "right").length
+  );
+  const oldAutomaticHeight = Math.max(BOX_H, rows ? rows * 24 + 48 : 0);
+  return height === oldAutomaticHeight ? void 0 : height;
+}
 function sizeWithOverride(base, o, minimum = { w: 48, h: 24 }) {
   return {
     w: o?.w !== void 0 ? Math.max(minimum.w, o.w) : base.w,
@@ -183553,11 +184487,38 @@ function applyCaseDefs(model, show) {
   };
 }
 var BEHAVIOR_FILTER_DEFAULTS = {
-  afv: { parts: true, performers: true, ports: true, defs: true, definedBy: true, actions: true },
-  stv: { parts: false, performers: true, ports: true, defs: true, definedBy: true, actions: true },
+  afv: {
+    parts: true,
+    performers: true,
+    ports: true,
+    defs: true,
+    definedBy: true,
+    actions: true,
+    connectionBoxes: true,
+    interfaceBoxes: true
+  },
+  stv: {
+    parts: false,
+    performers: true,
+    ports: true,
+    defs: true,
+    definedBy: true,
+    actions: true,
+    connectionBoxes: true,
+    interfaceBoxes: true
+  },
   // The Interconnection View is a STRUCTURE view; explicitly performed actions
   // are an optional behavior overlay and therefore the first layer to drop.
-  iv: { parts: true, performers: true, ports: true, defs: true, definedBy: true, actions: true }
+  iv: {
+    parts: true,
+    performers: true,
+    ports: true,
+    defs: true,
+    definedBy: true,
+    actions: true,
+    connectionBoxes: true,
+    interfaceBoxes: true
+  }
 };
 function behaviorFilterDefaults(kind) {
   return BEHAVIOR_FILTER_DEFAULTS[kind === "stv" ? "stv" : kind === "iv" ? "iv" : "afv"];
@@ -183570,9 +184531,164 @@ function restoreBehaviorFilters(kind, saved) {
   return restored;
 }
 var FILTERED_KINDS = /* @__PURE__ */ new Set(["afv", "stv", "iv"]);
+function withVisibleDefinitionLayer(model) {
+  const layer = model.layers?.definitions;
+  if (!layer) return model;
+  return {
+    ...model,
+    nodes: [...model.nodes, ...layer.nodes],
+    edges: [...model.edges, ...layer.edges],
+    frames: [...model.frames ?? [], ...layer.frames ?? []],
+    layers: void 0
+  };
+}
+function explicitRelationshipBindings(usage, model) {
+  return (usage.ports ?? []).flatMap((port, fallbackOrdinal) => {
+    const edge = model.edges.find((candidate) => candidate.from === port.id || candidate.to === port.id);
+    if (!edge) return [];
+    const pinAtFrom = edge.from === port.id;
+    const ordinal = typeof port.meta?.connectionEndOrdinal === "number" ? port.meta.connectionEndOrdinal : fallbackOrdinal;
+    const role = typeof port.meta?.connectionEndRole === "string" ? port.meta.connectionEndRole : pinAtFrom ? edge.endRoleFrom : edge.endRoleTo;
+    return [{
+      edge,
+      externalId: pinAtFrom ? edge.to : edge.from,
+      ordinal,
+      role,
+      multiplicity: pinAtFrom ? edge.endLabelFrom : edge.endLabelTo,
+      adornment: pinAtFrom ? edge.endAdornmentFrom : edge.endAdornmentTo
+    }];
+  }).sort((left, right) => left.ordinal - right.ordinal);
+}
+function hideExplicitRelationshipBoxes(model, relationship) {
+  if (model.kind !== "iv") return model;
+  const usages = model.nodes.filter((node) => relationship === "connection" ? node.meta?.connectionUsage === true : node.meta?.interfaceUsage === true);
+  if (usages.length === 0) return model;
+  const usageIds = new Set(usages.map((usage) => usage.id));
+  const annotatedUsageIds = /* @__PURE__ */ new Set();
+  for (const edge of model.edges) {
+    if (edge.kind !== "annotation") continue;
+    if (usageIds.has(edge.from)) annotatedUsageIds.add(edge.from);
+    if (usageIds.has(edge.to)) annotatedUsageIds.add(edge.to);
+  }
+  const projections = usages.map((usage) => ({
+    usage,
+    bindings: explicitRelationshipBindings(usage, model),
+    endCount: usage.ports?.length ?? 0
+  }));
+  const blocksCompaction = ({ usage, endCount }) => (nodeForCanvas(usage).compartments ?? []).some((compartment) => endCount !== 2 || compartment.title !== "flows");
+  const retainedIds = new Set(projections.filter((projection2) => blocksCompaction(projection2) || annotatedUsageIds.has(projection2.usage.id) || projection2.endCount < 2 || projection2.bindings.length !== projection2.endCount).map(({ usage }) => usage.id));
+  const hiddenIds = /* @__PURE__ */ new Set();
+  for (const { usage } of projections) {
+    if (retainedIds.has(usage.id)) continue;
+    hiddenIds.add(usage.id);
+    for (const port of usage.ports ?? []) hiddenIds.add(port.id);
+  }
+  const edges = model.edges.filter((edge) => !hiddenIds.has(edge.from) && !hiddenIds.has(edge.to));
+  const compactNodes = [];
+  const compactEdges = [];
+  for (const { usage, bindings, endCount } of projections) {
+    if (retainedIds.has(usage.id)) continue;
+    const sharedEdgeMeta = { ...bindings[0]?.edge.meta ?? {} };
+    delete sharedEdgeMeta.connectionUsageEnd;
+    delete sharedEdgeMeta.interfaceUsageEnd;
+    delete sharedEdgeMeta.connectionEndOrdinal;
+    delete sharedEdgeMeta.connectionEndRole;
+    const semanticName = typeof usage.meta?.explicitRelationshipName === "string" ? usage.meta.explicitRelationshipName : bindings[0]?.edge.name;
+    const semanticType = bindings[0]?.edge.type ?? usage.type;
+    const label = relationship === "interface" ? ["\xABinterface\xBB", semanticName ?? "", semanticType ? `: ${semanticType}` : ""].filter(Boolean).join(" ").trim() : semanticName;
+    const baseMeta = {
+      ...usage.meta,
+      ...sharedEdgeMeta,
+      connectionUsageId: usage.id,
+      connectionUsageSource: usage.source,
+      ...relationship === "interface" ? { interfaceUsageId: usage.id } : {}
+    };
+    if (endCount <= 2) {
+      if (bindings.length !== 2) continue;
+      const [from, to] = bindings;
+      compactEdges.push({
+        id: from.edge.id,
+        from: from.externalId,
+        to: to.externalId,
+        kind: relationship === "connection" ? "connect" : "interface",
+        name: semanticName,
+        type: semanticType,
+        isDef: false,
+        label,
+        endRoleFrom: from.role,
+        endLabelFrom: from.multiplicity,
+        endAdornmentFrom: from.adornment,
+        endRoleTo: to.role,
+        endLabelTo: to.multiplicity,
+        endAdornmentTo: to.adornment,
+        source: usage.source ?? from.edge.source,
+        meta: {
+          ...baseMeta,
+          ...relationship === "connection" ? { compactConnectionUsage: true } : { compactInterfaceUsage: true },
+          connectionEndFromOrdinal: from.ordinal,
+          connectionEndToOrdinal: to.ordinal,
+          ...from.role ? { connectionEndFromRole: from.role } : {},
+          ...to.role ? { connectionEndToRole: to.role } : {}
+        }
+      });
+      continue;
+    }
+    const hubMeta = { ...baseMeta };
+    delete hubMeta.flowDecorations;
+    const hubId = `${usage.id}::__compact_hub`;
+    compactNodes.push({
+      id: hubId,
+      name: "",
+      keyword: relationship,
+      isDef: false,
+      shape: "dot",
+      ...usage.frame ? { frame: usage.frame } : {},
+      source: usage.source,
+      meta: {
+        ...hubMeta,
+        naryConnectionHub: true,
+        ...relationship === "connection" ? { compactConnectionUsageHub: true } : { compactInterfaceUsageHub: true }
+      }
+    });
+    for (const binding of bindings) {
+      compactEdges.push({
+        id: binding.edge.id,
+        from: hubId,
+        to: binding.externalId,
+        kind: relationship === "connection" ? "connect" : "interface",
+        name: semanticName,
+        type: semanticType,
+        isDef: false,
+        label,
+        endRoleTo: binding.role,
+        endLabelTo: binding.multiplicity,
+        endAdornmentTo: binding.adornment,
+        source: usage.source ?? binding.edge.source,
+        meta: {
+          ...hubMeta,
+          ...relationship === "connection" ? { compactConnectionUsageEnd: true } : { compactInterfaceUsageEnd: true },
+          connectionEndOrdinal: binding.ordinal,
+          ...binding.role ? { connectionEndRole: binding.role } : {}
+        }
+      });
+    }
+  }
+  return {
+    ...model,
+    nodes: [...model.nodes.filter((node) => !hiddenIds.has(node.id)), ...compactNodes],
+    edges: [...edges, ...compactEdges]
+  };
+}
+function hideExplicitConnectionBoxes(model) {
+  return hideExplicitRelationshipBoxes(model, "connection");
+}
+function hideExplicitInterfaceBoxes(model) {
+  return hideExplicitRelationshipBoxes(model, "interface");
+}
 function applyBehaviorFilters(model, filters) {
   if (!FILTERED_KINDS.has(model.kind)) return model;
-  const frames = model.frames ?? [];
+  const visibleModel = filters.defs ? withVisibleDefinitionLayer(model) : model;
+  const frames = visibleModel.frames ?? [];
   const dropped = /* @__PURE__ */ new Set();
   const reparented = /* @__PURE__ */ new Set();
   for (const frame2 of frames) {
@@ -183581,12 +184697,15 @@ function applyBehaviorFilters(model, filters) {
     if (!filters.parts && isOwnerPartFrame || !filters.performers && isPerformerLane) {
       reparented.add(frame2.id);
     }
-    if (!filters.defs && frame2.meta?.behaviorDef === true) dropped.add(frame2.id);
+    if (!filters.defs && (frame2.meta?.behaviorDef === true || frame2.meta?.ivPartDef === true)) dropped.add(frame2.id);
   }
-  const droppedNodes = new Set(model.nodes.filter((n2) => !filters.parts && n2.meta?.stvPart === true || !filters.defs && n2.meta?.behaviorDef === true || !filters.actions && n2.meta?.ivAction === true).map((n2) => n2.id));
+  const droppedNodes = new Set(visibleModel.nodes.filter((n2) => !filters.parts && n2.meta?.stvPart === true || !filters.defs && (n2.meta?.behaviorDef === true || n2.meta?.ivPartDef === true) || !filters.actions && n2.meta?.ivAction === true).map((n2) => n2.id));
   const strippedPorts = !filters.ports && frames.some((f) => f.ports?.some((p) => p.meta?.afvPartPort === true));
-  const strippedDefinedBy = model.kind === "afv" && !filters.definedBy && model.edges.some((edge) => edge.kind === "definedBy");
-  if (dropped.size === 0 && reparented.size === 0 && droppedNodes.size === 0 && !strippedPorts && !strippedDefinedBy) return model;
+  const strippedDefinedBy = !filters.definedBy && visibleModel.edges.some((edge) => edge.kind === "definedBy");
+  if (dropped.size === 0 && reparented.size === 0 && droppedNodes.size === 0 && !strippedPorts && !strippedDefinedBy) {
+    const connectionsProjected2 = filters.connectionBoxes ? visibleModel : hideExplicitConnectionBoxes(visibleModel);
+    return filters.interfaceBoxes ? connectionsProjected2 : hideExplicitInterfaceBoxes(connectionsProjected2);
+  }
   const byId = new Map(frames.map((f) => [f.id, f]));
   const insideDropped = (id2) => {
     const seen = /* @__PURE__ */ new Set();
@@ -183617,7 +184736,7 @@ function applyBehaviorFilters(model, filters) {
     const ports = keepPorts(f.ports);
     return parent === f.parent && ports === f.ports ? f : { ...f, parent, ports };
   });
-  const nodes = model.nodes.filter((n2) => !droppedNodes.has(n2.id) && !insideDropped(n2.frame) && !dropped.has(n2.frame ?? "")).map((n2) => {
+  const nodes = visibleModel.nodes.filter((n2) => !droppedNodes.has(n2.id) && !insideDropped(n2.frame) && !dropped.has(n2.frame ?? "")).map((n2) => {
     const frame2 = visibleParent(n2.frame);
     return frame2 === n2.frame ? n2 : { ...n2, frame: frame2 };
   });
@@ -183627,8 +184746,15 @@ function applyBehaviorFilters(model, filters) {
     ...nextFrames.map((f) => f.id),
     ...nextFrames.flatMap((f) => (f.ports ?? []).map((p) => p.id))
   ]);
-  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 };
+  const edges = visibleModel.edges.filter((e) => !(!filters.definedBy && e.kind === "definedBy") && !hiddenPortIds.has(e.from) && !hiddenPortIds.has(e.to) && liveIds.has(e.from) && liveIds.has(e.to));
+  const filtered = {
+    ...visibleModel,
+    frames: nextFrames,
+    nodes: withoutOrphanedAnnotations(visibleModel, nodes, edges),
+    edges
+  };
+  const connectionsProjected = filters.connectionBoxes ? filtered : hideExplicitConnectionBoxes(filtered);
+  return filters.interfaceBoxes ? connectionsProjected : hideExplicitInterfaceBoxes(connectionsProjected);
 }
 function isProxyPort(port) {
   return port.meta?.proxy === true;
@@ -183736,7 +184862,7 @@ function collapseIvModel(model, hiddenInternals) {
   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 edges = model.edges.filter((edge) => rootFor(typeof edge.meta?.ivRelationshipOwnerId === "string" ? edge.meta.ivRelationshipOwnerId : void 0) === void 0).filter((e) => {
     const fromRoot = containerRootOf(e.from);
     const toRoot = containerRootOf(e.to);
     if (fromRoot !== void 0 && fromRoot === toRoot) return false;
@@ -184114,15 +185240,24 @@ function modelToFlow(model, opts) {
     const visibleFeatureH = featureCompartmentBandHeight(canvasNode);
     const featureH = nodeFeatureCompartmentReserve(canvasNode);
     const base = isGeo ? { w: 24, h: 24 } : nodeSize(canvasNode, opts.direction);
+    const requiresNaturalCompartmentHeight = visibleFeatureH > 0 || (canvasNode.meta?.connectionUsage === true || canvasNode.meta?.interfaceUsage === true) && !!canvasNode.compartments?.length;
     const sizeOverride = ov[n2.layoutKey ?? n2.id];
     const compactCollapsed = canvasNode.meta?.internalsHidden === true;
-    const presentationOverride = compactCollapsed && sizeOverride ? { ...sizeOverride, w: void 0, h: void 0 } : sizeOverride;
+    const compactOverride = compactCollapsed && sizeOverride ? { ...sizeOverride, w: sizeOverride.collapsedW, h: sizeOverride.collapsedH } : sizeOverride;
+    const presentationOverride = compactOverride ? {
+      ...compactOverride,
+      h: connectionUsageHeightOverride(
+        canvasNode,
+        compactOverride.h,
+        compactOverride.connectionBlockVersion
+      )
+    } : compactOverride;
     const projectedSize = isCircularControlShape(canvasNode.shape) ? base : isForkJoinShape(canvasNode.shape) ? forkJoinSizeWithOverride(presentationOverride, opts.direction) : sizeWithOverride(
       base,
       presentationOverride,
       {
         w: canvasNode.meta?.containerControls === true || canvasNode.meta?.internalsHidden === true ? COLLAPSED_CONTAINER_MIN_WIDTH : 48,
-        h: visibleFeatureH > 0 ? base.h : 24
+        h: requiresNaturalCompartmentHeight ? base.h : 24
       }
     );
     const compactPortHandles = compactCollapsed ? assignPortHandles(canvasNode.ports, opts.portOverrides, canvasNode.shape) : [];
@@ -184152,7 +185287,7 @@ function modelToFlow(model, opts) {
         w: size.w,
         h: size.h,
         featureCompartmentHeight: featureH,
-        featureCompartmentMinHeight: visibleFeatureH > 0 ? base.h : void 0,
+        featureCompartmentMinHeight: requiresNaturalCompartmentHeight ? base.h : void 0,
         showPortLabels: opts.showPortLabels,
         showMult: opts.showMult,
         connectPointSpacing
@@ -184273,18 +185408,27 @@ function modelToFlow(model, opts) {
     const routeKey = edgeRouteKey(e, dup, persistedEndpoints);
     const savedAnchor = opts.edgeAnchors?.[routeKey];
     const settledGeometry = opts.edgeGeometry?.[routeKey];
-    const savedSourceHandle = fromPort ? void 0 : canonicalSideHandle(savedAnchor?.sourceHandle ?? settledGeometry?.sourceHandle);
-    const savedTargetHandle = toPort ? void 0 : canonicalSideHandle(savedAnchor?.targetHandle ?? settledGeometry?.targetHandle);
-    const savedSourcePortSide = parsePortAnchorHandleId(settledGeometry?.sourceHandle)?.side;
-    const savedTargetPortSide = parsePortAnchorHandleId(settledGeometry?.targetHandle)?.side;
+    const explicitSourceHandle = fromPort ? void 0 : canonicalSideHandle(savedAnchor?.sourceHandle);
+    const explicitTargetHandle = toPort ? void 0 : canonicalSideHandle(savedAnchor?.targetHandle);
+    const savedSourceHandle = explicitSourceHandle ?? (fromPort ? void 0 : canonicalSideHandle(settledGeometry?.sourceHandle));
+    const savedTargetHandle = explicitTargetHandle ?? (toPort ? void 0 : canonicalSideHandle(settledGeometry?.targetHandle));
+    const portSideForHandle = (ownerId, portId, persistedHandle) => {
+      const portHandle = nodeById.get(ownerId)?.data.ports?.find((handle) => handle.port.id === portId);
+      return portHandle?.port.meta?.connectionEndPin === true ? portHandle.side : parsePortAnchorHandleId(persistedHandle)?.side;
+    };
+    const savedSourcePortSide = fromPort ? portSideForHandle(source, e.from, settledGeometry?.sourceHandle) : void 0;
+    const savedTargetPortSide = toPort ? portSideForHandle(target, e.to, settledGeometry?.targetHandle) : void 0;
+    const sourceHandle = fromPort ? savedSourcePortSide ? portAnchorHandleId(e.from, savedSourcePortSide) : e.from : savedSourceHandle;
+    const targetHandle = toPort ? savedTargetPortSide ? portAnchorHandleId(e.to, savedTargetPortSide) : e.to : savedTargetHandle;
+    const settledHandlesMatch = !settledGeometry || (settledGeometry.sourceHandle === void 0 || settledGeometry.sourceHandle === sourceHandle) && (settledGeometry.targetHandle === void 0 || settledGeometry.targetHandle === targetHandle);
     retainExplicitHandle(source, savedSourceHandle);
     retainExplicitHandle(target, savedTargetHandle);
     edges.push({
       id: e.id,
       source,
       target,
-      ...fromPort ? { sourceHandle: savedSourcePortSide ? portAnchorHandleId(e.from, savedSourcePortSide) : e.from } : savedSourceHandle ? { sourceHandle: savedSourceHandle } : {},
-      ...toPort ? { targetHandle: savedTargetPortSide ? portAnchorHandleId(e.to, savedTargetPortSide) : e.to } : savedTargetHandle ? { targetHandle: savedTargetHandle } : {},
+      ...sourceHandle ? { sourceHandle } : {},
+      ...targetHandle ? { targetHandle } : {},
       type: "sysml",
       data: {
         kind: model.kind,
@@ -184293,7 +185437,9 @@ function modelToFlow(model, opts) {
         showMult: opts.showMult,
         routeKey,
         route: opts.edgeRoutes?.[routeKey],
-        settledGeometry
+        ...explicitSourceHandle ? { explicitSourceAnchor: true } : {},
+        ...explicitTargetHandle ? { explicitTargetAnchor: true } : {},
+        settledGeometry: settledHandlesMatch ? settledGeometry : void 0
       },
       selectable: true,
       reconnectable: true,
@@ -184385,7 +185531,7 @@ function clampDirection(kind, d) {
 
 // ../extension/src/webview/diagram/flow/geo-layout.ts
 var GEO_MARGIN_LEFT = 48;
-var GEO_TOP_PAD = 28;
+var GEO_TOP_PAD = 40;
 var GEO_TARGET_W = 860;
 var GEO_TARGET_H = 520;
 var GEO_DEF_W = 400;
@@ -184400,33 +185546,110 @@ function geoProject(f, x, y, z2) {
   const isoY = (x + y) * f.sinA - z2;
   return [f.ox + (isoX - f.isoMinX) * f.scale, f.oy + (isoY - f.isoMinY) * f.scale];
 }
-function geoExtentOf(node, def) {
+function geoWorldPoint(placement, local) {
+  const [lx, ly, lz] = local;
+  const orientation = placement.orientation;
+  if (orientation) {
+    return [
+      placement.x + orientation[0] * lx + orientation[1] * ly + orientation[2] * lz,
+      placement.y + orientation[3] * lx + orientation[4] * ly + orientation[5] * lz,
+      (placement.z ?? 0) + orientation[6] * lx + orientation[7] * ly + orientation[8] * lz
+    ];
+  }
+  if (placement.rot) {
+    const angle = placement.rot * Math.PI / 180;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return [
+      placement.x + cos * lx - sin * ly,
+      placement.y + sin * lx + cos * ly,
+      (placement.z ?? 0) + lz
+    ];
+  }
+  return [placement.x + lx, placement.y + ly, (placement.z ?? 0) + lz];
+}
+function geoHalfExtentsOf(node, def) {
   const g = node.geo;
-  const z2 = g.z ?? 0;
   switch (g.shape) {
     case "sphere": {
       const r = g.radius ?? def / 2;
-      return { hx: r, hy: r, zlo: z2 - r, zhi: z2 + r };
+      return { hx: r, hy: r, hz: r };
     }
     case "cylinder":
     case "cone": {
       const r = g.radius ?? def / 2;
-      const h = g.sizeZ ?? def;
-      return { hx: r, hy: r, zlo: z2 - h / 2, zhi: z2 + h / 2 };
+      return { hx: r, hy: r, hz: (g.sizeZ ?? def) / 2 };
     }
     case "pyramid":
     case "wedge":
-    case "box": {
-      const sx = g.sizeX ?? def;
-      const sy = g.sizeY ?? def;
-      const sz = g.sizeZ ?? def;
-      return { hx: sx / 2, hy: sy / 2, zlo: z2 - sz / 2, zhi: z2 + sz / 2 };
-    }
-    default: {
-      const sx = g.sizeX ?? GEO_DEF_W;
-      const sy = g.sizeY ?? GEO_DEF_H;
-      return { hx: sx / 2, hy: sy / 2, zlo: z2, zhi: z2 };
+    case "box":
+      return {
+        hx: (g.sizeX ?? def) / 2,
+        hy: (g.sizeY ?? def) / 2,
+        hz: (g.sizeZ ?? def) / 2
+      };
+    default:
+      return { hx: (g.sizeX ?? GEO_DEF_W) / 2, hy: (g.sizeY ?? GEO_DEF_H) / 2, hz: 0 };
+  }
+}
+function geoShapePoints(node, def) {
+  const g = node.geo;
+  const { hx, hy, hz } = geoHalfExtentsOf(node, def);
+  const transform2 = (points) => points.map((point) => geoWorldPoint(g, point));
+  const ring = (z2) => Array.from({ length: 32 }, (_2, index2) => {
+    const angle = index2 * Math.PI / 16;
+    return [hx * Math.cos(angle), hy * Math.sin(angle), z2];
+  });
+  switch (g.shape) {
+    case "sphere": {
+      const radius = g.radius ?? def / 2;
+      const cosA = Math.cos(Math.PI / 6);
+      const sinA = Math.sin(Math.PI / 6);
+      const norm = Math.hypot(cosA, cosA);
+      const silhouette = Array.from({ length: 32 }, (_2, index2) => {
+        const angle = index2 * Math.PI / 16;
+        const alongX = [cosA / norm, -cosA / norm, 0];
+        const alongY = [sinA / norm, sinA / norm, -1 / norm];
+        const x = radius * (alongX[0] * Math.cos(angle) + alongY[0] * Math.sin(angle));
+        const y = radius * (alongX[1] * Math.cos(angle) + alongY[1] * Math.sin(angle));
+        const z2 = radius * (alongX[2] * Math.cos(angle) + alongY[2] * Math.sin(angle));
+        return [g.x + x, g.y + y, (g.z ?? 0) + z2];
+      });
+      return [
+        ...silhouette,
+        [g.x - radius, g.y, g.z ?? 0],
+        [g.x + radius, g.y, g.z ?? 0],
+        [g.x, g.y - radius, g.z ?? 0],
+        [g.x, g.y + radius, g.z ?? 0],
+        [g.x, g.y, (g.z ?? 0) - radius],
+        [g.x, g.y, (g.z ?? 0) + radius]
+      ];
     }
+    case "cylinder":
+      return transform2([...ring(-hz), ...ring(hz)]);
+    case "cone":
+      return transform2([...ring(-hz), [0, 0, hz]]);
+    case "pyramid":
+      return transform2([
+        [-hx, -hy, -hz],
+        [hx, -hy, -hz],
+        [hx, hy, -hz],
+        [-hx, hy, -hz],
+        [0, 0, hz]
+      ]);
+    case "wedge":
+      return transform2([
+        [-hx, -hy, -hz],
+        [hx, -hy, -hz],
+        [hx, hy, -hz],
+        [-hx, hy, -hz],
+        [0, -hy, hz],
+        [0, hy, hz]
+      ]);
+    case "box":
+      return transform2([-1, 1].flatMap((x) => [-1, 1].flatMap((y) => [-1, 1].map((z2) => [x * hx, y * hy, z2 * hz]))));
+    default:
+      return transform2([[-hx, -hy, 0], [hx, -hy, 0], [hx, hy, 0], [-hx, hy, 0]]);
   }
 }
 function makeGeoFrameNode(kind, w, h, geo) {
@@ -184506,26 +185729,30 @@ function layoutPlan(kind, placed, strip, axes, edges) {
 function layoutIso(kind, placed, strip, unit, edges) {
   const cosA = Math.cos(Math.PI / 6);
   const sinA = Math.sin(Math.PI / 6);
-  let pminX = 0, pmaxX = 0, pminY = 0, pmaxY = 0, pmaxZ = 0;
+  let centreMinX = 0, centreMaxX = 0, centreMinY = 0, centreMaxY = 0;
   for (const n2 of placed) {
     const g = n2.data.node.geo;
-    pminX = Math.min(pminX, g.x);
-    pmaxX = Math.max(pmaxX, g.x);
-    pminY = Math.min(pminY, g.y);
-    pmaxY = Math.max(pmaxY, g.y);
-    pmaxZ = Math.max(pmaxZ, g.z ?? 0);
+    centreMinX = Math.min(centreMinX, g.x);
+    centreMaxX = Math.max(centreMaxX, g.x);
+    centreMinY = Math.min(centreMinY, g.y);
+    centreMaxY = Math.max(centreMaxY, g.y);
   }
-  const span = Math.max(pmaxX - pminX, pmaxY - pminY, 1);
+  const span = Math.max(centreMaxX - centreMinX, centreMaxY - centreMinY, 1);
   const def = Math.max(span * 0.12, 1e-4);
+  let pminX = 0, pmaxX = 0, pminY = 0, pmaxY = 0, pmaxZ = 0;
   let isoMinX = Infinity, isoMaxX = -Infinity, isoMinY = Infinity, isoMaxY = -Infinity;
   const iso = (x, y, z2) => [(x - y) * cosA, (x + y) * sinA - z2];
-  const exts = /* @__PURE__ */ new Map();
+  const pointsByNode = /* @__PURE__ */ new Map();
   for (const n2 of placed) {
-    const e = geoExtentOf(n2.data.node, def);
-    exts.set(n2, e);
-    const g = n2.data.node.geo;
-    for (const dx of [-e.hx, e.hx]) for (const dy of [-e.hy, e.hy]) for (const z2 of [e.zlo, e.zhi]) {
-      const [ix, iy] = iso(g.x + dx, g.y + dy, z2);
+    const points = geoShapePoints(n2.data.node, def);
+    pointsByNode.set(n2, points);
+    for (const [worldX, worldY, worldZ] of points) {
+      pminX = Math.min(pminX, worldX);
+      pmaxX = Math.max(pmaxX, worldX);
+      pminY = Math.min(pminY, worldY);
+      pmaxY = Math.max(pmaxY, worldY);
+      pmaxZ = Math.max(pmaxZ, worldZ);
+      const [ix, iy] = iso(worldX, worldY, worldZ);
       isoMinX = Math.min(isoMinX, ix);
       isoMaxX = Math.max(isoMaxX, ix);
       isoMinY = Math.min(isoMinY, iy);
@@ -184537,11 +185764,9 @@ function layoutIso(kind, placed, strip, unit, edges) {
   const oy = GEO_TOP_PAD + 6;
   const frame3d = { ox, oy, scale, cosA, sinA, isoMinX, isoMinY, minX: pminX, maxX: pmaxX, minY: pminY, maxY: pmaxY, maxZ: pmaxZ, unit, def };
   const outPlaced = placed.map((n2) => {
-    const e = exts.get(n2);
-    const g = n2.data.node.geo;
     let sxMin = Infinity, syMin = Infinity, sxMax = -Infinity, syMax = -Infinity;
-    for (const dx of [-e.hx, e.hx]) for (const dy of [-e.hy, e.hy]) for (const z2 of [e.zlo, e.zhi]) {
-      const [px, py] = geoProject(frame3d, g.x + dx, g.y + dy, z2);
+    for (const [worldX, worldY, worldZ] of pointsByNode.get(n2)) {
+      const [px, py] = geoProject(frame3d, worldX, worldY, worldZ);
       sxMin = Math.min(sxMin, px);
       syMin = Math.min(syMin, py);
       sxMax = Math.max(sxMax, px);
@@ -194080,7 +195305,7 @@ function buildEdgeBundles(candidates, obstacles = [], busPositions = {}) {
   const buckets = /* @__PURE__ */ new Map();
   const fanSizes = /* @__PURE__ */ new Map();
   const add = (edge, role) => {
-    if (edge.eligible === false) return;
+    if (edge.eligible === false || edge.eligibleRole && edge.eligibleRole !== role) return;
     const pairKey = `${edge.source}\0${edge.target}\0${edge.className}`;
     if ((pairCounts.get(pairKey) ?? 0) > 1) return;
     const commonNodeId = role === "source" ? edge.source : edge.target;
@@ -194784,6 +196009,16 @@ async function elkLayout(elk, graph) {
   }
 }
 function overrideFor(node, overrides) {
+  const stored = storedOverrideFor(node, overrides);
+  if (!stored) return void 0;
+  const compact2 = node.data.node?.meta?.internalsHidden === true || node.data.frame?.meta?.internalsHidden === true;
+  const active = compact2 ? { ...stored, w: stored.collapsedW, h: stored.collapsedH } : stored;
+  return {
+    ...active,
+    h: connectionUsageHeightOverride(node.data.node, active.h, active.connectionBlockVersion)
+  };
+}
+function storedOverrideFor(node, overrides) {
   return overrides?.[node.data.layoutKey] ?? overrides?.[node.id];
 }
 var AFV_LAYOUT_EDGE_KINDS = /* @__PURE__ */ new Set([
@@ -196010,7 +197245,8 @@ function semanticPortHandle(node, handle) {
 function validConcretePortAnchor(node, handle) {
   const parsed = parsePortAnchorHandleId(handle);
   const ph = parsed ? portOnNode(node, parsed.portId) : void 0;
-  return !!ph && portConnectHandleIds(ph.port.id, ph.side).includes(handle);
+  if (!ph) return false;
+  return ph.port.meta?.connectionEndPin === true ? handle === portAnchorHandleId(ph.port.id, ph.side) : portConnectHandleIds(ph.port.id, ph.side).includes(handle);
 }
 function isStrictDescendant(nodeId, ancestorId, byId) {
   let cur = byId.get(nodeId)?.parentId;
@@ -196025,6 +197261,7 @@ function isStrictDescendant(nodeId, ancestorId, byId) {
 function inferredPortAnchorSide(node, other, portId, byId) {
   const ph = portOnNode(node, portId);
   if (!ph) return "right";
+  if (ph.port.meta?.connectionEndPin === true) return ph.side;
   return other.id === node.id || isStrictDescendant(other.id, node.id, byId) ? OPPOSITE[ph.side] : ph.side;
 }
 function assignPortAnchorSides(nodes, edges) {
@@ -196115,6 +197352,38 @@ function nextSideAnchor(counts, offsetsCache, assignedOffsets, node, side, spaci
 }
 function assignEdgeSides(nodes, edges, topDown = false, connectPointSpacing = CONNECT_POINT_SPACING_DEFAULT, behaviorDirection) {
   const byId = new Map(nodes.map((n2) => [n2.id, n2]));
+  const naryHub = (node) => node?.data.node?.shape === "dot" && node.data.node.meta?.naryConnectionHub === true;
+  const explicitHubAnchors = /* @__PURE__ */ new Map();
+  const retainExplicitHubAnchor = (nodeId, side, offset2) => {
+    const current2 = explicitHubAnchors.get(nodeId) ?? {};
+    const offsets = current2[side] ?? [];
+    if (!offsets.includes(offset2)) current2[side] = [...offsets, offset2].sort((a2, b) => a2 - b);
+    explicitHubAnchors.set(nodeId, current2);
+  };
+  for (const edge of edges) {
+    const sourceAnchor = parseSideAnchorHandleId(edge.sourceHandle);
+    if (sourceAnchor && naryHub(byId.get(edge.source))) {
+      if (edge.data?.explicitSourceAnchor === true) {
+        retainExplicitHubAnchor(edge.source, sourceAnchor.side, sourceAnchor.offset);
+      } else {
+        edge.sourceHandle = sideAnchorHandleId(sourceAnchor.side, 0.5);
+      }
+    }
+    const targetAnchor = parseSideAnchorHandleId(edge.targetHandle);
+    if (targetAnchor && naryHub(byId.get(edge.target))) {
+      if (edge.data?.explicitTargetAnchor === true) {
+        retainExplicitHubAnchor(edge.target, targetAnchor.side, targetAnchor.offset);
+      } else {
+        edge.targetHandle = sideAnchorHandleId(targetAnchor.side, 0.5);
+      }
+    }
+  }
+  for (const node of nodes) {
+    const explicit = explicitHubAnchors.get(node.id);
+    if (naryHub(node) && (node.data.explicitSideAnchors || explicit)) {
+      node.data = { ...node.data, explicitSideAnchors: explicit };
+    }
+  }
   const sideCounts = /* @__PURE__ */ new Map();
   const offsetsCache = /* @__PURE__ */ new Map();
   const assignedOffsets = /* @__PURE__ */ new Map();
@@ -196134,7 +197403,7 @@ function assignEdgeSides(nodes, edges, topDown = false, connectPointSpacing = CO
   const requests = /* @__PURE__ */ new Map();
   const requestPreference = /* @__PURE__ */ new Map();
   const requestKey = (edge, role) => `${edge.id}|${role}`;
-  const anchor = (node, side, preferred) => nextSideAnchor(sideCounts, offsetsCache, assignedOffsets, node, side, connectPointSpacing, demand, preferred);
+  const anchor = (node, side, preferred) => naryHub(node) ? sideAnchorHandleId(side, 0.5) : nextSideAnchor(sideCounts, offsetsCache, assignedOffsets, node, side, connectPointSpacing, demand, preferred);
   const diamondPreference = (node, side, dx, dy) => {
     const shape = node.data.node?.shape;
     if (shape !== "decision" && shape !== "merge") return void 0;
@@ -197107,6 +198376,45 @@ function successionFlowLabelPoint(centre, mark) {
     y: markCoordinate(centre.y - mark.normal.y * 16)
   };
 }
+function flowDecorationsOf(edge) {
+  const raw = edge.meta?.flowDecorations;
+  if (!Array.isArray(raw)) return [];
+  return raw.flatMap((entry) => {
+    if (!entry || typeof entry !== "object") return [];
+    const decoration = entry;
+    return [{
+      keyword: typeof decoration.keyword === "string" ? decoration.keyword : "flow",
+      label: typeof decoration.label === "string" ? decoration.label : void 0,
+      name: typeof decoration.name === "string" ? decoration.name : void 0,
+      reversed: decoration.reversed === true
+    }];
+  });
+}
+var FLOW_DECORATION_STEP = 26;
+function flowDecorationGeometry(centre, points, source, target, index2, count, reversed) {
+  const raw = midpointTangent(points?.length ? points : [source, target]) ?? { x: target.x - source.x, y: target.y - source.y };
+  const length2 = Math.hypot(raw.x, raw.y);
+  if (length2 <= 0) return void 0;
+  const tangent = { x: raw.x / length2, y: raw.y / length2 };
+  const normal = { x: -tangent.y, y: tangent.x };
+  const shift = (index2 - (count - 1) / 2) * FLOW_DECORATION_STEP;
+  const at = { x: centre.x + tangent.x * shift, y: centre.y + tangent.y * shift };
+  const sign = reversed ? -1 : 1;
+  const tip = { x: at.x + tangent.x * 5 * sign, y: at.y + tangent.y * 5 * sign };
+  const back = { x: at.x - tangent.x * 4 * sign, y: at.y - tangent.y * 4 * sign };
+  const corner = (side) => ({
+    x: back.x + normal.x * 4 * side,
+    y: back.y + normal.y * 4 * side
+  });
+  const wing = [corner(1), corner(-1)];
+  return {
+    chevron: [tip, wing[0], wing[1]].map((point) => `${markCoordinate(point.x)},${markCoordinate(point.y)}`).join(" "),
+    label: {
+      x: markCoordinate(at.x + normal.x * 13),
+      y: markCoordinate(at.y + normal.y * 13)
+    }
+  };
+}
 function routePointNearSource(points, source, target, distance2) {
   const route = [source, ...points ?? [], target].filter((point, index2, all) => index2 === 0 || point.x !== all[index2 - 1].x || point.y !== all[index2 - 1].y);
   let remaining = distance2;
@@ -197128,6 +198436,50 @@ function routePointNearSource(points, source, target, distance2) {
   }
   return void 0;
 }
+function connectionEndLabelLines(edge, side, showMultiplicity) {
+  const semanticRole = side === "from" ? edge.endRoleFrom : edge.endRoleTo;
+  const multiplicity = side === "from" ? edge.endLabelFrom : edge.endLabelTo;
+  let adornment = side === "from" ? edge.endAdornmentFrom : edge.endAdornmentTo;
+  const namedPinEnd = side === "from" && (edge.meta?.connectionUsageEnd === true || edge.meta?.interfaceUsageEnd === true);
+  if (namedPinEnd && semanticRole && adornment) {
+    const impliedRedefinition = `redefines ${semanticRole}`;
+    if (adornment === impliedRedefinition) {
+      adornment = void 0;
+    } else if (adornment.endsWith(` ${impliedRedefinition}`)) {
+      adornment = adornment.slice(0, -(impliedRedefinition.length + 1)).trim() || void 0;
+    }
+  }
+  const role = namedPinEnd ? void 0 : semanticRole;
+  return [role, showMultiplicity ? multiplicity : void 0, adornment].filter((line2) => !!line2);
+}
+function connectionEndLabelPoint(points, source, target, side) {
+  const reversed = side === "to" ? [...points ?? []].reverse() : points;
+  const start2 = side === "to" ? target : source;
+  const finish = side === "to" ? source : target;
+  const near = routePointNearSource(reversed, start2, finish, 24);
+  if (!near) return start2;
+  return {
+    x: markCoordinate(near.point.x - near.tangent.y * 12),
+    y: markCoordinate(near.point.y + near.tangent.x * 12)
+  };
+}
+function connectionElaborationGeometry(start2, target) {
+  const cx = target.x + target.width / 2;
+  const cy = target.y + target.height / 2;
+  const dx = start2.x - cx;
+  const dy = start2.y - cy;
+  const scale = Math.max(
+    Math.abs(dx) / Math.max(target.width / 2, 1),
+    Math.abs(dy) / Math.max(target.height / 2, 1),
+    1
+  );
+  const end = { x: cx + dx / scale, y: cy + dy / scale };
+  return {
+    start: start2,
+    target: end,
+    path: `M ${markCoordinate(start2.x)} ${markCoordinate(start2.y)} L ${markCoordinate(end.x)} ${markCoordinate(end.y)}`
+  };
+}
 function edgeLabelPoint(edge, centre, mark, points, source, target) {
   const branchLabel = edge.kind === "succession" && (edge.label === "else" || /^\[.*\]$/u.test(edge.label ?? ""));
   if (!branchLabel) return successionFlowLabelPoint(centre, mark);
@@ -197270,13 +198622,25 @@ function treeFacingDock(node, other, byId) {
   const normal = otherCentre.y >= centre.y ? DOCK_NORMAL.bottom : DOCK_NORMAL.top;
   return { point: { x: centre.x, y: centre.y + normal.y * h / 2 }, normal };
 }
+function naryFacingDock(node, other, byId) {
+  const from = nodeCentre(node, byId);
+  const to = nodeCentre(other, byId);
+  const dx = to.x - from.x;
+  const dy = to.y - from.y;
+  const side = Math.abs(dx) >= Math.abs(dy) ? dx >= 0 ? "right" : "left" : dy >= 0 ? "bottom" : "top";
+  return dockPoint(node, sideAnchorHandleId(side, 0.5), byId, from);
+}
+function isNaryConnectionHub(node) {
+  return node?.data.node?.shape === "dot" && node.data.node.meta?.naryConnectionHub === true;
+}
 function bundleCandidateFor(edge, byId) {
   const semantic = edge.data?.edge;
   const sourceNode = byId.get(edge.source);
   const targetNode = byId.get(edge.target);
   if (!semantic || !sourceNode || !targetNode) return void 0;
-  const sourceFallback = treeFacingDock(sourceNode, targetNode, byId);
-  const targetFallback = treeFacingDock(targetNode, sourceNode, byId);
+  const naryRole = semantic.kind === "connect" ? isNaryConnectionHub(sourceNode) ? "source" : isNaryConnectionHub(targetNode) ? "target" : void 0 : void 0;
+  const sourceFallback = naryRole ? naryFacingDock(sourceNode, targetNode, byId) : treeFacingDock(sourceNode, targetNode, byId);
+  const targetFallback = naryRole ? naryFacingDock(targetNode, sourceNode, byId) : treeFacingDock(targetNode, sourceNode, byId);
   const explicitSource = dockPoint(sourceNode, edge.sourceHandle, byId, sourceFallback.point);
   const explicitTarget = dockPoint(targetNode, edge.targetHandle, byId, targetFallback.point);
   const source = explicitSource.normal ? explicitSource : sourceFallback;
@@ -197299,7 +198663,8 @@ function bundleCandidateFor(edge, byId) {
     // remaining separate semantic edges. Once one connector owns manual
     // waypoints it deliberately leaves that automatic fan and keeps its
     // individually movable route.
-    eligible: edge.data?.kind === "gv" && GV_BUS_EDGE_KINDS.has(semantic.kind) && edge.source !== edge.target && !edge.data.route?.length && !isPortDocked(edge.sourceHandle) && !isPortDocked(edge.targetHandle)
+    eligible: edge.source !== edge.target && !edge.data?.route?.length && (naryRole !== void 0 || edge.data?.kind === "gv" && GV_BUS_EDGE_KINDS.has(semantic.kind) && !isPortDocked(edge.sourceHandle) && !isPortDocked(edge.targetHandle)),
+    ...naryRole ? { eligibleRole: naryRole } : {}
   };
 }
 function movingNodeIds(nodes, byId) {
@@ -197472,7 +198837,7 @@ function edgeBundles(nodes, edges, runtime = defaultBundleRuntime) {
 function projectedBundleMember(edge) {
   return edge.data?.bundleMember;
 }
-function projectIndividualGvTreeRenderEdges(nodes, semanticEdges, runtime) {
+function projectAutomaticBusRenderEdges(nodes, semanticEdges, runtime) {
   const bundles = edgeBundles(nodes, semanticEdges, runtime);
   if (!bundles.size) return semanticEdges;
   return semanticEdges.map((edge) => {
@@ -198079,6 +199444,13 @@ body {
 .dlink { stroke: var(--diagram-line-structural); stroke-width: 1.2; fill: none; }
 .dlink.successionFlow { stroke-width: 2; }
 .dsuccession-flow-mark { pointer-events: none; stroke-linecap: butt; }
+/* REQ-401 \u2014 OMG 8.2.3.16 flow-on-connection: the payload chevron rides the
+   connector that transports it, in the item-flow hue, and never takes pointer
+   events away from the connector it decorates. */
+.dflow-decoration {
+  pointer-events: none; stroke: none;
+  fill: var(--diagram-line-connection, #6cd1d9);
+}
 /* REQ-196: AFV control transitions (IR succession) use a dotted route so
    they remain visually distinct from continuous item and succession flows. */
 .dlink.succession { stroke-dasharray: 1 3; stroke-linecap: round; }
@@ -198086,6 +199458,7 @@ body {
 /* REQ-186/188/189/199/206/210 \u2014 the dashed labelled families */
 .dlink.allocate, .dlink.frame, .dlink.derive, .dlink.causation, .dlink.import, .dlink.expose { stroke-dasharray: 4 3; }
 .dlink.annotation { stroke-dasharray: 2 3; }
+.dlink.elaboration { stroke-dasharray: 2 3; pointer-events: none; }
 .dlink.reply { stroke-dasharray: 4 3; } /* REQ-202 \u2014 sequence reply arrows */
 /* issue #84 \u2014 REQ-202: a message is dragged up/down to change WHEN it happens.
    The grip is the invisible hit band over the arrow (a row-resize cursor is the
@@ -198124,6 +199497,15 @@ body {
  * 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. */
 .dnode-port.pin { fill: var(--element-fill); stroke: var(--element-outline); stroke-width: 1.2; }
+/* REQ-192 - explicit connection ends are outline-coloured endpoint dots, not
+ * action-pin boxes. The dot itself is the persistent snap affordance. */
+.dconnection-end-dot { fill: var(--element-outline); stroke: var(--element-outline); stroke-width: 1.2; }
+.dconnection-end-dot.selected { fill: var(--accent); stroke: var(--accent); }
+.rf-node.selected .dnode-control.dot { fill: var(--accent); stroke: var(--accent); }
+.dconnection-end-dot.hovered, .dconnection-end-dot.connect-target {
+  fill: var(--cyan); stroke: var(--cyan); filter: drop-shadow(0 0 3px var(--cyan));
+}
+.dconnection-end-dot.moving { fill: var(--accent); stroke: var(--accent); filter: drop-shadow(0 0 4px var(--accent)); }
 /* REQ-194 \u2014 the port direction ARROW: a shaft across the glyph with a solid head
  * at each directed end (--> out, <-- in, <-> inout), per OMG 8.2.3.12.
  * NOTE: no backticks in this file's CSS \u2014 STYLE is a template literal. */
@@ -198288,15 +199670,19 @@ body {
 /* REQ-205 \u2014 Geometry View 3D (isometric) shapes + ground frame */
 .dgeo3d-grid { stroke-width: 1; opacity: 0.35; }
 .dgeo3d-face { stroke: var(--element-outline); stroke-width: 1; stroke-linejoin: round; }
-.dgeo3d-face.top { fill: var(--element-fill); fill-opacity: 0.56; }
-.dgeo3d-face.side { fill: var(--element-fill); fill-opacity: 0.38; }
-.dgeo3d-face.side2 { fill: var(--element-fill); fill-opacity: 0.24; }
+.dgeo3d-face.top { fill: var(--element-fill); fill-opacity: 0.42; }
+.dgeo3d-face.side { fill: var(--element-fill); fill-opacity: 0.28; }
+.dgeo3d-face.side2 { fill: var(--element-fill); fill-opacity: 0.18; }
 .dgeo3d-edge { stroke: var(--element-outline); stroke-width: 1; opacity: 0.7; }
 .dgeo3d-node { cursor: pointer; }
 .dgeo3d-node:hover .dgeo3d-face { fill-opacity: 0.42; }
 .dgeo3d-node.selected .dgeo3d-face { stroke: var(--accent); }
 .dgeo3d-node.selected .dgeo3d-face.top { fill: var(--accent); fill-opacity: 0.34; }
-.dgeo3d-name { fill: var(--fg-0); font-family: var(--font-mono); font-size: 10px; }
+.dgeo3d-name {
+  fill: var(--fg-0); stroke: var(--diagram-canvas); stroke-width: 3px;
+  paint-order: stroke fill; stroke-linejoin: round;
+  font-family: var(--font-mono); font-size: 10px;
+}
 /* REQ-205 \u2014 an object whose coordinate-frame transformation could not be fully
    decided is DRAWN and MARKED, never silently misplaced: its outline goes dashed
    and it carries a warning glyph whose tooltip names the reason. (The issue
@@ -198873,14 +200259,17 @@ svg.react-flow__connectionline { z-index: 1; }
  * Each 5px dot has a compact hit box and can start or end a connector. The chosen
  * handle is the chosen dock point, while the central body stays selectable. */
 .react-flow__handle.rf-handle-port { width: ${PORT_CONNECT_DOT_HIT}px; height: ${PORT_CONNECT_DOT_HIT}px; --rf-dot-size: 5px; z-index: 6; }
+.react-flow__handle.rf-handle-connection-end { width: 12px; height: 12px; z-index: 6; }
+.react-flow__handle.rf-handle-connection-end::after { display: none; }
 .react-flow__handle.rf-handle-side { width: ${BODY_SNAP_POINT_HIT_SIZE}px; height: ${BODY_SNAP_POINT_HIT_SIZE}px; --rf-dot-size: 5px; z-index: 2; }
 /* REQ-370: body snap points are hollow circles. Port and pin endpoints are
  * solid squares, so adjacent targets cannot be mistaken for each other. */
 .react-flow__handle.rf-handle-side::after { background: var(--bg-1); border: 1.5px solid var(--cyan); }
 .react-flow__handle.rf-handle-port::after { border-radius: 1px; }
-/* The start/done centre stays available for normal node selection and dragging
- * even though four 12px handle targets meet over these exact-size glyphs. The
- * perimeter dots remain above the rest of the node and keep their full hit area. */
+/* The start, done, and n-ary hub centre stays available for normal node
+ * selection and dragging even though four 12px handle targets meet over these
+ * exact-size glyphs. The perimeter dots remain above the rest of the node and
+ * keep their full hit area. */
 .rf-circular-control-hit {
   position: absolute; left: 50%; top: 50%; width: 50%; height: 50%;
   transform: translate(-50%, -50%); border-radius: 50%;
@@ -198894,6 +200283,7 @@ svg.react-flow__connectionline { z-index: 1; }
 .react-flow.sysml-connecting .react-flow__handle.rf-handle-side.connectionindicator,
 .react-flow.sysml-connecting .react-flow__handle.rf-handle-lifeline.connectionindicator { opacity: 0.42; }
 .react-flow.sysml-connecting .react-flow__handle.rf-handle-port.connectionindicator { opacity: 0.42; }
+.react-flow.sysml-connecting .react-flow__handle.rf-handle-connection-end.connectionindicator { opacity: 0.42; }
 .react-flow.sysml-connecting .react-flow__handle.rf-handle-port.active { opacity: 1; }
 /* The nearest semantically valid body target is stronger than the candidate
  * points. Port and pin targets use the highlighted endpoint glyph instead. */
@@ -199044,6 +200434,9 @@ svg.react-flow__connectionline { z-index: 1; }
 .rf-edge-label { position: absolute; pointer-events: none; font-family: var(--font-mono); font-size: 9px;
   color: var(--fg-0); background: transparent; border: 0; padding: 0; white-space: nowrap; }
 .rf-edge-label.mult { background: transparent; border: 0; color: var(--fg-2); padding: 0; }
+.rf-edge-label.connection-end { color: var(--fg-1); display: flex; flex-direction: column;
+  line-height: 1.15; text-align: center; white-space: nowrap; }
+.rf-edge-label.connection-end span:nth-child(n+2) { color: var(--fg-2); }
 
 /* REQ-366/386 \u2014 two adjacent, independent container presentation controls.
  * +/\u2212 owns graphical internals; the outlined list owns textual feature
@@ -199126,6 +200519,11 @@ function labelExtent(text) {
 function labelSvg(text, x, y, cls) {
   return `<text class="${cls}" x="${Math.round(x)}" y="${Math.round(y)}" text-anchor="middle" dominant-baseline="central">${escapeXml(text)}</text>`;
 }
+function multilineLabelSvg(lines, x, y, cls) {
+  const firstY = y - (lines.length - 1) * 5.5;
+  const spans = lines.map((line2, index2) => `<tspan x="${Math.round(x)}" dy="${index2 === 0 ? 0 : 11}">${escapeXml(line2)}</tspan>`).join("");
+  return `<text class="${cls}" x="${Math.round(x)}" y="${Math.round(firstY)}" text-anchor="middle" dominant-baseline="central">${spans}</text>`;
+}
 function buildDiagramSvg(options) {
   const { nodes, edges, lineStyle, nodeMarkup } = options;
   if (!nodes.length) return null;
@@ -199204,6 +200602,22 @@ function buildDiagramSvg(options) {
     const markerStart = style2.markerStart ? ` marker-start="${style2.markerStart}"` : "";
     const markerEnd = style2.markerEnd ? ` marker-end="${style2.markerEnd}"` : "";
     edgeParts.push(`<path class="${style2.className}" d="${geometry.path}"${markerStart}${markerEnd}/>`);
+    if (semantic?.elaboration) {
+      const targetNode = byId.get(semantic.elaboration);
+      if (targetNode) {
+        const position = absolutePos(targetNode.id, byId);
+        const size = sizeOf(targetNode);
+        const elaboration = connectionElaborationGeometry(geometry.label, {
+          x: position.x,
+          y: position.y,
+          width: size.w,
+          height: size.h
+        });
+        edgeParts.push(`<path class="dlink elaboration" d="${elaboration.path}"/>`);
+        extendPoint(elaboration.start.x, elaboration.start.y, 2);
+        extendPoint(elaboration.target.x, elaboration.target.y, 2);
+      }
+    }
     const sequencingMark = successionFlowMarkGeometry(
       style2,
       geometry.label,
@@ -199216,6 +200630,24 @@ function buildDiagramSvg(options) {
       extendPoint(sequencingMark.x1, sequencingMark.y1, 2);
       extendPoint(sequencingMark.x2, sequencingMark.y2, 2);
     }
+    const decorations = semantic ? flowDecorationsOf(semantic) : [];
+    decorations.forEach((decoration, index2) => {
+      const placement = flowDecorationGeometry(
+        geometry.label,
+        geometry.points ?? geometry.anchors,
+        geometry.source,
+        geometry.target,
+        index2,
+        decorations.length,
+        decoration.reversed === true
+      );
+      if (!placement) return;
+      edgeParts.push(`<polygon class="dflow-decoration ${decoration.keyword.replace(/\s+/gu, "-")}" points="${placement.chevron}"/>`);
+      const text = [decoration.name, decoration.label].filter(Boolean).join(" : ");
+      if (!text) return;
+      labelParts.push(labelSvg(text, placement.label.x, placement.label.y, "elabel flow"));
+      extendLabel(text, placement.label.x, placement.label.y);
+    });
     extendPoint(geometry.source.x, geometry.source.y, MARKER_ALLOWANCE);
     extendPoint(geometry.target.x, geometry.target.y, MARKER_ALLOWANCE);
     for (const point of geometry.points ?? geometry.anchors) extendPoint(point.x, point.y, MARKER_ALLOWANCE);
@@ -199231,14 +200663,22 @@ function buildDiagramSvg(options) {
       labelParts.push(labelSvg(semantic.label, labelPoint.x, labelPoint.y, `elabel ${semantic.kind}`));
       extendLabel(semantic.label, labelPoint.x, labelPoint.y);
     }
-    if (edge.data?.showMult) {
-      if (semantic?.endLabelFrom) {
-        labelParts.push(labelSvg(semantic.endLabelFrom, geometry.source.x, geometry.source.y, "elabel mult"));
-        extendLabel(semantic.endLabelFrom, geometry.source.x, geometry.source.y);
-      }
-      if (semantic?.endLabelTo) {
-        labelParts.push(labelSvg(semantic.endLabelTo, geometry.target.x, geometry.target.y, "elabel mult"));
-        extendLabel(semantic.endLabelTo, geometry.target.x, geometry.target.y);
+    if (semantic) {
+      for (const side of ["from", "to"]) {
+        const lines = connectionEndLabelLines(semantic, side, edge.data?.showMult === true);
+        if (!lines.length) continue;
+        const point = connectionEndLabelPoint(
+          geometry.points ?? geometry.anchors,
+          geometry.source,
+          geometry.target,
+          side
+        );
+        const role = side === "from" ? semantic.endRoleFrom : semantic.endRoleTo;
+        const adornment = side === "from" ? semantic.endAdornmentFrom : semantic.endAdornmentTo;
+        labelParts.push(!role && !adornment && lines.length === 1 ? labelSvg(lines[0], point.x, point.y, "elabel mult") : multilineLabelSvg(lines, point.x, point.y, "elabel connection-end"));
+        const widest = lines.reduce((longest, line2) => line2.length > longest.length ? line2 : longest, "");
+        extendLabel(widest, point.x, point.y);
+        extendPoint(point.x, point.y, lines.length * 6);
       }
     }
   }
@@ -199707,6 +201147,7 @@ var TOOLBOX = {
     elements: [
       el("part", "part", "\u25A2"),
       el("port", "port", "\u25AB"),
+      el("connection", "connection", "\u25AD"),
       el("attribute", "attribute", "\u2013"),
       el("item", "item", "\u25C7"),
       el("constraint", "constraint", "{}"),
@@ -199871,7 +201312,7 @@ var COMMON_USAGE_KINDS = [
 var CASE_CHILDREN = ["subject", "actor", "part", "attribute", "action", "item", "requirement"];
 var CHILD_KINDS = {
   package: ["package", ...DEFINITION_KINDS, ...COMMON_USAGE_KINDS],
-  part: ["part", "attribute", "port", "item", "constraint", "action", "state", "calc", "occurrence"],
+  part: ["part", "attribute", "port", "item", "connection", "constraint", "action", "state", "calc", "occurrence"],
   item: ["attribute", "port", "part", "item"],
   // REQ-006/REQ-192 — a port owns the features that describe what crosses
   // its boundary. Keep the direction in the creation choice so an IV user
@@ -199976,6 +201417,7 @@ function isWritableRelationEndpoint(endpoint) {
 }
 function directRelationForHandle(viewKind, endpoint) {
   if (!endpoint || !isWritableRelationEndpoint(endpoint)) return void 0;
+  if (viewKind === "iv" && (endpoint.connectionEnd || normalizedElementKeyword(endpoint.keyword).base === "connection end")) return "connectionEnd";
   return relationToolsForNode(endpoint.keyword, viewKind, endpoint.shape).find((tool) => tool.kind !== "terminate" && tool.kind !== "finish")?.kind;
 }
 var START_PSEUDOSTATE_BASES = /* @__PURE__ */ new Set(["start", "initial"]);
@@ -200066,6 +201508,65 @@ function relationToolsForNode(keyword, viewKind, shape) {
 var import_react7 = __toESM(require_react());
 var import_jsx_runtime3 = __toESM(require_jsx_runtime());
 var ptStr = (pts) => pts.map((p) => `${p[0].toFixed(1)},${p[1].toFixed(1)}`).join(" ");
+var GEO_VIEW_DIRECTION = [1, 1, 1];
+function dot3(a2, b) {
+  return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
+}
+function cross3(a2, b) {
+  return [
+    a2[1] * b[2] - a2[2] * b[1],
+    a2[2] * b[0] - a2[0] * b[2],
+    a2[0] * b[1] - a2[1] * b[0]
+  ];
+}
+function subtract3(a2, b) {
+  return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
+}
+function convexHull(points) {
+  const sorted = [...points].sort((a2, b) => a2[0] - b[0] || a2[1] - b[1]);
+  if (sorted.length <= 2) return sorted;
+  const turn = (a2, b, c) => (b[0] - a2[0]) * (c[1] - a2[1]) - (b[1] - a2[1]) * (c[0] - a2[0]);
+  const half = (input) => {
+    const result = [];
+    for (const point of input) {
+      while (result.length >= 2 && turn(result.at(-2), result.at(-1), point) <= 0) result.pop();
+      result.push(point);
+    }
+    return result;
+  };
+  const lower2 = half(sorted);
+  const upper = half([...sorted].reverse());
+  return [...lower2.slice(0, -1), ...upper.slice(0, -1)];
+}
+function polyhedronBody(node, f, localVertices, faces) {
+  const g = node.geo;
+  const center = geoWorldPoint(g, [0, 0, 0]);
+  const world = localVertices.map((point) => geoWorldPoint(g, point));
+  const visible = faces.flatMap((face, index2) => {
+    let points = face.map((vertex) => world[vertex]);
+    let normal = cross3(subtract3(points[1], points[0]), subtract3(points[2], points[0]));
+    const faceCenter = [
+      points.reduce((sum, point) => sum + point[0], 0) / points.length,
+      points.reduce((sum, point) => sum + point[1], 0) / points.length,
+      points.reduce((sum, point) => sum + point[2], 0) / points.length
+    ];
+    if (dot3(normal, subtract3(faceCenter, center)) < 0) {
+      points = [...points].reverse();
+      normal = [-normal[0], -normal[1], -normal[2]];
+    }
+    const normalLength = Math.hypot(normal[0], normal[1], normal[2]);
+    if (normalLength === 0 || dot3(normal, GEO_VIEW_DIRECTION) / (normalLength * Math.sqrt(3)) <= 1e-9) return [];
+    const absolute = normal.map(Math.abs);
+    const faceClass = absolute[2] >= absolute[0] && absolute[2] >= absolute[1] && normal[2] > 0 ? "top" : absolute[0] >= absolute[1] ? "side2" : "side";
+    return [{
+      key: index2,
+      faceClass,
+      depth: points.reduce((sum, point) => sum + dot3(point, GEO_VIEW_DIRECTION), 0) / points.length,
+      points: points.map((point) => geoProject(f, point[0], point[1], point[2]))
+    }];
+  }).sort((a2, b) => a2.depth - b.depth);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("g", { children: visible.map((face) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: `dgeo3d-face ${face.faceClass}`, points: ptStr(face.points) }, face.key)) });
+}
 var GEO_HANDLE_POSITION = {
   top: Position3.Top,
   right: Position3.Right,
@@ -200188,15 +201689,16 @@ function IsoAxes({ f, marker }) {
 }
 function geoShapeBody(node, f) {
   const g = node.geo;
-  const e = geoExtentOf(node, f.def);
+  const { hx, hy, hz } = geoHalfExtentsOf(node, f.def);
   const P = (x, y, z2) => geoProject(f, x, y, z2);
-  const { hx, hy, zlo, zhi } = e;
-  const cx = g.x;
-  const cy = g.y;
+  const PL = (point) => {
+    const world = geoWorldPoint(g, point);
+    return P(world[0], world[1], world[2]);
+  };
   switch (g.shape) {
     case "sphere": {
-      const c = P(cx, cy, (zlo + zhi) / 2);
-      const pts = [P(cx + hx, cy, e.zlo), P(cx - hx, cy, e.zlo), P(cx, cy + hy, e.zlo), P(cx, cy - hy, e.zlo), P(cx, cy, zhi), P(cx, cy, zlo)];
+      const c = PL([0, 0, 0]);
+      const pts = geoShapePoints(node, f.def).map((point) => P(point[0], point[1], point[2]));
       const r = Math.max(...pts.map((p) => Math.hypot(p[0] - c[0], p[1] - c[1])));
       return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("g", { children: [
         /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("circle", { className: "dgeo3d-face top", cx: c[0], cy: c[1], r }),
@@ -200205,64 +201707,79 @@ function geoShapeBody(node, f) {
     }
     case "cylinder":
     case "cone": {
-      const exr = (z2) => {
-        const c = P(cx, cy, z2);
-        const cardinals = [P(cx + hx, cy, z2), P(cx - hx, cy, z2), P(cx, cy + hy, z2), P(cx, cy - hy, z2)];
-        const rx = (Math.max(...cardinals.map((p) => p[0])) - Math.min(...cardinals.map((p) => p[0]))) / 2;
-        const ry = (Math.max(...cardinals.map((p) => p[1])) - Math.min(...cardinals.map((p) => p[1]))) / 2;
-        return { c, rx, ry };
-      };
-      const base = exr(zlo);
+      const ring = (z2) => Array.from({ length: 32 }, (_2, index2) => {
+        const angle = index2 * Math.PI / 16;
+        return [hx * Math.cos(angle), hy * Math.sin(angle), z2];
+      });
+      const baseLocal = ring(-hz);
+      const baseWorld = baseLocal.map((point) => geoWorldPoint(g, point));
+      const base = baseWorld.map((point) => P(point[0], point[1], point[2]));
       if (g.shape === "cone") {
-        const apex = P(cx, cy, zhi);
+        const apexWorld = geoWorldPoint(g, [0, 0, hz]);
+        const apex = P(apexWorld[0], apexWorld[1], apexWorld[2]);
+        const baseCenter = geoWorldPoint(g, [0, 0, -hz]);
+        const baseVisible = dot3(baseCenter, GEO_VIEW_DIRECTION) > dot3(apexWorld, GEO_VIEW_DIRECTION);
         return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("g", { children: [
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("ellipse", { className: "dgeo3d-face side", cx: base.c[0], cy: base.c[1], rx: base.rx, ry: base.ry }),
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face side2", points: ptStr([[base.c[0] - base.rx, base.c[1]], apex, [base.c[0] + base.rx, base.c[1]]]) }),
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("ellipse", { className: "dgeo3d-edge", cx: base.c[0], cy: base.c[1], rx: base.rx, ry: base.ry, fill: "none" })
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face side", points: ptStr(convexHull([...base, apex])) }),
+          baseVisible ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face top", points: ptStr(base) }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polyline", { className: "dgeo3d-edge", points: ptStr([...base, base[0]]), fill: "none", strokeDasharray: "3 3" })
         ] });
       }
-      const top = exr(zhi);
+      const topLocal = ring(hz);
+      const topWorld = topLocal.map((point) => geoWorldPoint(g, point));
+      const top = topWorld.map((point) => P(point[0], point[1], point[2]));
+      const baseDepth = dot3(geoWorldPoint(g, [0, 0, -hz]), GEO_VIEW_DIRECTION);
+      const topDepth = dot3(geoWorldPoint(g, [0, 0, hz]), GEO_VIEW_DIRECTION);
+      const near = topDepth >= baseDepth ? top : base;
+      const far = topDepth >= baseDepth ? base : top;
       return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("g", { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("ellipse", { className: "dgeo3d-edge", cx: base.c[0], cy: base.c[1], rx: base.rx, ry: base.ry, fill: "none", strokeDasharray: "3 3" }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face side", points: ptStr([[top.c[0] - top.rx, top.c[1]], [top.c[0] + top.rx, top.c[1]], [base.c[0] + base.rx, base.c[1]], [base.c[0] - base.rx, base.c[1]]]) }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("ellipse", { className: "dgeo3d-face top", cx: top.c[0], cy: top.c[1], rx: top.rx, ry: top.ry })
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face side", points: ptStr(convexHull([...base, ...top])) }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polyline", { className: "dgeo3d-edge", points: ptStr([...far, far[0]]), fill: "none", strokeDasharray: "3 3" }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face top", points: ptStr(near) })
       ] });
     }
     case "pyramid": {
-      const apex = P(cx, cy, zhi);
-      const bxp = P(cx + hx, cy - hy, zlo);
-      const bxp2 = P(cx + hx, cy + hy, zlo);
-      const byp = P(cx - hx, cy + hy, zlo);
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("g", { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face side2", points: ptStr([bxp, bxp2, apex]) }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face side", points: ptStr([byp, bxp2, apex]) }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polyline", { className: "dgeo3d-edge", points: ptStr([P(cx - hx, cy - hy, zlo), bxp, bxp2, byp, P(cx - hx, cy - hy, zlo)]), fill: "none" })
-      ] });
+      const vertices = [
+        [-hx, -hy, -hz],
+        [hx, -hy, -hz],
+        [hx, hy, -hz],
+        [-hx, hy, -hz],
+        [0, 0, hz]
+      ];
+      return polyhedronBody(node, f, vertices, [[0, 3, 2, 1], [0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4]]);
     }
     case "wedge": {
-      const rf = P(cx, cy - hy, zhi);
-      const rb = P(cx, cy + hy, zhi);
-      const blr = P(cx + hx, cy - hy, zlo);
-      const bur = P(cx + hx, cy + hy, zlo);
-      const bll = P(cx - hx, cy - hy, zlo);
-      const bul = P(cx - hx, cy + hy, zlo);
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("g", { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face side2", points: ptStr([blr, bur, rb, rf]) }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face top", points: ptStr([bll, bul, rb, rf]) }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face side", points: ptStr([bul, bur, rb]) })
-      ] });
+      const vertices = [
+        [-hx, -hy, -hz],
+        [hx, -hy, -hz],
+        [hx, hy, -hz],
+        [-hx, hy, -hz],
+        [0, -hy, hz],
+        [0, hy, hz]
+      ];
+      return polyhedronBody(node, f, vertices, [[0, 3, 2, 1], [0, 1, 4], [1, 2, 5, 4], [2, 3, 5], [3, 0, 4, 5]]);
     }
     case "box": {
-      const t = (sx, sy) => P(cx + sx * hx, cy + sy * hy, zhi);
-      const b = (sx, sy) => P(cx + sx * hx, cy + sy * hy, zlo);
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("g", { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face side2", points: ptStr([t(1, -1), t(1, 1), b(1, 1), b(1, -1)]) }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face side", points: ptStr([t(-1, 1), t(1, 1), b(1, 1), b(-1, 1)]) }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face top", points: ptStr([t(-1, -1), t(1, -1), t(1, 1), t(-1, 1)]) })
-      ] });
+      const vertices = [
+        [-hx, -hy, -hz],
+        [hx, -hy, -hz],
+        [hx, hy, -hz],
+        [-hx, hy, -hz],
+        [-hx, -hy, hz],
+        [hx, -hy, hz],
+        [hx, hy, hz],
+        [-hx, hy, hz]
+      ];
+      return polyhedronBody(node, f, vertices, [
+        [0, 3, 2, 1],
+        [4, 5, 6, 7],
+        [0, 1, 5, 4],
+        [1, 2, 6, 5],
+        [2, 3, 7, 6],
+        [3, 0, 4, 7]
+      ]);
     }
     default: {
-      const q = [P(cx - hx, cy - hy, zlo), P(cx + hx, cy - hy, zlo), P(cx + hx, cy + hy, zlo), P(cx - hx, cy + hy, zlo)];
+      const q = [PL([-hx, -hy, 0]), PL([hx, -hy, 0]), PL([hx, hy, 0]), PL([-hx, hy, 0])];
       return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polygon", { className: "dgeo3d-face top", points: ptStr(q) });
     }
   }
@@ -200285,6 +201802,7 @@ function GeoShapeNode({ id: id2, data, selected: selected2 }) {
   const dim = useInteraction(ctx.store, (s) => s.matchedIds ? !s.matchedIds.has(id2) : false);
   const origin = data.origin;
   const iso = data.geo3d && node.geo && origin;
+  const displayName = node.name.split(/::|\./u).filter(Boolean).at(-1) ?? node.name;
   const approx = node.geo?.approx;
   return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
     "div",
@@ -200300,7 +201818,10 @@ function GeoShapeNode({ id: id2, data, selected: selected2 }) {
         /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("svg", { className: "rf-node-svg", width: w, height: h, style: { overflow: "visible" }, children: [
           iso ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
             /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("g", { className: `dgeo3d-node${selected2 ? " selected" : ""}`, transform: `translate(${-origin.x},${-origin.y})`, children: geoShapeBody(node, data.geo3d) }),
-            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("text", { className: "dgeo3d-name", x: w / 2, y: -3, textAnchor: "middle", children: node.name })
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("text", { className: "dgeo3d-name", x: w / 2, y: -3, textAnchor: "middle", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("title", { children: node.name }),
+              displayName
+            ] })
           ] }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
             /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("rect", { className: `dnode-rect${selected2 ? " selected" : ""}`, x: 0, y: 0, width: w, height: h, rx: node.isDef ? 0 : 12 }),
             /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("text", { className: "dnode-label", x: w / 2, y: h / 2 + 3, textAnchor: "middle", children: node.name })
@@ -200521,7 +202042,7 @@ function usePortDrag(containerRef, w, h, topReserve, onPortMove, onPortPreview,
   };
   return { dragId, onPortPointerDown };
 }
-function DualHandle({ id: id2, side, x, y, kind, active, connectable = true, startable = false, size, occluded = false }) {
+function DualHandle({ id: id2, side, x, y, kind, active, connectable = true, startable = false, size, occluded = false, onContextMenu }) {
   const dimensions = typeof size === "number" ? { width: size, height: size } : size;
   const style2 = dimensions ? { left: x, top: y, ...dimensions, transform: "translate(-50%,-50%)" } : { left: x, top: y, transform: "translate(-50%,-50%)" };
   const enabled = connectable && !occluded;
@@ -200537,7 +202058,8 @@ function DualHandle({ id: id2, side, x, y, kind, active, connectable = true, sta
         className: cls,
         isConnectable: enabled,
         isConnectableStart: false,
-        isConnectableEnd: enabled
+        isConnectableEnd: enabled,
+        onContextMenu
       }
     ),
     /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
@@ -200550,7 +202072,8 @@ function DualHandle({ id: id2, side, x, y, kind, active, connectable = true, sta
         className: cls,
         isConnectable: enabled,
         isConnectableStart: enabled && startable,
-        isConnectableEnd: enabled
+        isConnectableEnd: enabled,
+        onContextMenu
       }
     )
   ] });
@@ -200892,7 +202415,15 @@ function AnnotationBody({ node, w, h }) {
 }
 function DotBody({ node, w, h }) {
   return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("g", { children: [
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("circle", { cx: w / 2, cy: h / 2, r: 5, fill: "var(--fg-2, #7e8aa1)" }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      "circle",
+      {
+        className: "dnode-control dot dconnection-end-dot",
+        cx: w / 2,
+        cy: h / 2,
+        r: circularControlRadius("dot")
+      }
+    ),
     node.name ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("text", { className: "dnode-kind", x: w / 2 + 9, y: h / 2 + 4, children: node.name }) : ""
   ] });
 }
@@ -200961,6 +202492,8 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
     };
   })() : void 0;
   const proxy = rect.proxy;
+  const connectionEnd = ph.port.meta?.connectionEndPin === true;
+  const glyphClass = `${selected2 ? " selected" : ""}${hovered ? " hovered" : ""}${moving ? " moving" : ""}${connectTargetSide ? " connect-target" : ""}`;
   return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
     "g",
     {
@@ -200990,10 +202523,10 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
             }
           );
         })() : null,
-        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        connectionEnd ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("circle", { className: `dconnection-end-dot${glyphClass}`, cx: x, cy: y, r: half }) : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
           "rect",
           {
-            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" : ""}`,
+            className: `dnode-port${ph.port.pin ? " pin" : ""}${ph.port.ref ? " ref" : ""}${rect.elongated ? " host" : ""}${proxy ? " proxy" : ""}${glyphClass}`,
             x: rect.x,
             y: rect.y,
             width: rect.width,
@@ -201001,12 +202534,12 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
             rx: ph.port.isDef ? 0 : PORT_CORNER_RADIUS
           }
         ),
-        d ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+        d && !connectionEnd ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
           /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("path", { className: "dport-dir", d: arrowShaft() }),
           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 && !proxy ? (() => {
+        selected2 && connectStart && !connectTargetSide && !proxy && !connectionEnd ? (() => {
           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: [
@@ -201014,7 +202547,7 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
             /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("line", { x1: px, y1: py - PORT_PLUS_HALF, x2: px, y2: py + PORT_PLUS_HALF })
           ] });
         })() : "",
-        connectTargetSide ? (() => {
+        connectTargetSide && !connectionEnd ? (() => {
           const at2 = portDockAt(rect, ph.side, connectTargetSide);
           return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("circle", { className: "dport-anchor", cx: at2.x, cy: at2.y, r: 1.7 });
         })() : "",
@@ -201270,7 +202803,7 @@ function NodeBody({ node, data, selectedPortId, hoveredPortId, movingPortId, con
         hovered: hoveredPortId === ph.port.id,
         moving: movingPortId === ph.port.id,
         connectTargetSide: connectTargetPortId === ph.port.id ? connectTargetPortSide : void 0,
-        connectStart: showPortConnectStart && (data.kind === "iv" ? ph.port.pin !== true : data.kind === "afv"),
+        connectStart: showPortConnectStart && (data.kind === "iv" ? ph.port.pin !== true || ph.port.meta?.connectionEndPin === true : data.kind === "afv"),
         onSelect: onPortSelect,
         onContext: onPortContext
       },
@@ -201322,15 +202855,16 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
     shape: node.shape,
     source: node.source
   });
-  const nodeSideStartable = directRelation !== void 0 && data.kind !== "sv" && node.shape !== "lifeline" && !isPackageEndpoint(node.shape, node.keyword);
+  const connectionUsage = node.meta?.connectionUsage === true || node.meta?.interfaceUsage === true;
+  const nodeSideStartable = !connectionUsage && directRelation !== void 0 && data.kind !== "sv" && node.shape !== "lifeline" && !isPackageEndpoint(node.shape, node.keyword);
   const selectedPortId = useInteraction(ctx.store, (s) => typeof s.selectedId === "string" && myPortIds.includes(s.selectedId) ? s.selectedId : void 0);
   const dropClass = useDropState(ctx.store, id2);
   const [hoveredPortId, setHoveredPortId] = (0, import_react9.useState)(void 0);
   const [sidePointsHovered, setSidePointsHovered] = (0, import_react9.useState)(false);
   const isPackageNode = isPackageEndpoint(node.shape, node.keyword);
-  const sideConnectable = data.kind !== "sv" && !isPackageNode;
+  const sideConnectable = data.kind !== "sv" && !isPackageNode && !connectionUsage;
   const perimeterControl = keepsPerimeterSidePointsMounted(node.shape);
-  const sideOffsets = SIDES.map((side) => mountedNodeSidePointOffsets(
+  const sideOffsets = connectionUsage ? SIDES.map(() => []) : SIDES.map((side) => mountedNodeSidePointOffsets(
     data,
     side,
     sideConnectable,
@@ -201453,17 +202987,39 @@ 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,
+          node.shape === "initial" || node.shape === "final" || node.shape === "dot" ? /* @__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 proxied = isProxyPort(ph.port);
             const startable = !proxied && directRelationForHandle(data.kind, {
               id: ph.port.id,
               name: ph.port.name,
-              keyword: ph.port.pin ? "pin" : "port",
+              keyword: ph.port.meta?.interfaceEndPort === true ? "interface end" : ph.port.meta?.connectionEndPin === true ? "connection end" : ph.port.pin ? "pin" : "port",
               shape: ph.port.pin ? "pin" : "port",
               source: ph.port.source
             }) !== void 0;
+            if (ph.port.meta?.connectionEndPin === true) {
+              const point = portDockAt(rect, ph.side, ph.side);
+              return [/* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+                DualHandle,
+                {
+                  id: portAnchorHandleId(ph.port.id, ph.side),
+                  side: ph.side,
+                  x: point.x,
+                  y: point.y,
+                  kind: "connection-end",
+                  connectable: !proxied,
+                  active: !proxied && (ph.port.id === hoveredPortId || ph.port.id === selectedPortId || ph.port.id === connectTargetPortId),
+                  startable,
+                  onContextMenu: (e) => {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    ctx.onContextNode(ph.port.id, e.clientX, e.clientY);
+                  }
+                },
+                `${ph.port.id}-end`
+              )];
+            }
             const [outerId, innerId] = portConnectHandleIds(ph.port.id, ph.side);
             const outer = portDockAt(rect, ph.side, ph.side);
             const innerSide = OPPOSITE_DOCK_SIDE[ph.side];
@@ -201504,7 +203060,7 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
             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);
+            const strip = portInteractionStrip(rect, ph.side, ph.port.meta?.connectionEndPin === true);
             return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
               "div",
               {
@@ -201875,7 +203431,7 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
               hovered: hoveredPortId === ph.port.id,
               moving: dragId === ph.port.id,
               connectTargetSide: connectTargetPortId === ph.port.id ? connectTargetPortSide : void 0,
-              connectStart: data.kind === "iv" ? ph.port.pin !== true : data.kind === "afv",
+              connectStart: data.kind === "iv" ? ph.port.pin !== true || ph.port.meta?.connectionEndPin === true : data.kind === "afv",
               onSelect: ctx.onPortMove ? void 0 : portSource,
               onContext: ctx.onContextNode
             },
@@ -201948,10 +203504,32 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
           const startable = !proxied && directRelationForHandle(data.kind, {
             id: ph.port.id,
             name: ph.port.name,
-            keyword: ph.port.pin ? "pin" : "port",
+            keyword: ph.port.meta?.interfaceEndPort === true ? "interface end" : ph.port.meta?.connectionEndPin === true ? "connection end" : ph.port.pin ? "pin" : "port",
             shape: ph.port.pin ? "pin" : "port",
             source: ph.port.source
           }) !== void 0;
+          if (ph.port.meta?.connectionEndPin === true) {
+            const point = portDockAt(rect, ph.side, ph.side);
+            return [/* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+              DualHandle,
+              {
+                id: portAnchorHandleId(ph.port.id, ph.side),
+                side: ph.side,
+                x: point.x,
+                y: point.y,
+                kind: "connection-end",
+                connectable: !proxied,
+                active: !proxied && (ph.port.id === hoveredPortId || ph.port.id === selectedPortId || ph.port.id === connectTargetPortId),
+                startable,
+                onContextMenu: (e) => {
+                  e.preventDefault();
+                  e.stopPropagation();
+                  ctx.onContextNode(ph.port.id, e.clientX, e.clientY);
+                }
+              },
+              `${ph.port.id}-end`
+            )];
+          }
           const [outerId, innerId] = portConnectHandleIds(ph.port.id, ph.side);
           const outer = portDockAt(rect, ph.side, ph.side);
           const innerSide = OPPOSITE_DOCK_SIDE[ph.side];
@@ -201992,7 +203570,7 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
           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);
+          const strip = portInteractionStrip(rect, ph.side, ph.port.meta?.connectionEndPin === true);
           return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
             "div",
             {
@@ -202323,7 +203901,7 @@ async function renderDiagramSvg(document2, provider, options) {
     overrides: config.overrides,
     connectPointSpacing: config.connectPointSpacing
   });
-  const renderEdges = kind === "gv" && config.gvMode === "tree" && config.lineStyle === "orthogonal" ? projectIndividualGvTreeRenderEdges(laid.nodes, laid.edges, createEdgeBundleRuntime()) : laid.edges;
+  const renderEdges = config.lineStyle === "orthogonal" ? projectAutomaticBusRenderEdges(laid.nodes, laid.edges, createEdgeBundleRuntime()) : laid.edges;
   const indexOf2 = new Map(laid.nodes.map((node, i) => [node.id, i]));
   return buildDiagramSvg({
     nodes: laid.nodes,
@@ -202379,7 +203957,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.22.0" : "dev";
+var VERSION2 = true ? "0.24.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;