sysml-diagram 0.20.3 → 0.21.1

package/out/main.js

@@ -161733,9 +161733,16 @@ function nameOf(node) {
   const name = node?.name;
   if (typeof name === "string" && name.length > 0)
     return name;
-  if (node?.$type === "FeatureRedefinitionShorthand") {
-    const leading = node.preRelationships?.[0]?.targets?.[0];
-    return leading ? lastSegment(leading) : void 0;
+  const relational = node;
+  for (const relationship of [
+    ...relational?.preRelationships ?? [],
+    ...relational?.relationships ?? []
+  ]) {
+    if (relationship.kind !== ":>>" && relationship.kind !== "redefines")
+      continue;
+    const target = relationship.targets?.[0];
+    if (target)
+      return lastSegment(target);
   }
   if (node?.$type === "FeatureShorthand") {
     const text = node.$cstNode?.text;
@@ -161752,9 +161759,16 @@ function nameOf(node) {
   return void 0;
 }
 function unwrap(node) {
-  if (node.$type !== "PrefixMetadataMember")
-    return node;
-  return node.element ?? node;
+  let current2 = node;
+  const seen = /* @__PURE__ */ new Set();
+  while ((current2.$type === "PrefixMetadataMember" || current2.$type === "MemberPrefixDecl") && !seen.has(current2)) {
+    seen.add(current2);
+    const element = current2.element;
+    if (!element)
+      break;
+    current2 = element;
+  }
+  return current2;
 }
 function directNamedChildren(node) {
   const result = [];
@@ -161785,12 +161799,32 @@ function isSelfReference(candidate, node) {
 function lastSegment(path10) {
   return path10.split(/::|\./u).pop() ?? path10;
 }
+function simpleRelationName(path10) {
+  let quoted = false;
+  for (let index2 = 0; index2 < path10.length; index2 += 1) {
+    const char = path10[index2];
+    if (quoted) {
+      if (char === "\\")
+        index2 += 1;
+      else if (char === "'")
+        quoted = false;
+      continue;
+    }
+    if (char === "'")
+      quoted = true;
+    else if (char === "." || char === ":" && path10[index2 + 1] === ":")
+      return void 0;
+  }
+  const withoutMultiplicity = path10.replace(/\s*\[[^\]]*\]\s*$/u, "").trim();
+  return withoutMultiplicity ? canonicalEscapedName(withoutMultiplicity) : void 0;
+}
 var FeaturePathResolver = class {
   indexManager;
   descriptions;
   documents;
   locator;
   snapshots = /* @__PURE__ */ new WeakMap();
+  resolvingSpecializations = /* @__PURE__ */ new Set();
   constructor(services) {
     this.indexManager = services?.shared.workspace.IndexManager;
     this.descriptions = services?.workspace.AstNodeDescriptionProvider;
@@ -161893,6 +161927,14 @@ var FeaturePathResolver = class {
     }
     return result;
   }
+  /** Semantic owners reached through typing and specialization. This is used
+   * when an anonymous redefinition has no keyword from which to recover its
+   * feature kind. */
+  // REQ-364: recover the semantic kind of an anonymous local redefinition.
+  inheritedOwners(node) {
+    const root4 = ast_utils_exports.getDocument(node).parseResult.value;
+    return this.typedAndSpecializedOwners(node, this.snapshot(root4));
+  }
   segmentsOf(node) {
     const cst = node.$cstNode;
     if (!cst)
@@ -162038,20 +162080,45 @@ var FeaturePathResolver = class {
     return typed;
   }
   specializationTargets(node, snapshot) {
+    if (this.resolvingSpecializations.has(node))
+      return [];
+    this.resolvingSpecializations.add(node);
     const relNode = node;
     const result = [];
-    for (const relation of [...relNode.preRelationships ?? [], ...relNode.relationships ?? []]) {
-      if (!relation.kind || !SPECIALIZATION_KINDS.has(relation.kind))
-        continue;
-      for (const target of relation.targets ?? []) {
-        const description = this.pickDescription(snapshot.byName.get(target)) ?? this.pickDescription(snapshot.byName.get(lastSegment(target)));
-        const resolved = this.nodeOf(description);
-        if (resolved)
-          result.push(resolved);
+    try {
+      for (const relation of [...relNode.preRelationships ?? [], ...relNode.relationships ?? []]) {
+        if (!relation.kind || !SPECIALIZATION_KINDS.has(relation.kind))
+          continue;
+        for (const target of relation.targets ?? []) {
+          const simple = simpleRelationName(target);
+          const scoped = simple ? this.scopedSpecializationTarget(node, simple, snapshot) : void 0;
+          const description = scoped ? void 0 : this.pickDescription(snapshot.byName.get(target), node) ?? this.pickDescription(snapshot.byName.get(lastSegment(target)), node);
+          const resolved = scoped ?? this.nodeOf(description);
+          if (resolved)
+            result.push(resolved);
+        }
       }
+    } finally {
+      this.resolvingSpecializations.delete(node);
     }
     return result;
   }
+  /** A simple feature specialization is resolved in the visible inventory of
+   * its lexical owner. Only an absent scoped match may fall back to the global
+   * index, which prevents an unrelated same-named feature from winning. */
+  scopedSpecializationTarget(node, name, snapshot) {
+    for (let scope = node.$container; scope; scope = scope.$container) {
+      const local = directNamedChildren(scope).find((candidate) => candidate !== node && nameOf(candidate) === name);
+      if (local)
+        return local;
+      for (const owner of this.typedAndSpecializedOwners(scope, snapshot)) {
+        const inherited = directNamedChildren(owner).find((candidate) => candidate !== node && nameOf(candidate) === name);
+        if (inherited)
+          return inherited;
+      }
+    }
+    return void 0;
+  }
   memberInventoryKnown(node, snapshot) {
     const record = node;
     if (record.isDef === true || node.$type === "ClassDecl" || node.$type === "StructDecl" || node.$type === "EnumDecl" || node.$type === "DatatypeDecl" || node.$type === "FunctionDecl" || node.$type === "PredicateDecl") {
@@ -162243,14 +162310,21 @@ function sourceOf2(node, uri) {
     return { uri, range };
   }
 }
+function isAstDescendantOrSelf(node, ancestor) {
+  for (let current2 = node; current2; current2 = current2.$container) {
+    if (current2 === ancestor)
+      return true;
+  }
+  return false;
+}
 function ivEditMeta(part, instanceId, definition, localUsage, localPath, uri) {
-  const declarationId = qnameOf(part) || instanceId;
+  const declarationId = nameOf2(part) ? qnameOf(part) || instanceId : instanceId;
   const definitionId = definition ? qnameOf(definition) : void 0;
   const localUsageId = localUsage ? qnameOf(localUsage) : void 0;
   return {
     instanceId,
     declarationId,
-    declarationName: nameOf2(part),
+    declarationName: effectiveNameOf(part),
     declarationSource: sourceOf2(part, uri),
     definitionId,
     definitionName: definition ? nameOf2(definition) : void 0,
@@ -162259,7 +162333,10 @@ function ivEditMeta(part, instanceId, definition, localUsage, localPath, uri) {
     localUsageName: localUsage ? nameOf2(localUsage) : void 0,
     localUsageSource: localUsage ? sourceOf2(localUsage, uri) : void 0,
     localUsagePath: [...localPath],
-    expandedFromDefinition: declarationId !== instanceId
+    expandedFromDefinition: declarationId !== instanceId,
+    // A named declaration remains local even when an anonymous `:>>`
+    // wrapper removes its name from the rendered occurrence path.
+    localDeclaration: !!nameOf2(part) && !!localUsage && isAstDescendantOrSelf(part, localUsage)
   };
 }
 var nameOf2 = (node) => {
@@ -162466,6 +162543,16 @@ function specializationTargets(node) {
   }
   return out;
 }
+function featureInheritanceTargets(node) {
+  const n2 = node;
+  const out = [];
+  for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
+    if (rel2.kind === ":>" || rel2.kind === ":>>" || rel2.kind === "specializes" || rel2.kind === "subsets" || rel2.kind === "redefines") {
+      out.push(...rel2.targets ?? []);
+    }
+  }
+  return out;
+}
 function specializationFamily(node) {
   const n2 = node;
   const isDef = n2.isDef === true;
@@ -162498,8 +162585,37 @@ function disjointTargets(node) {
   return out;
 }
 var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
+  shared;
   perParseCache = /* @__PURE__ */ new WeakMap();
   featurePaths = new FeaturePathResolver();
+  annotationFeaturePaths = /* @__PURE__ */ new Map();
+  indexEpoch = 0;
+  // REQ-210 — Annotation graphics
+  // Shared services are optional so pure single-document tests stay cheap. In
+  // production they provide both workspace documents and the linker's private
+  // lazy library documents used by inherited members.
+  constructor(shared) {
+    this.shared = shared;
+    shared?.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => {
+      this.indexEpoch += 1;
+    });
+  }
+  externalDocumentRoot(uri) {
+    if (!this.shared)
+      return void 0;
+    const parsed = URI2.parse(uri);
+    try {
+      const services = this.shared.ServiceRegistry.getServices(parsed);
+      const linker = services.references.Linker;
+      const linked = linker.resolveDocumentRoot?.(parsed);
+      if (linked)
+        return linked;
+    } catch {
+    }
+    if (!this.shared.workspace.LangiumDocuments.hasDocument(parsed))
+      return void 0;
+    return this.shared.workspace.LangiumDocuments.getDocument(parsed)?.parseResult?.value;
+  }
   perParse(root4) {
     let entry = this.perParseCache.get(root4);
     if (!entry) {
@@ -162528,12 +162644,57 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const key = `${kind}\0${preferFileOverview ? "F" : "-"}\0${rootSymbol ?? ""}`;
     const cacheKey = kind === "grv" ? `${key}::${gridPreset}${gridPreset === "matrix" ? `::${matrixRelationship}` : ""}` : key;
     const hit = cache.models.get(cacheKey);
+    if (hit && hit.indexEpoch === this.indexEpoch && this.externalRootsAreCurrent(hit.externalRoots))
+      return hit.model;
     if (hit)
-      return hit;
+      cache.models.delete(cacheKey);
     const model = this.computeDiagramModel(document2, root4, rootSymbol, kind, preferFileOverview, gridPreset, matrixRelationship);
-    cache.models.set(cacheKey, model);
+    const externalRoots = this.externalRootsOf(model, document2.uri.toString());
+    model.dependencies = [document2.uri.toString(), ...externalRoots.keys()];
+    cache.models.set(cacheKey, {
+      model,
+      externalRoots,
+      indexEpoch: this.indexEpoch
+    });
     return model;
   }
+  // REQ-210 — Annotation graphics
+  // A model may project members and notes from another document. The anchor's
+  // parse identity does not change when that source file is edited, so validate
+  // those dependency roots before returning a warm per-anchor cache entry.
+  externalRootsAreCurrent(roots) {
+    for (const [uri, root4] of roots) {
+      if (this.externalDocumentRoot(uri) !== root4)
+        return false;
+    }
+    return true;
+  }
+  externalRootsOf(model, anchorUri) {
+    const uris = /* @__PURE__ */ new Set();
+    const add = (source) => {
+      if (source?.uri && source.uri !== anchorUri)
+        uris.add(source.uri);
+    };
+    const seen = /* @__PURE__ */ new Set();
+    const addSources = (value) => {
+      if (!value || typeof value !== "object" || seen.has(value))
+        return;
+      seen.add(value);
+      if (Array.isArray(value)) {
+        for (const item of value)
+          addSources(item);
+        return;
+      }
+      const record = value;
+      if (typeof record.uri === "string" && record.range && typeof record.range === "object") {
+        add(record);
+      }
+      for (const nested of Object.values(record))
+        addSources(nested);
+    };
+    addSources(model);
+    return new Map([...uris].map((uri) => [uri, this.externalDocumentRoot(uri)]));
+  }
   computeDiagramModel(document2, root4, rootSymbol, kind, preferFileOverview, gridPreset = "requirements", matrixRelationship = "allocation") {
     const uri = document2.uri.toString();
     const empty2 = (note) => ({
@@ -162549,28 +162710,126 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return empty2(`No anchor element found for the ${kind.toUpperCase()} view.`);
     const ctx = { uri, index: index2, anchor, gridPreset, matrixRelationship };
     const overview = isPackage(anchor) || isDocument(anchor);
-    switch (kind) {
-      case "gv":
-        return this.buildGeneralView(ctx);
-      case "iv":
-        return overview ? this.buildInterconnectionOverview(ctx) : this.buildInterconnectionView(ctx);
-      case "afv":
-        return overview ? this.buildActionFlowOverview(ctx) : this.buildActionFlowView(ctx);
-      case "stv":
-        return overview ? this.buildStateTransitionOverview(ctx) : this.buildStateTransitionView(ctx);
-      case "sv":
-        return overview ? this.buildSequenceOverview(ctx) : this.buildSequenceView(ctx);
-      case "cv":
-        return this.buildCaseView(ctx);
-      case "gev":
-        return overview ? this.buildGeometryOverview(ctx) : this.buildGeometryView(ctx);
-      case "grv":
-        return this.buildGridView(ctx);
-      case "bv":
-        return this.buildBrowserView(ctx);
-      default:
-        return empty2(`Unsupported diagram kind ${kind}.`);
+    const build = () => {
+      switch (kind) {
+        case "gv":
+          return this.buildGeneralView(ctx);
+        case "iv":
+          return overview ? this.buildInterconnectionOverview(ctx) : this.buildInterconnectionView(ctx);
+        case "afv":
+          return overview ? this.buildActionFlowOverview(ctx) : this.buildActionFlowView(ctx);
+        case "stv":
+          return overview ? this.buildStateTransitionOverview(ctx) : this.buildStateTransitionView(ctx);
+        case "sv":
+          return overview ? this.buildSequenceOverview(ctx) : this.buildSequenceView(ctx);
+        case "cv":
+          return this.buildCaseView(ctx);
+        case "gev":
+          return overview ? this.buildGeometryOverview(ctx) : this.buildGeometryView(ctx);
+        case "grv":
+          return this.buildGridView(ctx);
+        case "bv":
+          return this.buildBrowserView(ctx);
+        default:
+          return empty2(`Unsupported diagram kind ${kind}.`);
+      }
+    };
+    return this.withNotes(build(), root4, index2, uri);
+  }
+  // REQ-210 — Annotation graphics
+  // issue #229: attach the modeled notes of every DRAWN element to that
+  // element, on every view.
+  //
+  // The General View builds its own richer annotation pass (comment + rep +
+  // metadata, with package placement), the Browser View lists annotations as
+  // tree rows, and the Grid View is a table, so all three are left untouched.
+  // Every other view gets its notes here, once, after the builder (and its
+  // overview tiling / id prefixing) has settled the final node ids.
+  //
+  // A `comment` is always a note. A `doc` documents its owner and already has
+  // a textual home in that owner's `doc` compartment (issue #107), so it only
+  // becomes a note on the views that draw no compartments at all.
+  withNotes(model, root4, index2, uri) {
+    if (model.kind === "gv" || model.kind === "bv" || model.kind === "grv")
+      return model;
+    const docAsNote = model.kind === "sv" || model.kind === "gev";
+    const drawn = /* @__PURE__ */ new Map();
+    const externalUris = /* @__PURE__ */ new Set();
+    const key = (source) => source && `${source.uri}:${source.range.start.line}:${source.range.start.character}`;
+    const claim = (source, target) => {
+      const k = key(source);
+      if (!k)
+        return;
+      if (source && source.uri !== uri)
+        externalUris.add(source.uri);
+      const list = drawn.get(k);
+      if (list)
+        list.push(target);
+      else
+        drawn.set(k, [target]);
+    };
+    for (const n2 of model.nodes) {
+      claim(n2.source, { id: n2.id, parent: n2.parent, frame: n2.frame });
+      for (const port of n2.ports ?? []) {
+        claim(port.source, { id: port.id, parent: n2.parent, frame: n2.frame, port: true });
+      }
     }
+    for (const f of model.frames ?? []) {
+      claim(f.source, { id: f.id, frame: f.id });
+      for (const port of f.ports ?? []) {
+        claim(port.source, { id: port.id, frame: f.id, port: true });
+      }
+    }
+    if (model.ivBoundary) {
+      claim(model.ivBoundary.source, { id: model.ivBoundary.id, frame: model.ivBoundary.id });
+      for (const port of model.ivBoundary.ports ?? []) {
+        claim(port.source, { id: port.id, frame: model.ivBoundary.id, port: true });
+      }
+    }
+    if (!drawn.size)
+      return model;
+    const nodes = [...model.nodes];
+    const edges = [...model.edges];
+    let noteCount = 0;
+    let edgeCount = edges.length;
+    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({
+          id: id2,
+          name: annotation.label,
+          keyword: annotation.keyword,
+          isDef: false,
+          shape: "annotation",
+          type: annotation.body,
+          // Sit in the same container as the element the note is about,
+          // so the note travels with it instead of floating at the root.
+          ...target.parent ? { parent: target.parent } : {},
+          ...target.frame ? { frame: target.frame } : {},
+          source: sourceOf2(annotation.annotation, uri)
+        });
+        edges.push({
+          id: `e${edgeCount++}`,
+          from: id2,
+          to: target.id,
+          kind: "annotation",
+          source: sourceOf2(annotation.annotation, uri)
+        });
+      }
+    };
+    for (const annotation of this.semanticAnnotations(root4, index2))
+      note(annotation);
+    for (const externalUri of externalUris) {
+      const externalRoot = this.externalDocumentRoot(externalUri);
+      if (externalRoot) {
+        for (const annotation of this.semanticAnnotations(externalRoot, this.localIndex(externalRoot)))
+          note(annotation);
+      }
+    }
+    return noteCount ? { ...model, nodes, edges } : model;
   }
   // REQ-224 — Detect the file/anchor-specific view kinds that will render
   // substantive diagram content. The extension uses this to limit the
@@ -162649,6 +162908,132 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     cache.contents = contents;
     return contents;
   }
+  // REQ-210 — Annotation graphics
+  // Keep the whole-document filter out of each view build. Target resolution
+  // remains live because the workspace index can become more complete without
+  // reparsing the document.
+  annotationMembers(root4) {
+    const cache = this.perParse(root4);
+    if (cache.annotations)
+      return cache.annotations;
+    const comments = [];
+    const docs = [];
+    for (const node of [root4, ...this.rootContents(root4)]) {
+      if (node.$type === "CommentStmt")
+        comments.push(node);
+      else if (node.$type === "DocCommentMember")
+        docs.push(node);
+    }
+    cache.annotations = { comments, docs };
+    return cache.annotations;
+  }
+  // REQ-210 — Annotation graphics
+  // Resolve a document's modeled annotations once for every workspace-index
+  // epoch. Different diagram kinds then only match semantic owners to their
+  // rendered source identities instead of walking and resolving the AST again.
+  semanticAnnotations(root4, index2) {
+    const cache = this.perParse(root4);
+    if (cache.semanticAnnotations?.epoch === this.indexEpoch)
+      return cache.semanticAnnotations.values;
+    const members = this.annotationMembers(root4);
+    const values2 = [];
+    for (const comment of members.comments) {
+      const rawTargets = comment.targets ?? [];
+      const owners = rawTargets.length ? this.commentTargets(comment, index2) : [comment.$container];
+      for (const owner of owners) {
+        if (!owner)
+          continue;
+        values2.push({
+          annotation: comment,
+          owner,
+          keyword: "comment",
+          label: nameOf2(comment) ?? "comment",
+          body: annotationText(trailingBlockBody(comment))
+        });
+      }
+    }
+    for (const doc of members.docs) {
+      if (!doc.$container)
+        continue;
+      values2.push({
+        annotation: doc,
+        owner: doc.$container,
+        keyword: "doc",
+        label: nameOf2(doc) ?? "doc",
+        body: annotationText(docCommentBody(doc))
+      });
+    }
+    cache.semanticAnnotations = { epoch: this.indexEpoch, values: values2 };
+    return values2;
+  }
+  annotationPathResolver(node) {
+    if (!this.shared)
+      return this.featurePaths;
+    try {
+      const services = this.shared.ServiceRegistry.getServices(ast_utils_exports.getDocument(node).uri);
+      let resolver = this.annotationFeaturePaths.get(services);
+      if (!resolver) {
+        resolver = new FeaturePathResolver(services);
+        this.annotationFeaturePaths.set(services, resolver);
+      }
+      return resolver;
+    } catch {
+      return this.featurePaths;
+    }
+  }
+  annotationDescriptionNode(context, description) {
+    if (!description)
+      return void 0;
+    if (!this.shared)
+      return description.node;
+    try {
+      const services = this.shared.ServiceRegistry.getServices(ast_utils_exports.getDocument(context).uri);
+      const linker = services.references.Linker;
+      return linker.resolveIndexedNode?.(description) ?? description.node;
+    } catch {
+      return description.node;
+    }
+  }
+  // REQ-210 — Annotation graphics
+  /** Resolve every `comment about` target by semantic path identity. */
+  commentTargets(comment, index2) {
+    const rawTargets = comment.targets ?? [];
+    if (!rawTargets.length)
+      return [];
+    const root4 = this.documentRootOf(comment);
+    const all = [root4, ...this.rootContents(root4)];
+    const resolver = this.annotationPathResolver(comment);
+    const resolved = rawTargets.map((raw, occurrence) => {
+      const segment = resolver.resolvePropertyPath(comment, "targets", occurrence).segments.at(-1);
+      const linked = segment?.target ?? this.annotationDescriptionNode(comment, segment?.description);
+      if (linked)
+        return linked;
+      const path10 = this.featurePath(raw)?.trim();
+      if (!path10)
+        return void 0;
+      const unrooted = path10.replace(/^\s*\$\s*::\s*/u, "");
+      if (!/::|\./u.test(unrooted)) {
+        for (let scope = comment.$container; scope; scope = scope.$container) {
+          const local = membersOf(scope).find((member) => member !== comment && nameOf2(member) === unrooted);
+          if (local)
+            return local;
+          const declaringIndex = this.localIndex(this.documentRootOf(scope));
+          for (const inherited of this.inheritedFeatureOwnersOf(scope, declaringIndex)) {
+            const inheritedMember = membersOf(inherited).find((member) => nameOf2(member) === unrooted);
+            if (inheritedMember)
+              return inheritedMember;
+          }
+        }
+        return index2.get(unrooted);
+      }
+      const qualified = all.filter((candidate) => {
+        const qname = qnameOf(candidate);
+        return qname.length > 0 && pathMatchesQName(unrooted, qname);
+      });
+      return qualified.length === 1 ? qualified[0] : void 0;
+    }).filter((target) => target !== void 0);
+    return [...new Set(resolved)];
+  }
   // REQ-192/REQ-193 — prefer Langium's linked typing target. The diagram's
   // local index deliberately contains only the active document, so consulting
   // it alone drops structure declared in an imported workspace/library file
@@ -162698,6 +163083,98 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     }
     return chain;
   }
+  // REQ-061/REQ-192/REQ-364 - the effective feature owners inherited by a
+  // definition or usage. A redefining usage specializes both its explicit type
+  // and the feature it redefines. The latter can contribute its own body and its
+  // type's complete inventory, so following only typing definitions turns an
+  // anonymous `part :>> inheritedPart` into an empty leaf.
+  inheritedFeatureOwnersOf(node, index2) {
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set([node]);
+    const queue = [];
+    const add = (candidate) => {
+      if (!candidate || seen.has(candidate))
+        return;
+      seen.add(candidate);
+      chain.push(candidate);
+      queue.push(candidate);
+    };
+    const addTargets = (owner) => {
+      for (const target of featureInheritanceTargets(owner)) {
+        add(this.resolveFeatureInheritanceTarget(owner, target, index2));
+      }
+    };
+    if (node.isDef === true)
+      addTargets(node);
+    else {
+      add(this.resolveType(node, index2));
+      addTargets(node);
+    }
+    while (queue.length > 0) {
+      const owner = queue.shift();
+      if (owner.isDef !== true)
+        add(this.resolveType(owner, index2));
+      addTargets(owner);
+    }
+    return chain;
+  }
+  /** Declaration that an anonymous local redefinition specializes. Direct edits
+   * in definition-sync mode address this feature, while child insertion still
+   * addresses the feature's typing definition. */
+  synchronizationDeclarationOf(node, index2) {
+    if (nameOf2(node))
+      return node;
+    const wanted = effectiveNameOf(node);
+    return this.inheritedFeatureOwnersOf(node, index2).find((candidate) => candidate.isDef !== true && effectiveNameOf(candidate) === wanted && (isPartDecl(node) ? isPartDecl(candidate) : isPortDecl(node) ? isPortDecl(candidate) : true));
+  }
+  /** Resolve a usage specialization in its feature scope. A simple `:>> x`
+   * names a sibling supplied by the containing usage or one of its types. A
+   * global simple-name lookup can select the redeclaration itself or an
+   * unrelated namesake, so the containing feature inventory is checked first. */
+  resolveFeatureInheritanceTarget(owner, target, index2) {
+    const path10 = this.resolvedFeatureInheritancePath(owner, target);
+    if (path10.qualified) {
+      return path10.target === owner ? void 0 : path10.target;
+    }
+    if (owner.isDef !== true) {
+      const wanted = lastSeg(target);
+      const container = owner.$container;
+      if (container) {
+        for (const source of [container, ...this.inheritedFeatureOwnersOf(container, index2)]) {
+          const inherited = membersOf(source).find((member) => member !== owner && effectiveNameOf(member) === wanted);
+          if (inherited)
+            return inherited;
+        }
+      }
+    }
+    const resolved = path10.target ?? this.resolveSpecializationTarget(owner, target, index2);
+    return resolved === owner ? void 0 : resolved;
+  }
+  /** Resolve a relationship target through the shared feature path service.
+   * Qualified paths must retain every segment because a last-segment lookup can
+   * select an unrelated sibling with the same name. */
+  resolvedFeatureInheritancePath(owner, target) {
+    const relationships = [
+      ...owner.preRelationships ?? [],
+      ...owner.relationships ?? []
+    ];
+    const resolver = this.annotationPathResolver(owner);
+    for (const relationship of relationships) {
+      if (!relationship.kind || ![":>", ":>>", "specializes", "subsets", "redefines"].includes(relationship.kind))
+        continue;
+      for (const [occurrence, written] of (relationship.targets ?? []).entries()) {
+        if (written !== target)
+          continue;
+        const resolution = resolver.resolvePropertyPath(relationship, "targets", occurrence);
+        const segment = resolution.segments.at(-1);
+        return {
+          qualified: resolution.segments.length > 1,
+          target: segment?.target ?? this.annotationDescriptionNode(owner, segment?.description)
+        };
+      }
+    }
+    return { qualified: /::|\./u.test(target) };
+  }
   // issue #233 (PR #239 review) — one supertype path, resolved. A specialization
   // target is path TEXT in this grammar, not a cross-reference, so there is no
   // linked node to prefer the way `resolveType` prefers `typing.type.ref`; the
@@ -163173,7 +163650,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     return this.collectGeometry(node, index2).length > 0;
   }
   hasRenderablePorts(node, index2) {
-    return [node, ...this.inheritedTypesOf(node, index2)].some((source) => membersOf(source).some((m) => isPortDecl(m) && m.isDef !== true));
+    return [node, ...this.inheritedFeatureOwnersOf(node, index2)].some((source) => membersOf(source).some((m) => isPortDecl(m) && m.isDef !== true));
   }
   // REQ-192, issue #233 — the named part usages a part shows when expanded: its
   // own and the ones it inherits, through its typing definition or a `:>`
@@ -163181,7 +163658,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // The predicate form of `childUsagesOf`, so an anchor that only INHERITS
   // internals is recognised as having them.
   hasNestedPartUsages(node, index2) {
-    return [node, ...this.inheritedTypesOf(node, index2)].some((source) => this.nestedUsages(source, isPartDecl).some((n2) => nameOf2(n2) !== void 0));
+    return [node, ...this.inheritedFeatureOwnersOf(node, index2)].some((source) => this.nestedUsages(source, isPartDecl).some((n2) => nameOf2(n2) !== void 0));
   }
   nestedUsages(node, guard) {
     return membersOf(node).filter((m) => guard(m) && m.isDef !== true);
@@ -163723,8 +164200,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       }
     }
     let annotationCount = 0;
-    const annotate = (m, keyword, label, detail, target) => {
-      const owner = target ?? m.$container;
+    const annotate = (m, keyword, label, detail, targets) => {
       const annId = `__annotation_${annotationCount++}__`;
       nodes.push({
         id: annId,
@@ -163736,17 +164212,33 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         ...packageOf2(m),
         source: sourceOf2(m, uri)
       });
-      if (owner && ids.has(owner)) {
-        edges.push({ id: `e${e++}`, from: annId, to: ids.get(owner), kind: "annotation", source: sourceOf2(m, uri) });
+      const owners = targets?.length ? targets : m.$container ? [m.$container] : [];
+      for (const owner of new Set(owners)) {
+        if (!ids.has(owner))
+          continue;
+        edges.push({
+          id: `e${e++}`,
+          from: annId,
+          to: ids.get(owner),
+          kind: "annotation",
+          source: sourceOf2(m, uri)
+        });
       }
     };
+    const drawnAnnotationTarget = (target) => {
+      for (let current2 = target; current2; current2 = current2.$container) {
+        if (ids.has(current2))
+          return current2;
+      }
+      return void 0;
+    };
     for (const m of all) {
       if (m.$type === "CommentStmt") {
-        const targets = m.targets ?? [];
-        const target = targets.length ? byName.get(lastSeg(String(this.featurePath(targets[0]) ?? ""))) : void 0;
-        if (targets.length && !target)
+        const rawTargets = m.targets ?? [];
+        const targets = rawTargets.length ? this.commentTargets(m, index2).map(drawnAnnotationTarget).filter((target) => target !== void 0) : void 0;
+        if (rawTargets.length && !targets?.length)
           continue;
-        annotate(m, "comment", nameOf2(m) ?? "comment", annotationText(trailingBlockBody(m)), target);
+        annotate(m, "comment", nameOf2(m) ?? "comment", annotationText(trailingBlockBody(m)), targets);
       } else if (m.$type === "RepStmt") {
         const lang = `language "${String(m.language ?? "")}"`;
         const body = annotationText(trailingBlockBody(m));
@@ -163757,7 +164249,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           continue;
         const body = annotationText(docCommentBody(m));
         if (body)
-          annotate(m, "doc", nameOf2(m) ?? "doc", body, owner);
+          annotate(m, "doc", nameOf2(m) ?? "doc", body, owner ? [owner] : void 0);
       } else if (isMetadataDecl(m) && m.isDef !== true && (nameOf2(m) || typeText(m)) && !ids.has(m)) {
         const attrs = metadataAttrsText(m);
         const detail = typeText(m) ? `${typeText(m)}${attrs ? ` { ${attrs} }` : ""}` : attrs;
@@ -163836,7 +164328,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const childUsagesOf = (part) => {
       const out = this.nestedUsages(part, isPartDecl);
       const have = new Set(out.map(effectiveNameOf).filter((x) => !!x));
-      for (const source of this.inheritedTypesOf(part, index2)) {
+      for (const source of this.inheritedFeatureOwnersOf(part, index2)) {
         for (const usage of this.nestedUsages(source, isPartDecl)) {
           const nm = effectiveNameOf(usage);
           if (nm !== void 0) {
@@ -163849,7 +164341,27 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       }
       return out;
     };
-    const effectiveMembersOf = (part) => [part, ...this.inheritedTypesOf(part, index2)].flatMap((source) => membersOf(source));
+    const effectiveMembersOf = (part) => {
+      const effective = [];
+      const claimedNames = /* @__PURE__ */ new Set();
+      for (const source of [part, ...this.inheritedFeatureOwnersOf(part, index2)]) {
+        for (const member of membersOf(source)) {
+          const relationship = member;
+          const emptyPrefixFlow = member.$type === "FlowStmt" && relationship.target !== void 0 && relationship.source === void 0;
+          const emptyPrefixInterface = isInterfaceDecl(member) && relationship.target !== void 0 && relationship.connect === void 0;
+          const namedRelationship = isConnectorDecl(member) || isConnectionDecl(member) || isInterfaceDecl(member) && !emptyPrefixInterface || member.$type === "BindingDecl" || member.$type === "FlowStmt" && !emptyPrefixFlow;
+          if (namedRelationship) {
+            const names = [nameOf2(member), redefinedNameOf(member)].filter((name) => name !== void 0);
+            if (names.some((name) => claimedNames.has(name)))
+              continue;
+            for (const name of names)
+              claimedNames.add(name);
+          }
+          effective.push(member);
+        }
+      }
+      return effective;
+    };
     const childResolver = (childInfos, self2, actionInfos = []) => {
       const localPort = /* @__PURE__ */ new Map();
       const actionPort = /* @__PURE__ */ new Map();
@@ -163927,14 +164439,22 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return { resolve: resolve8, actionPinIds };
     };
     const renderInstance = (part, instanceId, parentFrame, seenTypes, depth, inheritedLocalUsage, inheritedLocalPath = []) => {
-      const ports = this.portsOf(part, index2, uri, instanceId).ports;
-      const typeDef = part.isDef === true ? void 0 : this.resolveType(part, index2);
+      const typeDef = part.isDef === true ? void 0 : this.resolveType(part, index2) ?? this.inheritedFeatureOwnersOf(part, index2).find((owner) => owner.isDef === true);
       const typeQ = typeDef ? qnameOf(typeDef) : void 0;
-      const declarationId = qnameOf(part) || instanceId;
-      const projected = declarationId !== instanceId;
+      const declarationId = nameOf2(part) ? qnameOf(part) || instanceId : instanceId;
+      const projected = nameOf2(part) === void 0 || declarationId !== instanceId;
       const localUsage = part.isDef !== true && !projected ? part : inheritedLocalUsage;
       const localPath = part.isDef !== true && !projected ? [] : inheritedLocalPath;
-      const editMeta = ivEditMeta(part, instanceId, typeDef, localUsage, localPath, uri);
+      const ports = this.portsOf(part, index2, uri, instanceId, localUsage).ports;
+      const syncDeclaration = this.synchronizationDeclarationOf(part, index2);
+      const editMeta = {
+        ...ivEditMeta(part, instanceId, typeDef, localUsage, localPath, uri),
+        ...syncDeclaration && syncDeclaration !== part ? {
+          syncDeclarationId: qnameOf(syncDeclaration),
+          syncDeclarationName: effectiveNameOf(syncDeclaration),
+          syncDeclarationSource: sourceOf2(syncDeclaration, uri)
+        } : {}
+      };
       const children2 = depth < 8 && !(typeQ !== void 0 && seenTypes.has(typeQ)) ? childUsagesOf(part) : [];
       const concretePerformPath = (statement, target) => {
         if (!this.isAnonymousBehaviorReference(statement)) {
@@ -163978,16 +164498,31 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       }).filter((entry, i, list) => list.findIndex((other) => other.key === entry.key) === i) : [];
       const performedActionInfos = performedActions.map(({ act, pinSource, pathSegments, name, key }) => {
         const id2 = `${instanceId}::__perform_${key}`;
+        const inheritedFromDefinition = !!localUsage && !isAstDescendantOrSelf(act, localUsage);
+        const syncDeclaration2 = this.synchronizationDeclarationOf(act, index2);
         return {
           act,
           name,
           id: id2,
           pathSegments,
-          pins: this.actionPinPorts(pinSource, id2, index2, uri)
+          pins: this.actionPinPorts(pinSource, id2, index2, uri),
+          meta: {
+            ...ivEditMeta(act, id2, void 0, localUsage, [...localPath, name], uri),
+            ivAction: true,
+            // A performed action projected from a typed part belongs
+            // to the shared definition. Local IV edits cannot safely
+            // materialize an action redefinition yet.
+            ivInheritedAction: inheritedFromDefinition,
+            ...syncDeclaration2 && syncDeclaration2 !== act ? {
+              syncDeclarationId: qnameOf(syncDeclaration2),
+              syncDeclarationName: effectiveNameOf(syncDeclaration2),
+              syncDeclarationSource: sourceOf2(syncDeclaration2, uri)
+            } : {}
+          }
         };
       });
       const emitOwnedActions = (frameOf) => {
-        for (const { act, name, id: actId, pins } of performedActionInfos) {
+        for (const { act, name, id: actId, pins, meta } of performedActionInfos) {
           nodes.push({
             id: actId,
             name,
@@ -163999,7 +164534,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
             ports: pins,
             frame: frameOf,
             source: sourceOf2(act, uri),
-            meta: { ivAction: true }
+            meta
           });
         }
       };
@@ -164026,7 +164561,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         }
         emitOwnedActions(instanceId);
         const resolver = childResolver(childInfos, { usage: part, id: instanceId }, performedActionInfos);
-        this.emitInterconnectEdges(effectiveMembersOf(part), resolver.resolve, children2, index2, uri, nodes, edges, eRef, instanceId, resolver.actionPinIds);
+        this.emitInterconnectEdges(effectiveMembersOf(part), resolver.resolve, children2, index2, uri, nodes, edges, eRef, instanceId, resolver.actionPinIds, part);
       } else {
         nodes.push({
           id: instanceId,
@@ -164042,12 +164577,37 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           source: sourceOf2(part, uri),
           meta: editMeta
         });
+        const resolver = childResolver([], { usage: part, id: instanceId });
+        this.emitInterconnectEdges(effectiveMembersOf(part), resolver.resolve, [], index2, uri, nodes, edges, eRef, instanceId, resolver.actionPinIds, part);
       }
     };
     const packageOfRoot = (root4) => enclosingPackage(root4) ?? scope;
+    const rootBaseId = (root4) => qnameOf(root4) || nameOf2(root4) || `__root_${root4.$cstNode?.offset ?? 0}__`;
+    const rootsByBaseId = /* @__PURE__ */ new Map();
+    for (const root4 of roots) {
+      const base = rootBaseId(root4);
+      rootsByBaseId.set(base, [...rootsByBaseId.get(base) ?? [], root4]);
+    }
+    const rootOccurrenceIds = /* @__PURE__ */ new Map();
+    for (const [base, sameNameRoots] of rootsByBaseId) {
+      if (sameNameRoots.length === 1) {
+        rootOccurrenceIds.set(sameNameRoots[0], base);
+        continue;
+      }
+      const discriminatorCounts = /* @__PURE__ */ new Map();
+      const inSourceOrder = [...sameNameRoots].sort((a2, b) => (a2.$cstNode?.offset ?? 0) - (b.$cstNode?.offset ?? 0));
+      for (const root4 of inSourceOrder) {
+        const semanticIdentity = [typeText(root4), ...featureInheritanceTargets(root4)].filter((part) => !!part).join("_") || root4.$type;
+        const discriminator = semanticIdentity.replace(/[^A-Za-z0-9_]+/gu, "_").replace(/^_+|_+$/gu, "") || "part";
+        const occurrence = discriminatorCounts.get(discriminator) ?? 0;
+        discriminatorCounts.set(discriminator, occurrence + 1);
+        const suffix = occurrence === 0 ? discriminator : `${discriminator}_${occurrence + 1}`;
+        rootOccurrenceIds.set(root4, `${base}::__occurrence_${suffix}`);
+      }
+    }
     const rootInfos = [];
     for (const root4 of roots) {
-      const id2 = qnameOf(root4) || nameOf2(root4) || `__root_${nodes.length + frames.length}__`;
+      const id2 = rootOccurrenceIds.get(root4) ?? rootBaseId(root4);
       renderInstance(root4, id2, opts.packageFrames ? ensurePkgFrame(enclosingPackage(root4)) : void 0, /* @__PURE__ */ new Set(), 0, root4.isDef === true ? void 0 : root4, []);
       rootInfos.push({ usage: root4, id: id2, pkg: packageOfRoot(root4) });
     }
@@ -164056,7 +164616,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         const localInfos = rootInfos.filter((r) => r.pkg === pkg && r.usage.isDef !== true);
         const localRoots = localInfos.map((r) => r.usage);
         const resolver = childResolver(localInfos);
-        this.emitInterconnectEdges(membersOf(pkg), resolver.resolve, localRoots, index2, uri, nodes, edges, eRef, void 0, resolver.actionPinIds);
+        this.emitInterconnectEdges(membersOf(pkg), resolver.resolve, localRoots, index2, uri, nodes, edges, eRef, void 0, resolver.actionPinIds, pkg);
       }
     }
     return { nodes, edges, frames };
@@ -164089,8 +164649,23 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // single Interconnection View (called once over the anchor's whole subtree)
   // and the package overview (called once per container part, tagging any
   // synthetic n-ary dot with that container's frame id).
-  emitInterconnectEdges(members, resolveEnd, parts, index2, uri, nodes, edges, eRef, frameId, actionPinIds = /* @__PURE__ */ new Set()) {
+  emitInterconnectEdges(members, resolveEnd, parts, index2, uri, nodes, edges, eRef, frameId, actionPinIds = /* @__PURE__ */ new Set(), memberOwner) {
     const memberList2 = [...members];
+    const relationshipFields = (source) => {
+      let directMember = source;
+      while (directMember.$container && directMember.$container !== memberOwner) {
+        directMember = directMember.$container;
+      }
+      const inherited = !!memberOwner && directMember.$container !== memberOwner;
+      const meta = {
+        ...inherited ? { ivInheritedRelation: true } : {},
+        ...frameId ? { ivRelationshipOwnerId: frameId } : {}
+      };
+      return {
+        source: sourceOf2(source, uri),
+        ...Object.keys(meta).length > 0 ? { meta } : {}
+      };
+    };
     const supportsEndpoints = (kind, ids) => {
       const pinCount = ids.filter((id2) => actionPinIds.has(id2)).length;
       if (pinCount === 0)
@@ -164116,7 +164691,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           label,
           endLabelFrom: multText(resolvedEnds[0].end),
           endLabelTo: multText(resolvedEnds[1].end),
-          source: sourceOf2(src, uri)
+          ...relationshipFields(src)
         });
         return;
       }
@@ -164133,7 +164708,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           isDef: false,
           label,
           endLabelTo: multText(end),
-          source: sourceOf2(src, uri)
+          ...relationshipFields(src)
         });
       }
     };
@@ -164178,7 +164753,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
                 to: endId,
                 kind: "connect",
                 endLabelTo: multText(end),
-                source: sourceOf2(m, uri)
+                ...relationshipFields(m)
               });
             }
           }
@@ -164198,7 +164773,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
               // REQ-179 — connector end multiplicities (`connect [1] a to [0..*] b;`)
               endLabelFrom: multText(srcEnd),
               endLabelTo: multText(tgtEnd),
-              source: sourceOf2(m, uri)
+              ...relationshipFields(m)
             });
           }
         }
@@ -164216,7 +164791,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
             to,
             kind: "flow",
             label: this.flowPayloadText(fm) ?? typeText(m) ?? nameOf2(m),
-            source: sourceOf2(m, uri)
+            ...relationshipFields(m)
           });
         }
       } else if (m.$type === "BindStmt" || m.$type === "BindingConnectorStmt" || m.$type === "BindingDecl") {
@@ -164239,7 +164814,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
             // of its own (issue #120 review).
             endLabelFrom: multText(leftEnd) ?? multText(bn),
             endLabelTo: multText(rightEnd),
-            source: sourceOf2(m, uri)
+            ...relationshipFields(m)
           });
         }
       } else if (isInterfaceDecl(m) && m.isDef !== true) {
@@ -164262,7 +164837,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
               label,
               endLabelFrom: multText(clause.source),
               endLabelTo: multText(clause.target),
-              source: sourceOf2(m, uri)
+              ...relationshipFields(m)
             });
           }
         }
@@ -164289,7 +164864,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
                 isDef: false,
                 label,
                 endLabelTo: multText(end),
-                source: sourceOf2(m, uri)
+                ...relationshipFields(m)
               });
             }
           }
@@ -164308,7 +164883,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
               label,
               endLabelFrom: multText(clause.source),
               endLabelTo: multText(clause.target),
-              source: sourceOf2(m, uri)
+              ...relationshipFields(m)
             });
           }
         }
@@ -164329,7 +164904,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const all = [...ast_utils_exports.streamAllContents(scope)];
     const isUsagePart = (n2) => isPartDecl(n2) && n2.isDef !== true && nameOf2(n2) !== void 0;
     const isDefPart = (n2) => isPartDecl(n2) && n2.isDef === true && nameOf2(n2) !== void 0;
-    const hasInternalParts = (d) => [d, ...this.inheritedTypesOf(d, index2)].some((source) => this.nestedUsages(source, isPartDecl).length > 0);
+    const hasInternalParts = (d) => [d, ...this.inheritedFeatureOwnersOf(d, index2)].some((source) => this.nestedUsages(source, isPartDecl).length > 0);
     const insideAPart = (n2) => {
       let c = n2.$container;
       while (c && c !== scope) {
@@ -168046,7 +168621,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   }
   // REQ-175, REQ-193 — collect a node's ports (own + inherited from its type
   // def) as stubs, plus a "usageName.portName" → portId resolution map.
-  portsOf(node, index2, uri, ownerId) {
+  portsOf(node, index2, uri, ownerId, localUsage) {
     const ports = [];
     const map3 = /* @__PURE__ */ new Map();
     const visibleNames = /* @__PURE__ */ new Set();
@@ -168058,23 +168633,50 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const portId = parentPortId ? `${parentPortId}.${pn}` : `${ownerId}.${pn}`;
       const rel2 = parentPath ? `${parentPath}.${pn}` : pn;
       let direction = directionOf(portNode);
-      const portTypeDef = this.resolveType(portNode, index2);
+      const inheritedOwners = this.inheritedFeatureOwnersOf(portNode, index2);
+      const directPortTypeDef = this.resolveType(portNode, index2);
+      const inheritedPortUsages = inheritedOwners.filter((owner) => isPortDecl(owner) && owner.isDef !== true);
+      const inheritedTyping = inheritedPortUsages.map((owner) => ({ owner, type: this.resolveType(owner, index2) })).find((entry) => entry.type !== void 0);
+      const portTypeDef = directPortTypeDef ?? inheritedTyping?.type ?? inheritedOwners.find((owner) => isPortDecl(owner) && owner.isDef === true);
+      const inheritedDirection = inheritedPortUsages.map(directionOf).find((candidate) => candidate !== void 0);
+      direction ??= inheritedDirection;
+      const referenceTraitOf = (candidate) => {
+        const modifiers2 = candidate.modifiers ?? [];
+        if (modifiers2.includes("ref"))
+          return true;
+        if (modifiers2.includes("composite"))
+          return false;
+        return void 0;
+      };
+      const inheritedReference = inheritedPortUsages.map(referenceTraitOf).find((candidate) => candidate !== void 0);
+      const reference = referenceTraitOf(portNode) ?? inheritedReference;
+      const hasDirectTyping = portNode.typing !== void 0;
+      const effectiveConjugated = hasDirectTyping ? isConjugated(portNode) : inheritedTyping ? isConjugated(inheritedTyping.owner) : false;
       if (!direction) {
         const conjugated = isConjugated(portNode);
-        const dirs = /* @__PURE__ */ new Set([
-          ...this.ownDirectedFeatureDirections(portNode, conjugated),
-          ...portTypeDef ? this.effectivePortDirections(portTypeDef, index2, conjugated) : []
-        ]);
+        const dirs = this.ownDirectedFeatureDirections(portNode, conjugated);
+        for (const inheritedUsage of inheritedPortUsages) {
+          const inheritedConjugated = conjugated !== isConjugated(inheritedUsage);
+          for (const inheritedDirection2 of this.ownDirectedFeatureDirections(inheritedUsage, inheritedConjugated)) {
+            dirs.add(inheritedDirection2);
+          }
+        }
+        const typeConjugated = directPortTypeDef ? conjugated : inheritedTyping ? conjugated !== isConjugated(inheritedTyping.owner) : conjugated;
+        if (portTypeDef) {
+          for (const inheritedDirection2 of this.effectivePortDirections(portTypeDef, index2, typeConjugated)) {
+            dirs.add(inheritedDirection2);
+          }
+        }
         direction = dirs.size === 1 ? [...dirs][0] : dirs.size > 1 ? "inout" : void 0;
       }
       const port = {
         id: portId,
         name: pn,
-        type: typeText(portNode),
+        type: typeText(portNode) ?? (inheritedTyping ? typeText(inheritedTyping.owner) : void 0),
         direction,
-        conjugated: isConjugated(portNode) || void 0,
+        conjugated: effectiveConjugated || void 0,
         // REQ-194 — reference ports render with a dashed outline
-        ref: (portNode.modifiers ?? []).includes("ref") || void 0,
+        ref: reference || void 0,
         isDef: portNode.isDef === true,
         // issue #108 — a nested port carries its parent's id so the webview
         // stacks it on the parent glyph and docks connectors on it.
@@ -168089,18 +168691,27 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         // projection origin to choose a direct edit or a usage-local
         // `port :>> name { ... }` materialization.
         meta: {
-          declarationId: qnameOf(portNode) || portId,
+          declarationId: nameOf2(portNode) ? qnameOf(portNode) || portId : portId,
           declarationName: pn,
           inheritedFromType,
+          localDeclaration: !inheritedFromType && !!nameOf2(portNode) && !!localUsage && isAstDescendantOrSelf(portNode, localUsage),
           definitionId: portTypeDef ? qnameOf(portTypeDef) : void 0,
           definitionName: portTypeDef ? nameOf2(portTypeDef) : void 0,
-          definitionSource: portTypeDef ? sourceOf2(portTypeDef, uri) : void 0
+          definitionSource: portTypeDef ? sourceOf2(portTypeDef, uri) : void 0,
+          ...(() => {
+            const syncDeclaration = this.synchronizationDeclarationOf(portNode, index2);
+            return syncDeclaration && syncDeclaration !== portNode ? {
+              syncDeclarationId: qnameOf(syncDeclaration),
+              syncDeclarationName: effectiveNameOf(syncDeclaration),
+              syncDeclarationSource: sourceOf2(syncDeclaration, uri)
+            } : {};
+          })()
         }
       };
       if (usageName)
         map3.set(`${usageName}.${rel2}`, portId);
       map3.set(`${ownerId}.${rel2}`, portId);
-      return { port, portTypeDef };
+      return { port, portTypeDef, inheritedOwners };
     };
     const addNested = (portNode, made, inheritedFromType, path10, depth, seenTypes) => {
       if (depth > NESTED_PORT_MAX_DEPTH)
@@ -168112,8 +168723,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const nestedSources = [
         // declared in this port usage's body: as local as its parent is
         ...membersOf(portNode).map((member) => ({ member, inherited: inheritedFromType })),
-        // declared in the port's type: always a projection of that type
-        ...made.portTypeDef && !repeatedType ? membersOf(made.portTypeDef).map((member) => ({ member, inherited: true })) : []
+        // every effective owner contributes its body, nearest first
+        ...!repeatedType ? made.inheritedOwners.flatMap((owner) => membersOf(owner).map((member) => ({ member, inherited: true }))) : []
       ];
       for (const { member, inherited } of nestedSources) {
         if (!isPortDecl(member) || member.isDef === true)
@@ -168143,7 +168754,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     for (const m of membersOf(node))
       if (isPortDecl(m) && m.isDef !== true)
         addPort(m, false);
-    for (const inherited of this.inheritedTypesOf(node, index2)) {
+    for (const inherited of this.inheritedFeatureOwnersOf(node, index2)) {
       for (const m of membersOf(inherited))
         if (isPortDecl(m) && m.isDef !== true)
           addPort(m, true);
@@ -168246,20 +168857,20 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   inheritedItems(node, index2, uri) {
     if (node.isDef === true)
       return [];
-    const def = this.resolveType(node, index2);
-    if (!def)
-      return [];
-    const localRedefined = /* @__PURE__ */ new Set();
-    for (const m of membersOf(node)) {
-      for (const rel2 of [...m.preRelationships ?? [], ...m.relationships ?? []]) {
-        if (rel2.kind === ":>>" || rel2.kind === "redefines") {
-          for (const t of rel2.targets ?? [])
-            localRedefined.add(lastSeg(t));
-        }
+    const hiddenNames = new Set(membersOf(node).map(effectiveNameOf).filter((name) => name !== void 0));
+    const inherited = [];
+    for (const owner of this.inheritedFeatureOwnersOf(node, index2)) {
+      for (const member of membersOf(owner)) {
+        const name = effectiveNameOf(member);
+        if (!name || hiddenNames.has(name))
+          continue;
+        hiddenNames.add(name);
+        if (!isAttributeDecl(member) || member.isDef === true)
+          continue;
+        inherited.push({ member, source: sourceOf2(member, uri) });
       }
     }
-    const localNames = new Set(membersOf(node).map((m) => nameOf2(m)).filter(Boolean));
-    return membersOf(def).filter((m) => isAttributeDecl(m) && m.isDef !== true && nameOf2(m)).filter((m) => !localRedefined.has(nameOf2(m)) && !localNames.has(nameOf2(m))).map((member) => ({ member, source: sourceOf2(member, uri) }));
+    return inherited;
   }
   compartmentsFor(node, uri, index2, featureRows = false, includeInherited = true) {
     const members = membersOf(node);
@@ -178003,6 +178614,20 @@ var SysmlLinker = class extends DefaultLinker {
   resolveIndexedNode(nodeDescription) {
     return this.loadAstNode(nodeDescription);
   }
+  // REQ-210 — Annotation graphics
+  /**
+   * Return the parsed root for a live workspace or lazily loaded library file.
+   * Diagram projection uses this to collect annotations declared beside an
+   * inherited member without adding standard-library files to the workspace.
+   */
+  resolveDocumentRoot(uri) {
+    const live = this.langiumDocuments().getDocument(uri)?.parseResult?.value;
+    if (live)
+      return live;
+    if (!isStandardLibraryUri(uri))
+      return void 0;
+    return this.parsedLibraryDocument(uri)?.parseResult?.value;
+  }
   /** Parse (once) the standard-library file a precomputed description points at.
    *  Prefers an already-live workspace document when one exists (runtime-loaded
    *  library, or the user opened the file) so there is never a second copy. */
@@ -181882,7 +182507,8 @@ function portGlyphRect(g, w, h, topReserve = 0) {
     y: cy - height / 2,
     width,
     height,
-    elongated: across > natural
+    elongated: across > natural,
+    proxy: g.port.meta?.proxy === true
   };
 }
 function hostMarkAcrossShift(rect) {
@@ -181890,7 +182516,7 @@ function hostMarkAcrossShift(rect) {
   return -(rect.across / 2 - NESTED_PORT_HOST_CLEAR / 2);
 }
 function portDockAlongShift(rect) {
-  if (!rect.elongated) return 0;
+  if (!rect.elongated || rect.proxy) return 0;
   return rect.along / 2 - NESTED_PORT_END_PAD / 2;
 }
 function portDockAt(rect, side, dockSide) {
@@ -182200,6 +182826,7 @@ function portLabelPlacement(side, x, y, label, half = PORT_GLYPH_HALF, alongHalf
 }
 var SEQ_MSG_TOP = 76;
 var SEQ_MSG_GAP = 46;
+var SEQ_NOTE_GAP = 40;
 function sequenceSlotBoundaryY(slot) {
   return SEQ_MSG_TOP + (slot - 0.5) * SEQ_MSG_GAP;
 }
@@ -182298,6 +182925,12 @@ function gvNodeCategory(node) {
   };
   return alias[k] ?? "other";
 }
+function withoutOrphanedAnnotations(original, nodes, edges) {
+  const originallyAttached = new Set(original.edges.filter((edge) => edge.kind === "annotation").map((edge) => edge.from));
+  if (originallyAttached.size === 0) return nodes;
+  const stillAttached = new Set(edges.filter((edge) => edge.kind === "annotation").map((edge) => edge.from));
+  return nodes.filter((node) => node.shape !== "annotation" || !originallyAttached.has(node.id) || stillAttached.has(node.id));
+}
 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)));
@@ -182308,7 +182941,7 @@ function applyGvFilters(model, hidden) {
     for (const p of n2.ports ?? []) keptIds.add(p.id);
   }
   const edges = model.edges.filter((e) => keptIds.has(e.from) && keptIds.has(e.to));
-  return { ...model, nodes, edges };
+  return { ...model, nodes: withoutOrphanedAnnotations(model, nodes, edges), edges };
 }
 var PAD = 10;
 var NODE_W = 168;
@@ -182577,8 +183210,8 @@ function collapseNestedPorts(model, expanded2) {
   }).filter((e) => {
     if (e.from === e.to) return false;
     const key = `${e.from}\0${e.to}\0${e.kind}\0${e.label ?? ""}`;
-    if (seenEdge.has(key)) return false;
-    seenEdge.add(key);
+    if (seenEdge.has(`${key}:${e.id}`)) return false;
+    seenEdge.add(`${key}:${e.id}`);
     return true;
   });
   return {
@@ -182627,11 +183260,17 @@ function assignPortHandles(ports, overrides, ownerShape) {
         label + reserved
       ),
       across: portGlyphAcross(kidMetrics.map((k) => k.across))
+    } : isProxyPort(port) ? {
+      along: Math.max(
+        natural,
+        tw(`${port.conjugated ? "~" : ""}${port.name}`, 9) + 2 * NESTED_PORT_END_PAD + (port.direction ? NESTED_PORT_CHEVRON_RUN : 0)
+      ),
+      across: portGlyphAcross()
     } : { along: natural + reserved, across: natural };
     metrics.set(port.id, m);
     return m;
   };
-  const alongOf = (port) => hasToggle(port) ? metricsOf(port).along : void 0;
+  const alongOf = (port) => hasToggle(port) || isProxyPort(port) ? metricsOf(port).along : void 0;
   const place = (list, side) => {
     const n2 = list.length;
     const alongs = list.map(alongOf);
@@ -182805,9 +183444,10 @@ function applyCaseDefs(model, show) {
   if (hidden.size === 0) return model;
   const edges = model.edges.filter((e) => !hidden.has(e.from) && !hidden.has(e.to));
   const retainedEndpoints = new Set(edges.flatMap((edge) => [edge.from, edge.to]));
+  const nodes = model.nodes.filter((n2) => !hidden.has(n2.id) && (n2.meta?.cvAuxiliary !== true || retainedEndpoints.has(n2.id)));
   return {
     ...model,
-    nodes: model.nodes.filter((n2) => !hidden.has(n2.id) && (n2.meta?.cvAuxiliary !== true || retainedEndpoints.has(n2.id))),
+    nodes: withoutOrphanedAnnotations(model, nodes, edges),
     edges
   };
 }
@@ -182887,7 +183527,51 @@ function applyBehaviorFilters(model, filters) {
     ...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, edges };
+  return { ...model, frames: nextFrames, nodes: withoutOrphanedAnnotations(model, nodes, edges), edges };
+}
+function isProxyPort(port) {
+  return port.meta?.proxy === true;
+}
+var PROXY_LAYOUT_PREFIX = "proxy:";
+function proxyPortFor(port, path10, hostId) {
+  const stand = {
+    ...port,
+    name: path10,
+    layoutKey: `${PROXY_LAYOUT_PREFIX}${hostId}:${port.layoutKey ?? port.id}`,
+    meta: { ...port.meta, proxy: true, proxyFor: port.id, proxyPath: path10, proxyName: port.name }
+  };
+  delete stand.parentPort;
+  return stand;
+}
+function proxyPathOf(port, ownerId, hostId, containerLabel, containerOf, portById) {
+  const segments = [port.name];
+  const seenPorts = /* @__PURE__ */ new Set([port.id]);
+  for (let cur = port.parentPort; cur !== void 0 && !seenPorts.has(cur); cur = portById.get(cur)?.parentPort) {
+    seenPorts.add(cur);
+    const parent = portById.get(cur);
+    if (!parent) break;
+    segments.unshift(parent.name);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let cur = ownerId; cur !== void 0 && cur !== hostId && !seen.has(cur); cur = containerOf(cur)) {
+    seen.add(cur);
+    const label = containerLabel(cur);
+    if (label) segments.unshift(label);
+  }
+  return segments.join(".");
+}
+function proxyPortsByHost(referenced, hostOf, ownerOf, containerLabel, containerOf, portById) {
+  const byHost = /* @__PURE__ */ new Map();
+  for (const portId of referenced) {
+    const host = hostOf.get(portId);
+    const entry = ownerOf.get(portId);
+    if (host === void 0 || entry === void 0) continue;
+    const path10 = proxyPathOf(entry.port, entry.owner, host, containerLabel, containerOf, portById);
+    const list = byHost.get(host);
+    if (list) list.push(proxyPortFor(entry.port, path10, host));
+    else byHost.set(host, [proxyPortFor(entry.port, path10, host)]);
+  }
+  return byHost;
 }
 function collapseIvModel(model, hiddenInternals) {
   const frames = model.frames ?? [];
@@ -182918,12 +183602,72 @@ function collapseIvModel(model, hiddenInternals) {
   };
   const hiddenFrameIds = new Set(frames.filter((f) => belongsToCollapsedRoot(f.id, false)).map((f) => f.id));
   const hiddenNodeIds = new Set(model.nodes.filter((n2) => belongsToCollapsedRoot(n2.frame ?? n2.parent, true)).map((n2) => n2.id));
-  const hiddenEndpoints = /* @__PURE__ */ new Set([...hiddenFrameIds, ...hiddenNodeIds]);
-  for (const f of frames) if (hiddenFrameIds.has(f.id)) for (const p of f.ports ?? []) hiddenEndpoints.add(p.id);
-  for (const n2 of model.nodes) if (hiddenNodeIds.has(n2.id)) for (const p of n2.ports ?? []) hiddenEndpoints.add(p.id);
+  const nodeById = new Map(model.nodes.map((n2) => [n2.id, n2]));
+  const containerOf = (id2) => {
+    const frame2 = frameById.get(id2);
+    if (frame2) return frame2.parent;
+    const node = nodeById.get(id2);
+    return node ? node.frame ?? node.parent : void 0;
+  };
+  const containerLabel = (id2) => frameById.get(id2)?.label ?? nodeById.get(id2)?.name;
+  const rootFor = (id2) => {
+    const seen = /* @__PURE__ */ new Set();
+    for (let cur = id2; cur !== void 0 && !seen.has(cur); cur = containerOf(cur)) {
+      if (roots.has(cur)) return cur;
+      seen.add(cur);
+    }
+    return void 0;
+  };
+  const ownerOfHiddenPort = /* @__PURE__ */ new Map();
+  for (const f of frames) if (hiddenFrameIds.has(f.id)) for (const p of f.ports ?? []) ownerOfHiddenPort.set(p.id, { port: p, owner: f.id });
+  for (const n2 of model.nodes) if (hiddenNodeIds.has(n2.id)) for (const p of n2.ports ?? []) ownerOfHiddenPort.set(p.id, { port: p, owner: n2.id });
+  const hiddenPortById = new Map([...ownerOfHiddenPort].map(([id2, entry]) => [id2, entry.port]));
+  const proxyHost = /* @__PURE__ */ new Map();
+  for (const [portId, entry] of ownerOfHiddenPort) {
+    const root4 = rootFor(entry.owner);
+    if (root4 !== void 0) proxyHost.set(portId, root4);
+  }
+  const bodyDock = /* @__PURE__ */ new Map();
+  for (const id2 of [...hiddenFrameIds, ...hiddenNodeIds]) {
+    const root4 = rootFor(id2);
+    if (root4 !== void 0) bodyDock.set(id2, root4);
+  }
+  const hidden = /* @__PURE__ */ new Set([...hiddenFrameIds, ...hiddenNodeIds, ...ownerOfHiddenPort.keys()]);
+  const containerRootOf = (id2) => proxyHost.get(id2) ?? bodyDock.get(id2);
+  const seenEdge = /* @__PURE__ */ new Set();
+  const edges = model.edges.filter((e) => {
+    const fromRoot = containerRootOf(e.from);
+    const toRoot = containerRootOf(e.to);
+    if (fromRoot !== void 0 && fromRoot === toRoot) return false;
+    return !(hidden.has(e.from) && fromRoot === void 0) && !(hidden.has(e.to) && toRoot === void 0);
+  }).map((e) => {
+    const from = bodyDock.get(e.from) ?? e.from;
+    const to = bodyDock.get(e.to) ?? e.to;
+    return from === e.from && to === e.to ? e : { ...e, from, to };
+  }).filter((e) => {
+    if (e.from === e.to) return false;
+    const key = `${e.from}\0${e.to}\0${e.kind}\0${e.label ?? ""}`;
+    if (seenEdge.has(`${key}:${e.id}`)) return false;
+    seenEdge.add(`${key}:${e.id}`);
+    return true;
+  });
+  const referenced = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (proxyHost.has(e.from)) referenced.add(e.from);
+    if (proxyHost.has(e.to)) referenced.add(e.to);
+  }
+  const proxies = proxyPortsByHost(
+    referenced,
+    proxyHost,
+    ownerOfHiddenPort,
+    containerLabel,
+    containerOf,
+    hiddenPortById
+  );
   const collapsedNodes = [...roots].flatMap((id2) => {
     const f = frameById.get(id2);
     if (!f) return [];
+    const stand = proxies.get(id2) ?? [];
     return [{
       id: f.id,
       layoutKey: f.layoutKey,
@@ -182933,7 +183677,7 @@ function collapseIvModel(model, hiddenInternals) {
       shape: "box",
       type: f.type,
       multiplicity: f.multiplicity,
-      ports: f.ports,
+      ports: stand.length ? [...f.ports ?? [], ...stand] : f.ports,
       compartments: f.compartments,
       frame: f.parent,
       source: f.source,
@@ -182944,7 +183688,7 @@ function collapseIvModel(model, hiddenInternals) {
     ...model,
     nodes: [...model.nodes.filter((n2) => !hiddenNodeIds.has(n2.id)), ...collapsedNodes],
     frames: frames.filter((f) => !roots.has(f.id) && !hiddenFrameIds.has(f.id)),
-    edges: model.edges.filter((e) => !hiddenEndpoints.has(e.from) && !hiddenEndpoints.has(e.to))
+    edges
   };
 }
 function isCollapsibleActionFrame(frame2) {
@@ -183026,13 +183770,18 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
   };
   const roots = new Set([...requested].filter((id2) => rootOf(frameById.get(id2)?.parent) === void 0));
   const dockOf = /* @__PURE__ */ new Map();
+  const proxyHost = /* @__PURE__ */ new Map();
+  const ownerOfHiddenPort = /* @__PURE__ */ new Map();
   const hiddenFrameIds = /* @__PURE__ */ new Set();
   for (const f of frames) {
     const root4 = roots.has(f.id) ? rootOf(f.parent) : rootOf(f.id);
     if (root4 === void 0) continue;
     hiddenFrameIds.add(f.id);
     dockOf.set(f.id, root4);
-    for (const p of f.ports ?? []) dockOf.set(p.id, root4);
+    for (const p of f.ports ?? []) {
+      proxyHost.set(p.id, root4);
+      ownerOfHiddenPort.set(p.id, { port: p, owner: f.id });
+    }
   }
   const hiddenNodeIds = /* @__PURE__ */ new Set();
   for (const n2 of model.nodes) {
@@ -183040,15 +183789,59 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
     if (root4 === void 0) continue;
     hiddenNodeIds.add(n2.id);
     dockOf.set(n2.id, root4);
-    for (const p of n2.ports ?? []) dockOf.set(p.id, root4);
+    for (const p of n2.ports ?? []) {
+      proxyHost.set(p.id, root4);
+      ownerOfHiddenPort.set(p.id, { port: p, owner: n2.id });
+    }
   }
   for (const id2 of roots) {
     dockOf.delete(id2);
-    for (const p of frameById.get(id2)?.ports ?? []) dockOf.delete(p.id);
+    for (const p of frameById.get(id2)?.ports ?? []) {
+      proxyHost.delete(p.id);
+      ownerOfHiddenPort.delete(p.id);
+    }
   }
+  const nodeById = new Map(model.nodes.map((n2) => [n2.id, n2]));
+  const containerOf = (id2) => {
+    const frame2 = frameById.get(id2);
+    if (frame2) return frame2.parent;
+    return nodeById.get(id2)?.frame;
+  };
+  const containerLabel = (id2) => frameById.get(id2)?.label ?? nodeById.get(id2)?.name;
+  const hiddenPortById = new Map([...ownerOfHiddenPort].map(([id2, entry]) => [id2, entry.port]));
+  const containerRootOf = (id2) => proxyHost.get(id2) ?? dockOf.get(id2);
+  const seenEdge = /* @__PURE__ */ new Set();
+  const edges = model.edges.filter((e) => {
+    const fromRoot = containerRootOf(e.from);
+    return fromRoot === void 0 || fromRoot !== containerRootOf(e.to);
+  }).map((e) => {
+    const from = dockOf.get(e.from) ?? e.from;
+    const to = dockOf.get(e.to) ?? e.to;
+    return from === e.from && to === e.to ? e : { ...e, from, to };
+  }).filter((e) => {
+    if (e.from === e.to) return false;
+    const key = `${e.from}\0${e.to}\0${e.kind}\0${e.label ?? ""}`;
+    if (seenEdge.has(`${key}:${e.id}`)) return false;
+    seenEdge.add(`${key}:${e.id}`);
+    return true;
+  });
+  const referenced = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (proxyHost.has(e.from)) referenced.add(e.from);
+    if (proxyHost.has(e.to)) referenced.add(e.to);
+  }
+  const proxies = proxyPortsByHost(
+    referenced,
+    proxyHost,
+    ownerOfHiddenPort,
+    containerLabel,
+    containerOf,
+    hiddenPortById
+  );
   const collapsedNodes = [...roots].flatMap((id2) => {
     const f = frameById.get(id2);
     if (!f) return [];
+    const stand = proxies.get(id2) ?? [];
     return [{
       id: f.id,
       layoutKey: f.layoutKey,
@@ -183058,25 +183851,13 @@ function collapseActionFrames(model, hiddenInternals, isHost = isCollapsibleActi
       shape: collapsedShape,
       type: f.type,
       multiplicity: f.multiplicity,
-      ports: f.ports,
+      ports: stand.length ? [...f.ports ?? [], ...stand] : f.ports,
       compartments: f.compartments,
       frame: f.parent,
       source: f.source,
       meta: { ...f.meta, internalsHidden: true }
     }];
   });
-  const seenEdge = /* @__PURE__ */ new Set();
-  const edges = model.edges.map((e) => {
-    const from = dockOf.get(e.from) ?? e.from;
-    const to = dockOf.get(e.to) ?? e.to;
-    return from === e.from && to === e.to ? e : { ...e, from, to };
-  }).filter((e) => {
-    if (e.from === e.to) return false;
-    const key = `${e.from} ${e.to} ${e.kind} ${e.label ?? ""}`;
-    if (seenEdge.has(key)) return false;
-    seenEdge.add(key);
-    return true;
-  });
   return {
     ...model,
     nodes: [...model.nodes.filter((n2) => !hiddenNodeIds.has(n2.id)), ...collapsedNodes],
@@ -183234,7 +184015,7 @@ function modelToFlow(model, opts) {
     const base = isGeo ? { w: 24, h: 24 } : nodeSize(canvasNode, opts.direction);
     const sizeOverride = ov[n2.layoutKey ?? n2.id];
     const compactCollapsed = canvasNode.meta?.internalsHidden === true;
-    const presentationOverride = compactCollapsed && sizeOverride ? { ...sizeOverride, h: void 0 } : sizeOverride;
+    const presentationOverride = compactCollapsed && sizeOverride ? { ...sizeOverride, w: void 0, h: void 0 } : sizeOverride;
     const projectedSize = isCircularControlShape(canvasNode.shape) ? base : isForkJoinShape(canvasNode.shape) ? forkJoinSizeWithOverride(presentationOverride, opts.direction) : sizeWithOverride(
       base,
       presentationOverride,
@@ -183243,7 +184024,20 @@ function modelToFlow(model, opts) {
         h: visibleFeatureH > 0 ? base.h : 24
       }
     );
-    const size = model.kind === "gv" && canvasNode.shape !== "package" ? { ...projectedSize, w: Math.min(projectedSize.w, GV_NODE_MAX_WIDTH) } : projectedSize;
+    const compactPortHandles = compactCollapsed ? assignPortHandles(canvasNode.ports, opts.portOverrides, canvasNode.shape) : [];
+    const compactPortWidth = Math.max(
+      portedSideLength(compactPortHandles, "top"),
+      portedSideLength(compactPortHandles, "bottom")
+    );
+    const compactPortHeight = Math.max(
+      portedSideLength(compactPortHandles, "left"),
+      portedSideLength(compactPortHandles, "right")
+    );
+    const size = model.kind === "gv" && canvasNode.shape !== "package" ? { ...projectedSize, w: Math.min(projectedSize.w, GV_NODE_MAX_WIDTH) } : compactCollapsed ? {
+      ...projectedSize,
+      w: Math.max(compactPortWidth, Math.min(projectedSize.w, GV_NODE_MAX_WIDTH)),
+      h: Math.max(compactPortHeight, projectedSize.h)
+    } : projectedSize;
     const parentId = n2.frame ?? (model.kind === "gv" && n2.parent && gvPackageIds.has(n2.parent) ? n2.parent : void 0) ?? (boundary ? boundary.id : void 0);
     nodes.push({
       id: n2.id,
@@ -183496,6 +184290,7 @@ var GEO_TARGET_H = 520;
 var GEO_DEF_W = 400;
 var GEO_DEF_H = 300;
 var GEO_STRIP_GAP = 16;
+var GEO_STRIP_INSET = 16;
 var GEO_FRAME_ID = "__geoframe__";
 var GEO_EMPTY_W = 560;
 var GEO_EMPTY_H = 320;
@@ -183564,7 +184359,7 @@ function layoutGeometry(nodes, edges, meta) {
     const frame2 = makeGeoFrameNode(kind, GEO_EMPTY_W, GEO_EMPTY_H, {
       geoEmpty: { hLabel: axes.h ?? "x", vLabel: axes.v ?? "z", unit }
     });
-    placeStrip(strip, GEO_MARGIN_LEFT + 16, GEO_EMPTY_H + GEO_STRIP_GAP);
+    placeStrip(strip, GEO_MARGIN_LEFT + GEO_STRIP_INSET, GEO_EMPTY_H + GEO_STRIP_GAP);
     return { nodes: [frame2, ...strip], edges };
   }
   const is3d = placed.some((n2) => n2.data.node.geo.shape !== void 0 || n2.data.node.geo.z !== void 0);
@@ -195490,13 +196285,18 @@ var SEQ_EVENT_GAP = 22;
 function layoutSequence(nodes, edges, overrides) {
   const ov = overrides ?? {};
   const lifelines = nodes.filter((n2) => n2.data.node?.shape === "lifeline").sort((a2, b) => Number(a2.data.node?.meta?.order ?? 0) - Number(b.data.node?.meta?.order ?? 0));
+  const lifelineIds = new Set(lifelines.map((n2) => n2.id));
+  const noteNodes = nodes.filter((n2) => n2.data.node?.shape === "annotation");
+  const isMessage = (edge) => edge.data?.edge.kind === "message" && lifelineIds.has(edge.source) && lifelineIds.has(edge.target);
+  const nonMessageEdges = edges.filter((edge) => !isMessage(edge));
+  const msgs = edges.filter(isMessage);
   const slotFor = (e, i) => {
     const s = e.data?.edge.meta?.slot;
     return typeof s === "number" && Number.isFinite(s) && s >= 0 ? s : i;
   };
-  const msgY = edges.map((e, i) => MSG_TOP + slotFor(e, i) * MSG_GAP);
-  const lastMsgY = edges.length ? Math.max(...msgY) : MSG_TOP;
-  let maxSlot = edges.length ? Math.max(...edges.map(slotFor)) : -1;
+  const msgY = msgs.map((e, i) => MSG_TOP + slotFor(e, i) * MSG_GAP);
+  const lastMsgY = msgs.length ? Math.max(...msgY) : MSG_TOP;
+  let maxSlot = msgs.length ? Math.max(...msgs.map(slotFor)) : -1;
   const eventBase = lastMsgY + 22;
   let maxEventY = 0;
   const eventsByLifeline = /* @__PURE__ */ new Map();
@@ -195519,7 +196319,7 @@ function layoutSequence(nodes, edges, overrides) {
     baseX.push(cursorX);
     cursorX += n2.data.w + LIFELINE_MIN_GAP;
   }
-  const msgHandles = edges.map((_edge, i) => ({ id: `m${i}`, y: msgY[i] }));
+  const msgHandles = msgs.map((_edge, i) => ({ id: `m${i}`, y: msgY[i] }));
   const insertHandles = Array.from({ length: Math.max(maxSlot, -1) + 2 }, (_2, k) => ({
     id: `d${k}`,
     y: sequenceSlotBoundaryY(k),
@@ -195530,7 +196330,7 @@ function layoutSequence(nodes, edges, overrides) {
     const w = n2.data.w;
     const x = overrideFor(n2, ov)?.x ?? baseX[i];
     xOf.set(n2.id, x + w / 2);
-    const ys = edges.map((e, idx) => e.source === n2.id || e.target === n2.id ? msgY[idx] : void 0).filter((y) => y != null);
+    const ys = msgs.map((e, idx) => e.source === n2.id || e.target === n2.id ? msgY[idx] : void 0).filter((y) => y != null);
     const activation = ys.length ? { from: Math.min(...ys) - 6, to: Math.max(...ys) + 6 } : void 0;
     return {
       ...n2,
@@ -195549,7 +196349,7 @@ function layoutSequence(nodes, edges, overrides) {
       draggable: true
     };
   });
-  const outEdges = edges.map((e, i) => {
+  const outEdges = msgs.map((e, i) => {
     const y = msgY[i];
     return {
       ...e,
@@ -195586,7 +196386,21 @@ function layoutSequence(nodes, edges, overrides) {
     const h = Math.max(40, bottom - top);
     return { ...n2, position: { x: left, y: top }, width: w, height: h, data: { ...n2.data, w, h }, zIndex: 0 };
   });
-  return { nodes: [...fragmentNodes, ...out], edges: outEdges, height: bodyH };
+  const noteX = out.length ? Math.max(...out.map((node) => node.position.x + (node.width ?? node.data.w))) + SEQ_NOTE_GAP : 20 + SEQ_NOTE_GAP;
+  let noteY = MSG_TOP;
+  const placedNotes = noteNodes.map((n2) => {
+    const o = overrideFor(n2, ov);
+    const y = o?.y ?? noteY;
+    noteY = Math.max(noteY, y + n2.data.h + SEQ_NOTE_GAP);
+    return { ...n2, position: { x: o?.x ?? noteX, y }, draggable: true };
+  });
+  const sequenceNodes = [...fragmentNodes, ...out, ...placedNotes];
+  assignEdgeSides(sequenceNodes, nonMessageEdges);
+  return {
+    nodes: sequenceNodes,
+    edges: [...outEdges, ...nonMessageEdges],
+    height: Math.max(bodyH, noteY)
+  };
 }
 var TILE_PAD = 22;
 var TILE_HEADER = 38;
@@ -195650,7 +196464,12 @@ async function layoutTiledOverview(model, nodes, edges, args) {
     }));
     const localOverrides = overrideSubset(members, args.overrides);
     const meta = tileMeta[frame2.id];
-    const laidPromise = model.kind === "sv" ? Promise.resolve(layoutSequence(detached, tileEdges, localOverrides)) : model.kind === "gev" ? Promise.resolve(layoutGeometry(detached, tileEdges, meta ?? model.meta)) : layoutFlow(detached, tileEdges, {
+    const laidPromise = model.kind === "sv" ? Promise.resolve(layoutSequence(detached, tileEdges, localOverrides)) : model.kind === "gev" ? Promise.resolve(layoutGeometryWithAnnotationEdges(
+      detached,
+      tileEdges,
+      meta ?? model.meta,
+      args.connectPointSpacing
+    )) : layoutFlow(detached, tileEdges, {
       ...args,
       overrides: localOverrides,
       kind: args.kind ?? model.kind,
@@ -196104,13 +196923,25 @@ async function layoutBands(nodes, edges, overrides, direction = "TB", connectPoi
   assignEdgeSides(all, edges, false, connectPointSpacing);
   return { nodes: all, edges };
 }
+function layoutGeometryWithAnnotationEdges(nodes, edges, meta, connectPointSpacing = CONNECT_POINT_SPACING_DEFAULT) {
+  const laid = layoutGeometry(nodes, edges, meta);
+  assignEdgeSides(
+    laid.nodes,
+    laid.edges.filter((edge) => edge.data?.edge.kind === "annotation"),
+    false,
+    connectPointSpacing
+  );
+  return laid;
+}
 async function layoutDiagram(model, nodes, edges, args) {
   const { kind, direction, overrides, connectPointSpacing } = args;
   if (model.meta?.groupMode === "tiled-h" || model.meta?.groupMode === "tiled-v") {
     return layoutTiledOverview(model, nodes, edges, { direction, overrides, kind, connectPointSpacing });
   }
   const profile2 = profileFor(kind);
-  if (profile2.layout === "geometry") return layoutGeometry(nodes, edges, model.meta);
+  if (profile2.layout === "geometry") {
+    return layoutGeometryWithAnnotationEdges(nodes, edges, model.meta, connectPointSpacing);
+  }
   if (profile2.layout === "sequence") return layoutSequence(nodes, edges, overrides);
   if (kind === "gv" && (args.gvMode ?? "group") === "group") {
     return layoutBands(nodes, edges, overrides, direction, connectPointSpacing);
@@ -197182,6 +198013,12 @@ body {
 
 /* REQ-194 \u2014 port variants: dashed reference ports, direction chevrons */
 .dnode-port.ref { stroke-dasharray: 2 2; }
+/* REQ-400 \u2014 a PROXY stands in for a port inside collapsed contents.
+ * It is drawn hollow with a fine dotted outline, so it reads as a place a
+ * connector docks rather than as an element that is really on the boundary. Its
+ * dot pattern is deliberately finer than the reference port's dash. */
+.dnode-port.proxy { fill: none; stroke-dasharray: 1 2; stroke-width: 1.2; }
+.dnode-port.proxy.selected { fill: var(--accent); fill-opacity: 0.35; }
 /* REQ-376 \u2014 an action pin takes the OUTLINE and explicit fill of the action it sits
  * on rather than the flow colour (user direction 2026-08-09). Its rounded corners and its
  * direction arrow come from the shared port path in nodes.tsx. */
@@ -198167,6 +199004,21 @@ function sizeOf(node) {
     h: node.measured?.height ?? node.height ?? node.data.h
   };
 }
+function exportedNodeColorClass(node) {
+  const frame2 = node.data.frame;
+  if (frame2) {
+    return diagramElementColorClass(diagramElementColorTypeForFrame(frame2.keyword, {
+      boundary: frame2.meta?.boundaryBox === true,
+      exhibitor: frame2.meta?.exhibitBoundary === true,
+      loop: frame2.meta?.loop === true,
+      parallel: frame2.meta?.parallel === true,
+      performer: frame2.meta?.performerLane === true,
+      structured: frame2.meta?.structuredControl === true
+    }));
+  }
+  const semantic = node.data.node;
+  return diagramElementColorClass(semantic ? diagramElementColorTypeForNode(semantic.shape, semantic.keyword) : "default");
+}
 function labelExtent(text) {
   return { w: Math.max(8, text.length * 6.2) / 2, h: 7 };
 }
@@ -198202,7 +199054,7 @@ function buildDiagramSvg(options) {
       extend2(p.x + background.x, p.y + background.y, background.width, background.height);
     }
     const body = nodeMarkup(node);
-    if (body) nodeParts.push(`<g transform="translate(${Math.round(p.x)},${Math.round(p.y)})">${body}</g>`);
+    if (body) nodeParts.push(`<g transform="translate(${Math.round(p.x)},${Math.round(p.y)})" class="${exportedNodeColorClass(node)}">${body}</g>`);
   }
   if (!isFinite(minX)) return null;
   const edgeParts = [];
@@ -198585,6 +199437,7 @@ function normalizeSideCar(value) {
       const next = {};
       if (state.mode !== void 0) next.mode = state.mode;
       if (state.zoom !== void 0) next.zoom = state.zoom;
+      if (state.showGrid !== void 0) next.showGrid = state.showGrid;
       const dir = sanitizeDirection(state.direction);
       if (dir !== void 0) next.direction = dir;
       if (state.hiddenInternals !== void 0) next.hiddenInternals = state.hiddenInternals;
@@ -198610,7 +199463,7 @@ function getViewState(sc, anchor, kind) {
 }
 
 // src/node-markup.tsx
-var import_react10 = __toESM(require_react(), 1);
+var import_react11 = __toESM(require_react(), 1);
 var import_server = __toESM(require_server_node(), 1);
 
 // ../extension/src/webview/diagram/flow/context.ts
@@ -198661,7 +199514,7 @@ function useDiagram() {
 }
 
 // ../extension/src/webview/diagram/flow/nodes.tsx
-var import_react8 = __toESM(require_react());
+var import_react9 = __toESM(require_react());
 
 // ../extension/src/webview/diagram/derive.ts
 function edgeKindLabel(kind) {
@@ -199014,6 +199867,7 @@ var DIRECT_NAME_RE = new RegExp(`^${DIRECT_NAME_SEGMENT}$`);
 var DIRECT_PATH_RE = new RegExp(`^${DIRECT_NAME_SEGMENT}(?:\\.${DIRECT_NAME_SEGMENT})*$`);
 function isWritableRelationEndpoint(endpoint) {
   if (!endpoint) return false;
+  if (endpoint.shape === "annotation") return false;
   if (pseudostateEndpointPath(endpoint.keyword)) return true;
   if (!endpoint.source || /^__flow_\d+__(?:\.|$)/u.test(endpoint.id)) return false;
   if (!endpoint.name.trim() && ["if", "while", "loop", "for"].includes(endpoint.keyword.trim().toLowerCase())) return true;
@@ -199034,6 +199888,7 @@ var TERMINAL_RELATION = "finish";
 function relationToolsForNode(keyword, viewKind, shape) {
   const { base, isDefinition, isDecision } = normalizedElementKeyword(keyword);
   const tools = TOOLBOX[viewKind]?.relations ?? [];
+  if (shape === "annotation") return [];
   if (viewKind === "afv" && ["if", "while", "loop", "for"].includes(base)) {
     return tools.filter((tool) => tool.kind === "terminate");
   }
@@ -199110,6 +199965,12 @@ 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_HANDLE_POSITION = {
+  top: Position3.Top,
+  right: Position3.Right,
+  bottom: Position3.Bottom,
+  left: Position3.Left
+};
 function niceStep(range, target = 5) {
   if (!(range > 0)) return 1;
   const raw = range / target;
@@ -199324,7 +200185,7 @@ function GeoShapeNode({ id: id2, data, selected: selected2 }) {
   const origin = data.origin;
   const iso = data.geo3d && node.geo && origin;
   const approx = node.geo?.approx;
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
     "div",
     {
       className: `rf-node rf-geo${selected2 ? " selected" : ""}${approx ? " dgeo-approx" : ""}`,
@@ -199334,19 +200195,38 @@ function GeoShapeNode({ id: id2, data, selected: selected2 }) {
         e.stopPropagation();
         ctx.onContextNode(id2, e.clientX, e.clientY);
       },
-      children: /* @__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)(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 })
+      children: [
+        /* @__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)(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 })
+          ] }),
+          approx ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("text", { className: "dgeo-approx-mark", x: w - 2, y: -3, textAnchor: "end", children: [
+            "\u26A0",
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("title", { children: `${node.name}: ${approx}` })
+          ] }) : null
         ] }),
-        approx ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("text", { className: "dgeo-approx-mark", x: w - 2, y: -3, textAnchor: "end", children: [
-          "\u26A0",
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("title", { children: `${node.name}: ${approx}` })
-        ] }) : null
-      ] })
+        PORT_DOCK_SIDES.flatMap((side) => (data.edgeSideAnchors?.[side] ?? []).map((offset2) => {
+          const point = sidePoint(side, offset2, w, h);
+          return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+            Handle,
+            {
+              type: "target",
+              id: sideAnchorHandleId(side, offset2),
+              position: GEO_HANDLE_POSITION[side],
+              style: { left: point.x, top: point.y, transform: "translate(-50%,-50%)" },
+              className: "rf-handle rf-handle-side",
+              isConnectable: true,
+              isConnectableStart: false,
+              isConnectableEnd: true
+            },
+            `${side}-${offset2}`
+          );
+        }))
+      ]
     }
   );
 }
@@ -199475,8 +200355,8 @@ function mountedNodeSidePointOffsets(data, side, connectable, exposeAll) {
 function useMountedHandleRegistration(id2, sideOffsets) {
   const mountedKey = mountedHandleKey(sideOffsets);
   const updateNodeInternals2 = useUpdateNodeInternals();
-  const lastKeyRef = (0, import_react8.useRef)(mountedKey);
-  (0, import_react8.useEffect)(() => {
+  const lastKeyRef = (0, import_react9.useRef)(mountedKey);
+  (0, import_react9.useEffect)(() => {
     if (lastKeyRef.current === mountedKey) return;
     lastKeyRef.current = mountedKey;
     updateNodeInternals2(id2);
@@ -199493,9 +200373,9 @@ var SIDE_NORMAL = {
 };
 var clampOffset = (v) => Math.max(0.06, Math.min(0.94, v));
 function usePortDrag(containerRef, w, h, topReserve, onPortMove, onPortPreview, onSelect) {
-  const [dragId, setDragId] = (0, import_react8.useState)(void 0);
-  const gestureRef = (0, import_react8.useRef)(void 0);
-  (0, import_react8.useEffect)(() => () => gestureRef.current?.abort(), []);
+  const [dragId, setDragId] = (0, import_react9.useState)(void 0);
+  const gestureRef = (0, import_react9.useRef)(void 0);
+  (0, import_react9.useEffect)(() => () => gestureRef.current?.abort(), []);
   const onPortPointerDown = (portId, e, origin, draggable = true) => {
     if (e.button !== 0) return;
     e.stopPropagation();
@@ -199979,6 +200859,7 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
       len
     };
   })() : void 0;
+  const proxy = rect.proxy;
   return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
     "g",
     {
@@ -199988,7 +200869,7 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
         e.stopPropagation();
         onSelect(ph.port.id);
       } : void 0,
-      onContextMenu: onContext ? (e) => {
+      onContextMenu: onContext && !proxy ? (e) => {
         e.preventDefault();
         e.stopPropagation();
         onContext(ph.port.id, e.clientX, e.clientY);
@@ -200011,7 +200892,7 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
         /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
           "rect",
           {
-            className: `dnode-port${ph.port.pin ? " pin" : ""}${ph.port.ref ? " ref" : ""}${rect.elongated ? " host" : ""}${selected2 ? " selected" : ""}${hovered ? " hovered" : ""}${moving ? " moving" : ""}${connectTargetSide ? " connect-target" : ""}`,
+            className: `dnode-port${ph.port.pin ? " pin" : ""}${ph.port.ref ? " ref" : ""}${rect.elongated ? " host" : ""}${proxy ? " proxy" : ""}${selected2 ? " selected" : ""}${hovered ? " hovered" : ""}${moving ? " moving" : ""}${connectTargetSide ? " connect-target" : ""}`,
             x: rect.x,
             y: rect.y,
             width: rect.width,
@@ -200024,7 +200905,7 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
           d === "out" || d === "inout" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("path", { className: "dport-dir head", d: arrowHead(1) }) : "",
           d === "in" || d === "inout" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("path", { className: "dport-dir head", d: arrowHead(-1) }) : ""
         ] }) : "",
-        selected2 && connectStart && !connectTargetSide ? (() => {
+        selected2 && connectStart && !connectTargetSide && !proxy ? (() => {
           const px = x + v.x * (half + PORT_PLUS_GAP);
           const py = y + v.y * (half + PORT_PLUS_GAP);
           return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("g", { className: "dport-plus", children: [
@@ -200170,8 +201051,8 @@ function ContainerControls({
   ] });
 }
 function InlineEditor({ initial, mode, elementKind, onCommit, onCancel, w }) {
-  const ref = (0, import_react8.useRef)(null);
-  (0, import_react8.useEffect)(() => {
+  const ref = (0, import_react9.useRef)(null);
+  (0, import_react9.useEffect)(() => {
     const el2 = ref.current;
     if (el2) {
       el2.focus();
@@ -200269,7 +201150,7 @@ function shapeBody(node, data) {
 var CLIP_EXEMPT = /* @__PURE__ */ new Set(["fork", "join", "dot", "initial", "final", "terminate", "lifeline", "actor"]);
 function NodeBody({ node, data, selectedPortId, hoveredPortId, movingPortId, connectTargetPortId, connectTargetPortSide, showPortConnectStart, onPortSelect, onPortContext }) {
   const { w, h } = data;
-  const rawId = (0, import_react8.useId)();
+  const rawId = (0, import_react9.useId)();
   const clipId = `dnode-clip-${rawId.replace(/[^a-zA-Z0-9_-]/g, "")}`;
   const clip = !CLIP_EXEMPT.has(node.shape) || data.kind === "gv" && node.shape === "actor";
   const elementColorClass = diagramElementColorClass(diagramElementColorTypeForNode(node.shape, node.keyword));
@@ -200316,7 +201197,7 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
   const internalNoun = INTERNAL_NOUN[data.kind] ?? "internal parts";
   const featureCompartmentsVisible = node.meta?.featureCompartmentsVisible === true;
   const featureCompartmentHeight = featureBandTopReserve(data);
-  const containerRef = (0, import_react8.useRef)(null);
+  const containerRef = (0, import_react9.useRef)(null);
   const portSource = (pid) => {
     const p = node.ports?.find((pp) => pp.id === pid);
     ctx.onPortSelected?.();
@@ -200343,8 +201224,8 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
   const nodeSideStartable = 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_react8.useState)(void 0);
-  const [sidePointsHovered, setSidePointsHovered] = (0, import_react8.useState)(false);
+  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 perimeterControl = keepsPerimeterSidePointsMounted(node.shape);
@@ -200474,7 +201355,8 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
           node.shape === "initial" || node.shape === "final" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "rf-circular-control-hit", "aria-hidden": "true" }) : null,
           ports.flatMap((ph) => {
             const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
-            const startable = directRelationForHandle(data.kind, {
+            const proxied = isProxyPort(ph.port);
+            const startable = !proxied && directRelationForHandle(data.kind, {
               id: ph.port.id,
               name: ph.port.name,
               keyword: ph.port.pin ? "pin" : "port",
@@ -200495,7 +201377,8 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
                   x: outer.x,
                   y: outer.y,
                   kind: "port",
-                  active: revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === ph.side,
+                  connectable: !proxied,
+                  active: !proxied && (revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === ph.side),
                   startable
                 },
                 `${ph.port.id}-out`
@@ -200508,7 +201391,8 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
                   x: inner.x,
                   y: inner.y,
                   kind: "port",
-                  active: revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === innerSide,
+                  connectable: !proxied,
+                  active: !proxied && (revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === innerSide),
                   startable
                 },
                 `${ph.port.id}-in`
@@ -200518,17 +201402,21 @@ function SysmlNode({ id: id2, data, draggable, selected: selected2, width, heigh
           ctx.onPortMove ? ports.map((ph) => {
             const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
             const nestedChild = ph.port.parentPort !== void 0;
+            const proxyPort = isProxyPort(ph.port);
             const strip = portInteractionStrip(rect, ph.side);
             return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
               "div",
               {
                 className: "port-drag-hit nodrag",
                 style: { position: "absolute", left: strip.cx, top: strip.cy, width: strip.w, height: strip.h, transform: "translate(-50%,-50%)" },
-                title: nestedChild ? `${ph.port.name} - click to select; drag a dot to connect (moves with its parent port)` : `${ph.port.name} - drag the centre to move along the edge; drag a dot to connect; click to select`,
+                title: proxyPort ? `${ph.port.name} - a proxy for a port inside the collapsed contents; drag the centre to move it, click to select the port it stands for` : nestedChild ? `${ph.port.name} - click to select; drag a dot to connect (moves with its parent port)` : `${ph.port.name} - drag the centre to move along the edge; drag a dot to connect; click to select`,
                 onPointerEnter: () => setHoveredPortId(ph.port.id),
                 onPointerLeave: () => setHoveredPortId((cur) => cur === ph.port.id ? void 0 : cur),
                 onPointerDown: (e) => onPortPointerDown(ph.port.id, e, { side: ph.side, offset: ph.offset }, !nestedChild),
-                onContextMenu: (e) => {
+                onContextMenu: proxyPort ? (e) => {
+                  e.preventDefault();
+                  e.stopPropagation();
+                } : (e) => {
                   e.preventDefault();
                   e.stopPropagation();
                   ctx.onContextNode(ph.port.id, e.clientX, e.clientY);
@@ -200655,7 +201543,7 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
   const h = height ?? data.h;
   const partitionKindFull = isExhibitLane ? "\xABexhibited by\xBB" : "\xABperformer\xBB";
   const partitionKindShown = fitKind(partitionKindFull, Math.max(1, w - 20));
-  const rawClipId = (0, import_react8.useId)();
+  const rawClipId = (0, import_react9.useId)();
   const clipId = `dframe-clip-${rawClipId.replace(/[^a-zA-Z0-9_-]/g, "")}`;
   const structuredPrefix = `\xAB${structuredKeyword}\xBB`;
   const structuredConditionShown = structuredCondition ? fitText(structuredCondition, Math.max(1, w - 24 - structuredPrefix.length * 9 * 0.78), 11) : "";
@@ -200683,7 +201571,7 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
     performer: frame2.meta?.performerLane === true,
     structured: frame2.meta?.structuredControl === true
   }));
-  const containerRef = (0, import_react8.useRef)(null);
+  const containerRef = (0, import_react9.useRef)(null);
   const portSource = (pid) => {
     ctx.onPortSelected?.();
     ctx.onReveal(frame2.ports?.find((p) => p.id === pid)?.source, pid);
@@ -200711,8 +201599,8 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
   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 editing = useInteraction(ctx.store, (s) => s.editing?.nodeId === id2 && !s.editing?.at && !s.editing?.edgeId ? s.editing : void 0);
-  const [hoveredPortId, setHoveredPortId] = (0, import_react8.useState)(void 0);
-  const [sidePointsHovered, setSidePointsHovered] = (0, import_react8.useState)(false);
+  const [hoveredPortId, setHoveredPortId] = (0, import_react9.useState)(void 0);
+  const [sidePointsHovered, setSidePointsHovered] = (0, import_react9.useState)(false);
   const sideConnectable = data.kind !== "sv" && !isPackageFrame && !isPartitionLane && !isOuterViewFrame;
   const sideOffsets = isPartitionLane ? SIDES.map(() => []) : SIDES.map((side) => mountedNodeSidePointOffsets(
     data,
@@ -200955,7 +201843,8 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
         }),
         showPorts ? ports.flatMap((ph) => {
           const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
-          const startable = directRelationForHandle(data.kind, {
+          const proxied = isProxyPort(ph.port);
+          const startable = !proxied && directRelationForHandle(data.kind, {
             id: ph.port.id,
             name: ph.port.name,
             keyword: ph.port.pin ? "pin" : "port",
@@ -200976,7 +201865,8 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
                 x: outer.x,
                 y: outer.y,
                 kind: "port",
-                active: revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === ph.side,
+                connectable: !proxied,
+                active: !proxied && (revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === ph.side),
                 startable
               },
               `${ph.port.id}-out`
@@ -200989,7 +201879,8 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
                 x: inner.x,
                 y: inner.y,
                 kind: "port",
-                active: revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === innerSide,
+                connectable: !proxied,
+                active: !proxied && (revealBoth || ph.port.id === connectTargetPortId && connectTargetPortSide === innerSide),
                 startable
               },
               `${ph.port.id}-in`
@@ -200999,17 +201890,21 @@ function FrameNode({ id: id2, data, selected: selected2, width, height }) {
         ctx.onPortMove ? ports.map((ph) => {
           const rect = portGlyphRect(ph, w, h, featureCompartmentHeight);
           const nestedChild = ph.port.parentPort !== void 0;
+          const proxyPort = isProxyPort(ph.port);
           const strip = portInteractionStrip(rect, ph.side);
           return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
             "div",
             {
               className: "port-drag-hit nodrag",
               style: { position: "absolute", left: strip.cx, top: strip.cy, width: strip.w, height: strip.h, transform: "translate(-50%,-50%)" },
-              title: nestedChild ? `${ph.port.name} - click to select; drag a dot to connect (moves with its parent port)` : `${ph.port.name} - drag the centre to move along the edge; drag a dot to connect; click to select`,
+              title: proxyPort ? `${ph.port.name} - a proxy for a port inside the collapsed contents; drag the centre to move it, click to select the port it stands for` : nestedChild ? `${ph.port.name} - click to select; drag a dot to connect (moves with its parent port)` : `${ph.port.name} - drag the centre to move along the edge; drag a dot to connect; click to select`,
               onPointerEnter: () => setHoveredPortId(ph.port.id),
               onPointerLeave: () => setHoveredPortId((cur) => cur === ph.port.id ? void 0 : cur),
               onPointerDown: (e) => onPortPointerDown(ph.port.id, e, { side: ph.side, offset: ph.offset }, !nestedChild),
-              onContextMenu: (e) => {
+              onContextMenu: proxyPort ? (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+              } : (e) => {
                 e.preventDefault();
                 e.stopPropagation();
                 ctx.onContextNode(ph.port.id, e.clientX, e.clientY);
@@ -201100,12 +201995,12 @@ function SeqFragmentNode({ data, width, height }) {
   ] }) });
 }
 var nodeTypes = {
-  sysml: (0, import_react8.memo)(SysmlNode),
-  frame: (0, import_react8.memo)(FrameNode),
-  lane: (0, import_react8.memo)(LaneNode),
-  seqfragment: (0, import_react8.memo)(SeqFragmentNode),
-  geo: (0, import_react8.memo)(GeoShapeNode),
-  geoframe: (0, import_react8.memo)(GeoFrameNode)
+  sysml: (0, import_react9.memo)(SysmlNode),
+  frame: (0, import_react9.memo)(FrameNode),
+  lane: (0, import_react9.memo)(LaneNode),
+  seqfragment: (0, import_react9.memo)(SeqFragmentNode),
+  geo: (0, import_react9.memo)(GeoShapeNode),
+  geoframe: (0, import_react9.memo)(GeoFrameNode)
 };
 
 // src/node-markup.tsx
@@ -201169,13 +202064,13 @@ function renderNodeBody(node, lineStyle, index2) {
     width: node.width ?? node.measured?.width ?? node.data.w,
     height: node.height ?? node.measured?.height ?? node.data.h
   };
-  const markup = (0, import_server.renderToStaticMarkup)((0, import_react10.createElement)(
+  const markup = (0, import_server.renderToStaticMarkup)((0, import_react11.createElement)(
     ReactFlowProvider,
     null,
-    (0, import_react10.createElement)(
+    (0, import_react11.createElement)(
       DiagramContext.Provider,
       { value: exportContext(lineStyle) },
-      (0, import_react10.createElement)(Component, props)
+      (0, import_react11.createElement)(Component, props)
     )
   ));
   const inner = extractNodeSvgInner(markup);
@@ -201355,7 +202250,7 @@ async function runExport(command) {
   const root4 = command.workspace ? path8.resolve(command.workspace) : findWorkspaceRoot(file);
   const settings = diagramSettingsFor(readProjectConfig(root4));
   const sideCar = command.autoLayout ? emptySideCar() : readSideCar(root4, file);
-  const provider = new SysmlDiagramModelProvider();
+  const provider = new SysmlDiagramModelProvider(services.shared);
   const kinds = command.all ? CANVAS_KINDS.filter((kind) => provider.buildAvailableDiagramKinds(document2, command.anchor).some((available) => available.kind === kind)) : [command.view ?? settings.defaultKind];
   const written = [];
   const empty2 = [];
@@ -201383,7 +202278,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.20.3" : "dev";
+var VERSION2 = true ? "0.21.1" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;