sysml-diagram 0.28.0 → 0.28.1

package/out/main.js

@@ -161786,6 +161786,14 @@ function directNamedChildren(node) {
   }
   return result;
 }
+function boundVariableName(node) {
+  if (!node || node.$type !== "ForLoopNode" && node.$type !== "AcceptNode")
+    return void 0;
+  const binding = node;
+  if (binding.varSegs?.length)
+    return void 0;
+  return typeof binding.varName === "string" && binding.varName.length > 0 ? canonicalEscapedName(binding.varName) : void 0;
+}
 function isAncestor(candidate, node) {
   if (!candidate)
     return false;
@@ -161798,7 +161806,25 @@ function isAncestor(candidate, node) {
 function isSelfReference(candidate, node) {
   if (!candidate || !isAncestor(candidate, node))
     return false;
-  return !isPackage(candidate) && candidate.$type !== "NamespaceDecl";
+  if (candidate === node)
+    return true;
+  if (isPackage(candidate) || candidate.$type === "NamespaceDecl")
+    return false;
+  const initializer = candidate.value;
+  if (initializer && isAncestor(initializer, node))
+    return true;
+  const header = candidate;
+  if (typeof header.name === "string" && header.name.length > 0)
+    return false;
+  for (const part of [
+    ...header.preRelationships ?? [],
+    ...header.relationships ?? [],
+    ...header.typing ? [header.typing] : []
+  ]) {
+    if (isAncestor(part, node))
+      return true;
+  }
+  return false;
 }
 function lastSegment(path10) {
   return path10.split(/::|\./u).pop() ?? path10;
@@ -161872,7 +161898,8 @@ var FeaturePathResolver = class {
     let current2 = this.resolveRoot(node, segments[0].text, snapshot);
     this.applyTarget(segments[0], current2);
     if (!current2.node && !current2.description) {
-      return { segments, indeterminateIndex: 0 };
+      const under = node.$type === "Relationship" || node.$type === "LeadingRelationship" ? node : void 0;
+      return this.lexicalInventoryComplete(node, snapshot, under) ? { segments, unresolvedIndex: 0 } : { segments, indeterminateIndex: 0 };
     }
     for (let index2 = 1; index2 < segments.length; index2 += 1) {
       const segment = segments[index2];
@@ -162025,12 +162052,77 @@ var FeaturePathResolver = class {
       }
     }
     for (let owner = node.$container; owner; owner = owner.$container) {
+      const declaredName2 = owner.name;
+      if (typeof declaredName2 === "string" && canonicalEscapedName(declaredName2) === name && !isSelfReference(owner, node)) {
+        return this.targetForNode(owner, this.memberInventoryKnown(owner, snapshot));
+      }
+      if (boundVariableName(owner) === name)
+        return this.targetForNode(owner, true);
       const local = directNamedChildren(owner).find((candidate) => nameOf(candidate) === name && !isSelfReference(candidate, node));
       if (local)
         return this.targetForNode(local, this.memberInventoryKnown(local, snapshot));
+      for (const inheritedOwner of this.typedAndSpecializedOwners(owner, snapshot)) {
+        const inherited = directNamedChildren(inheritedOwner).find((candidate) => nameOf(candidate) === name && !isSelfReference(candidate, node));
+        if (inherited) {
+          return this.targetForNode(inherited, this.memberInventoryKnown(inherited, snapshot));
+        }
+      }
     }
     return this.targetFromDescriptions(snapshot.byName.get(name), node);
   }
+  // REQ-317 — issue #259. Whether the scope chain around `node` has a member
+  // inventory this resolver can enumerate COMPLETELY. A type or supertype it
+  // could not resolve carries members it cannot list, so a name missing from
+  // what it can see is then no proof the name is absent, and reporting it
+  // would be a false positive rather than a diagnosis.
+  //
+  // `under` is the relationship whose own target is being resolved. It is the
+  // claim under test, so it must not also count as evidence that the scope is
+  // unknowable — otherwise every unresolved target would silence the very
+  // check that should report it.
+  lexicalInventoryComplete(node, snapshot, under) {
+    for (let owner = node.$container; owner; owner = owner.$container) {
+      if (this.inheritsImplicitly(owner, snapshot, under))
+        return false;
+      if (!this.declaredTypesResolve(owner, snapshot, under))
+        return false;
+      for (const inheritedOwner of this.typedAndSpecializedOwners(owner, snapshot)) {
+        if (!this.declaredTypesResolve(inheritedOwner, snapshot, under))
+          return false;
+      }
+    }
+    return true;
+  }
+  // issue #259 — OMG SysML gives a case its single `objective` and `subject`,
+  // so a usage of a typed case IMPLICITLY redefines the one its definition
+  // declares, whatever either is named, and inherits that one's members
+  // (`verify vehicleMassRequirement :>> massRequirement` reaches
+  // `massRequirement` through exactly that). This resolver does not evaluate
+  // implicit redefinition, so where one applies it cannot enumerate the scope
+  // and must not call a name absent.
+  inheritsImplicitly(node, snapshot, under) {
+    if (node.$type !== "ObjectiveDecl" && node.$type !== "SubjectDecl")
+      return false;
+    if (this.typedAndSpecializedOwners(node, snapshot).length > 0)
+      return false;
+    const owner = node.$container;
+    return !!owner && (this.typedAndSpecializedOwners(owner, snapshot).length > 0 || !this.declaredTypesResolve(owner, snapshot, under));
+  }
+  // Every type and specialization target this element WRITES resolves to a node
+  // whose own members are readable. An unresolved one is an unknown inventory.
+  declaredTypesResolve(node, snapshot, under) {
+    const record = node;
+    if (record.typing?.type?.$refText && !this.typingTarget(node, snapshot))
+      return false;
+    const declared = [
+      ...record.preRelationships ?? [],
+      ...record.relationships ?? []
+    ].filter((relation) => relation !== under && relation.kind && SPECIALIZATION_KINDS.has(relation.kind));
+    if (declared.length === 0)
+      return true;
+    const written = declared.reduce((total, relation) => total + (relation.targets?.length ?? 0), 0);
+    return this.specializationTargets(node, snapshot).length >= written;
+  }
   resolveChild(current2, name, segments, index2, snapshot) {
     const owner = this.followAlias(current2, snapshot);
     if (owner.node) {
@@ -165304,16 +165396,16 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       };
       const performedActions = depth < 8 && !(typeQ !== void 0 && seenTypes.has(typeQ)) ? effectiveMembersOf(part).filter((m) => m.$type === "PerformStmt" && !!nameOf2(m)).map((act) => {
         const pinSource = this.performTargetOf(act, index2) ?? act;
-        const pathSegments2 = this.isAnonymousBehaviorReference(act) ? this.featurePaths.resolveDeclarationPath(act).segments.map((segment) => segment.text) : [nameOf2(act)];
+        const pathSegments3 = this.isAnonymousBehaviorReference(act) ? this.featurePaths.resolveDeclarationPath(act).segments.map((segment) => segment.text) : [nameOf2(act)];
         return {
           act,
           pinSource,
-          pathSegments: pathSegments2,
-          name: pathSegments2.at(-1) ?? nameOf2(act),
+          pathSegments: pathSegments3,
+          name: pathSegments3.at(-1) ?? nameOf2(act),
           key: concretePerformPath(act, pinSource)
         };
       }).filter((entry, i, list) => list.findIndex((other) => other.key === entry.key) === i) : [];
-      const performedActionInfos = performedActions.map(({ act, pinSource, pathSegments: pathSegments2, name, key }) => {
+      const performedActionInfos = performedActions.map(({ act, pinSource, pathSegments: pathSegments3, name, key }) => {
         const id2 = `${instanceId}::__perform_${key}`;
         const inheritedFromDefinition = !!localUsage && !isAstDescendantOrSelf(act, localUsage);
         const syncDeclaration2 = this.synchronizationDeclarationOf(act, index2);
@@ -165321,7 +165413,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           act,
           name,
           id: id2,
-          pathSegments: pathSegments2,
+          pathSegments: pathSegments3,
           pins: this.actionPinPorts(pinSource, id2, index2, uri),
           meta: {
             ...ivEditMeta(act, id2, void 0, localUsage, [...localPath, name], uri),
@@ -171433,7 +171525,6 @@ var SysmlFoldingRangeProvider = class extends DefaultFoldingRangeProvider {
         continue;
       }
       let groupStart = -1;
-      let groupEnd = -1;
       let startLine = -1;
       let endLine = -1;
       const flushGroup = () => {
@@ -171445,7 +171536,6 @@ var SysmlFoldingRangeProvider = class extends DefaultFoldingRangeProvider {
           });
         }
         groupStart = -1;
-        groupEnd = -1;
         startLine = -1;
         endLine = -1;
       };
@@ -171457,7 +171547,6 @@ var SysmlFoldingRangeProvider = class extends DefaultFoldingRangeProvider {
             groupStart = i;
             startLine = range.start.line;
           }
-          groupEnd = i;
           endLine = range.end.line;
         } else {
           flushGroup();
@@ -174812,7 +174901,7 @@ function evaluateFilterCondition(condition, element, options) {
   return value.kind === "boolean" ? value.value : void 0;
 }
 function extensionFor(ctx) {
-  const ext = (node, evaluate2) => {
+  const ext = (node, _evaluate) => {
     switch (node.$type) {
       case "SelfClassifyExpr":
         return classify(node, ctx);
@@ -175974,6 +176063,22 @@ var ConformanceModel = class {
 };
 
 // ../language-server/out/src/services/validator.js
+var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([
+  ":>>",
+  "redefines",
+  ":>",
+  "subsets",
+  "specializes"
+]);
+function isBoundReferencePart(node) {
+  let declaration = node.$container;
+  while (declaration && !isPartDecl(declaration))
+    declaration = declaration.$container;
+  if (!declaration)
+    return false;
+  const modifiers2 = declaration.modifiers ?? [];
+  return modifiers2.includes("ref");
+}
 var severityOverrides = {};
 function severity(code, defaultSeverity) {
   return severityOverrides[code] ?? defaultSeverity;
@@ -176172,15 +176277,11 @@ var SysmlValidator = class _SysmlValidator {
   // dispatches `checkPathExpr`, so without a shared decision the two would drift
   // and a body would quietly escape a diagnostic the surrounding model receives.
   featurePathFault(node) {
-    let declaration = node.$container;
-    while (declaration && !isPartDecl(declaration))
-      declaration = declaration.$container;
-    const modifiers2 = declaration?.modifiers ?? [];
-    if (!declaration || !modifiers2.includes("ref"))
-      return void 0;
     const resolution = this.featurePaths.resolve(node);
     if (resolution.unresolvedIndex === void 0)
       return void 0;
+    if (resolution.unresolvedIndex > 0 && !isBoundReferencePart(node))
+      return void 0;
     const invalid = resolution.segments[resolution.unresolvedIndex];
     return {
       segment: invalid.text,
@@ -176188,6 +176289,28 @@ var SysmlValidator = class _SysmlValidator {
       range: invalid.cst.range
     };
   }
+  // REQ-317 — issue #259. A redefinition or subsetting target is a written path
+  // too (`attribute :>> maxMass`, `attribute other :> maxMass`), and the grammar
+  // stores it as a plain `RelationPath` STRING rather than a Langium
+  // cross-reference, so nothing else can diagnose it either: a target that names
+  // nothing linked silently, and the model kept a relationship to an element that
+  // does not exist.
+  //
+  // Only the ROOT segment is judged, on the same terms `checkPathExpr` uses: the
+  // resolver reports an absent root only when it could enumerate the surrounding
+  // inventory completely. A later segment depends on the KerML semantic model
+  // this resolver does not evaluate.
+  checkRelationshipTargets(node, accept) {
+    if (!node.kind || !REDEFINITION_KINDS2.has(node.kind))
+      return;
+    for (let ordinal = 0; ordinal < node.targets.length; ordinal += 1) {
+      const resolution = this.featurePaths.resolvePropertyPath(node, "targets", ordinal);
+      if (resolution.unresolvedIndex !== 0)
+        continue;
+      const invalid = resolution.segments[0];
+      accept(severity("RES001", "error"), DIAGNOSTIC_MESSAGES.RES001_FEATURE_PATH_SEGMENT(invalid.text, "the current scope"), { node, range: invalid.cst.range, code: "RES001", data: { featurePathSegment: true } });
+    }
+  }
   // REQ-389 — Namespace qualification versus feature chaining in every written path
   // issue #213 — RES019: `::` binds tighter than `.`. Each dot-separated link of
   // a KerML FeatureChain is a complete QualifiedName, and an
@@ -178753,6 +178876,10 @@ ${baseIndent}}`;
       Document: this.checkDocument.bind(this),
       PartDecl: this.checkPartDecl.bind(this),
       PathExpr: this.checkPathExpr.bind(this),
+      // issue #259 — the same absent-name rule on a redefinition or
+      // subsetting target, which is a written path string as well.
+      Relationship: this.checkRelationshipTargets.bind(this),
+      LeadingRelationship: this.checkRelationshipTargets.bind(this),
       // issue #213 — RES019: the `::` vs `.` rule on the reference-form
       // declarations that reach their target through OwnedReferenceSubsetting.
       PerformStmt: this.checkChainSeparators.bind(this),
@@ -180110,9 +180237,13 @@ var SysmlLinker = class extends DefaultLinker {
 // ../language-server/out/src/services/rename-provider.js
 var SysmlRenameProvider = class extends DefaultRenameProvider {
   langiumDocuments;
+  locator;
+  featurePaths;
   constructor(services) {
     super(services);
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+    this.locator = services.workspace.AstNodeLocator;
+    this.featurePaths = new FeaturePathResolver(services);
   }
   // REQ-261 — reject a rename request whose cursor resolves to a library
   // declaration: such a symbol has no meaningful "prepare rename" range
@@ -180131,7 +180262,8 @@ var SysmlRenameProvider = class extends DefaultRenameProvider {
     const target = this.resolveDeclarationAt(document2, params.position);
     if (target && isLibraryDocument(ast_utils_exports.getDocument(target)))
       return void 0;
-    const edit = await super.rename(document2, { ...params, newName: encodeUnrestrictedName(params.newName) }, cancelToken);
+    const newName = encodeUnrestrictedName(params.newName);
+    const edit = await super.rename(document2, { ...params, newName }, cancelToken);
     if (!edit?.changes)
       return edit;
     const changes = {};
@@ -180141,8 +180273,121 @@ var SysmlRenameProvider = class extends DefaultRenameProvider {
         continue;
       changes[uri] = textEdits;
     }
+    if (target)
+      this.addWrittenPathEdits(changes, target, newName);
     return { ...edit, changes };
   }
+  // issue #255 — the references Langium cannot see. An expression operand
+  // (`require constraint { maxMass > 0 }`) and a redefinition or subsetting
+  // target (`attribute :>> maxMass`) are written as PLAIN PATH STRINGS in the
+  // grammar (PathExpr / RelationPath), not as Langium cross-references, so
+  // `findReferences` reports none of them and a rename left every one of them
+  // spelling the old name.
+  //
+  // They are resolved here the same way go-to-definition resolves them
+  // (`FeaturePathResolver`, the one path-resolution rule in the server), and a
+  // segment is edited ONLY when it resolves to this exact declaration. Matching
+  // by resolution rather than by spelling is what keeps a same-named feature of
+  // another element untouched.
+  // REQ-262 — Rename: workspace edit, library not renamable
+  addWrittenPathEdits(changes, declaration, newName) {
+    const oldName = canonicalEscapedName(declaration.name ?? "");
+    if (!oldName)
+      return;
+    const spelledVerbatim = encodeUnrestrictedName(oldName) === oldName;
+    for (const doc of this.langiumDocuments.all) {
+      if (isLibraryDocument(doc))
+        continue;
+      const root4 = doc.parseResult?.value;
+      if (!root4)
+        continue;
+      if (spelledVerbatim && !doc.textDocument.getText().includes(oldName))
+        continue;
+      const uri = doc.uri.toString();
+      const edits = changes[uri] ?? [];
+      const claimed = new Set(edits.map((edit) => `${edit.range.start.line}:${edit.range.start.character}`));
+      const added = [];
+      for (const segment of this.writtenPathSegments(root4, oldName)) {
+        const resolved = this.resolvedNodeOf(segment);
+        if (!resolved || !this.denotes(resolved, declaration))
+          continue;
+        const key = `${segment.cst.range.start.line}:${segment.cst.range.start.character}`;
+        if (claimed.has(key))
+          continue;
+        claimed.add(key);
+        added.push({ range: segment.cst.range, newText: newName });
+      }
+      if (added.length)
+        changes[uri] = [...edits, ...added];
+    }
+  }
+  // Every written-path segment of one document that SPELLS the old name. The
+  // spelling test comes first because resolving a path is the expensive half.
+  // `FeaturePathResolver` already canonicalises each segment it returns, so the
+  // comparison is against `oldName` directly.
+  *writtenPathSegments(root4, oldName) {
+    const matching = (segments) => segments.filter((segment) => segment.text === oldName);
+    const spellsName = (path10) => !!path10 && pathSegments(path10).some((step) => canonicalEscapedName(step) === oldName);
+    for (const node of [root4, ...ast_utils_exports.streamAllContents(root4)]) {
+      if (isPathExpr(node)) {
+        if (!spellsName(node.path))
+          continue;
+        yield* matching(this.featurePaths.resolve(node).segments);
+        continue;
+      }
+      if (!isRelationship(node) && !isLeadingRelationship(node))
+        continue;
+      for (let ordinal = 0; ordinal < node.targets.length; ordinal += 1) {
+        if (!spellsName(node.targets[ordinal]))
+          continue;
+        yield* matching(this.featurePaths.resolvePropertyPath(node, "targets", ordinal).segments);
+      }
+    }
+  }
+  // An anonymous redefinition (`attribute :>> maxMass = 1500.0;`) declares NO
+  // name of its own — it carries the name of what it redefines. A later
+  // `other :> maxMass` in the same body therefore resolves to that redefinition
+  // rather than to the original declaration, yet it still spells the renamed
+  // name and still has to be rewritten. Follow the redefinition chain, which is
+  // exactly the chain the name itself travels.
+  denotes(node, declaration, seen = /* @__PURE__ */ new Set()) {
+    if (node === declaration)
+      return true;
+    if (seen.has(node))
+      return false;
+    seen.add(node);
+    const own = node.name;
+    if (typeof own === "string" && own.length > 0)
+      return false;
+    const relational = node;
+    for (const relationship of [
+      ...relational.preRelationships ?? [],
+      ...relational.relationships ?? []
+    ]) {
+      if (relationship.kind !== ":>>" && relationship.kind !== "redefines")
+        continue;
+      const targets = relationship.targets ?? [];
+      for (let ordinal = 0; ordinal < targets.length; ordinal += 1) {
+        const segments = this.featurePaths.resolvePropertyPath(relationship, "targets", ordinal).segments;
+        const last2 = segments[segments.length - 1];
+        const resolved = last2 ? this.resolvedNodeOf(last2) : void 0;
+        if (resolved && this.denotes(resolved, declaration, seen))
+          return true;
+      }
+    }
+    return false;
+  }
+  resolvedNodeOf(segment) {
+    if (segment.target)
+      return segment.target;
+    const description = segment.description;
+    if (!description)
+      return void 0;
+    if (description.node)
+      return description.node;
+    const root4 = this.langiumDocuments.getDocument(description.documentUri)?.parseResult.value;
+    return root4 ? this.locator.getAstNode(root4, description.path) : void 0;
+  }
   // Mirrors DefaultRenameProvider's own leaf-node → declaration resolution
   // (langium/src/lsp/rename-provider.ts) so the library check runs against
   // the SAME target prepareRename/rename would otherwise act on.
@@ -180157,6 +180402,39 @@ var SysmlRenameProvider = class extends DefaultRenameProvider {
     return this.references.findDeclaration(leafNode);
   }
 };
+function pathSegments(path10) {
+  const out = [];
+  let current2 = "";
+  let quoted = false;
+  for (let at = 0; at < path10.length; at += 1) {
+    const ch = path10[at];
+    if (quoted) {
+      current2 += ch;
+      if (ch === "\\" && at + 1 < path10.length) {
+        current2 += path10[at + 1];
+        at += 1;
+      } else if (ch === "'") {
+        quoted = false;
+      }
+      continue;
+    }
+    if (ch === "'") {
+      quoted = true;
+      current2 += ch;
+    } else if (ch === ":" && path10[at + 1] === ":") {
+      out.push(current2);
+      current2 = "";
+      at += 1;
+    } else if (ch === ".") {
+      out.push(current2);
+      current2 = "";
+    } else {
+      current2 += ch;
+    }
+  }
+  out.push(current2);
+  return out;
+}
 
 // ../language-server/out/src/services/code-action-provider.js
 var import_vscode_languageserver18 = __toESM(require_main4(), 1);
@@ -181583,7 +181861,7 @@ var import_vscode_languageserver20 = __toESM(require_main4(), 1);
 function unquoteName3(name) {
   return name.replace(/^'(.*)'$/u, "$1");
 }
-function pathSegments(path10) {
+function pathSegments2(path10) {
   const segments = [];
   let current2 = "";
   let quoted = false;
@@ -181611,7 +181889,7 @@ function pathSegments(path10) {
   return segments;
 }
 function simpleNameOf2(name) {
-  return pathSegments(name).at(-1) ?? name;
+  return pathSegments2(name).at(-1) ?? name;
 }
 var ELEMENT_SEPARATOR = "\0";
 function elementKey2(description) {
@@ -181621,7 +181899,7 @@ function isDeclaredSpelling(description) {
   const kind = description.derivedKind;
   if (kind === "reexport" || kind === "inherited")
     return false;
-  return pathSegments(description.name).length === 1;
+  return pathSegments2(description.name).length === 1;
 }
 var SysmlNameLookup = class {
   shared;
@@ -181958,7 +182236,7 @@ var EXPLICIT_SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([
   "crosses",
   "conjugates"
 ]);
-var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var REDEFINITION_KINDS3 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var CONSTANT_CARRYING_KINDS = /* @__PURE__ */ new Set([
   ":>",
   "subsets",
@@ -182353,7 +182631,7 @@ var SysmlInlayHintProvider = class {
       const parameter = mine[index2].node;
       if (!parameter.name || !parameter.$cstNode)
         continue;
-      if (allRelationships2(parameter).some((rel2) => rel2.kind && REDEFINITION_KINDS2.has(rel2.kind)))
+      if (allRelationships2(parameter).some((rel2) => rel2.kind && REDEFINITION_KINDS3.has(rel2.kind)))
         continue;
       const target = theirs[index2].node;
       if (!target.name || target.name === parameter.name)
@@ -182626,7 +182904,7 @@ var SysmlInlayHintProvider = class {
 function effectiveNameHint(node) {
   if (node.name || node.shortName?.name || !node.$cstNode)
     return void 0;
-  const redefinition = allRelationships2(node).find((rel2) => rel2.kind && REDEFINITION_KINDS2.has(rel2.kind) && (rel2.targets?.length ?? 0) > 0);
+  const redefinition = allRelationships2(node).find((rel2) => rel2.kind && REDEFINITION_KINDS3.has(rel2.kind) && (rel2.targets?.length ?? 0) > 0);
   const target = redefinition?.targets?.[0];
   if (!target)
     return void 0;
@@ -185248,7 +185526,26 @@ function compartmentWidth(node) {
   }
   return w;
 }
+var RELATIONSHIP_COMPARTMENTS = /* @__PURE__ */ new Set([
+  "connections",
+  "interfaces",
+  "flows",
+  "state transition",
+  "successions"
+]);
+function withoutRelationshipCompartments(carrier) {
+  const comps = carrier.compartments;
+  if (!comps?.some((compartment) => RELATIONSHIP_COMPARTMENTS.has(compartment.title))) return carrier;
+  const kept = comps.filter((compartment) => !RELATIONSHIP_COMPARTMENTS.has(compartment.title));
+  return { ...carrier, compartments: kept.length ? kept : void 0 };
+}
+function frameForCanvas(frame2) {
+  return withoutRelationshipCompartments(frame2);
+}
 function nodeForCanvas(node) {
+  return withoutRelationshipCompartments(nodeBlockForCanvas(node));
+}
+function nodeBlockForCanvas(node) {
   if (node.meta?.connectionUsage === true || node.meta?.interfaceUsage === true) {
     const compartments2 = node.compartments?.filter((compartment) => compartment.title === "doc" || compartment.title === "flows");
     return {
@@ -185782,7 +186079,7 @@ function hideExplicitRelationshipBoxes(model, relationship) {
     bindings: explicitRelationshipBindings(usage, model),
     endCount: usage.ports?.length ?? 0
   }));
-  const blocksCompaction = ({ usage, endCount }) => (nodeForCanvas(usage).compartments ?? []).some((compartment) => endCount !== 2 || compartment.title !== "flows");
+  const blocksCompaction = ({ usage, endCount }) => (nodeBlockForCanvas(usage).compartments ?? []).some((compartment) => endCount !== 2 || compartment.title !== "flows");
   const retainedIds = new Set(projections.filter((projection2) => blocksCompaction(projection2) || annotatedUsageIds.has(projection2.usage.id) || projection2.endCount < 2 || projection2.bindings.length !== projection2.endCount).map(({ usage }) => usage.id));
   const hiddenIds = /* @__PURE__ */ new Set();
   for (const { usage } of projections) {
@@ -186365,10 +186662,11 @@ function modelToFlow(model, opts) {
   const visualDepth = (frame2) => frameDepth(frame2.id) + (visualPerformerParent.has(frame2.id) ? 1 : 0);
   const orderedFrames = [...frames].sort((a2, b) => visualDepth(a2) - visualDepth(b));
   for (const f of orderedFrames) {
-    const natural = frameMinSize(f);
-    const featureH = frameFeatureCompartmentHeight(f);
-    const frameHeaderHeight = isBehaviorPartitionLane(f) ? performerLaneHeaderHeight(f) : structuredControlHeaderHeight(f);
-    const frameBottomHeight = frameBottomCompartmentHeight(f);
+    const canvasFrame = frameForCanvas(f);
+    const natural = frameMinSize(canvasFrame);
+    const featureH = frameFeatureCompartmentHeight(canvasFrame);
+    const frameHeaderHeight = isBehaviorPartitionLane(canvasFrame) ? performerLaneHeaderHeight(canvasFrame) : structuredControlHeaderHeight(canvasFrame);
+    const frameBottomHeight = frameBottomCompartmentHeight(canvasFrame);
     const size = sizeWithOverride(
       natural,
       ov[f.layoutKey ?? f.id],
@@ -186380,7 +186678,7 @@ function modelToFlow(model, opts) {
       position: { x: 0, y: 0 },
       data: {
         kind: model.kind,
-        frame: f,
+        frame: canvasFrame,
         layoutKey: f.layoutKey ?? f.id,
         ports: isBehaviorPartitionLane(f) ? [] : assignPortHandles(f.ports, opts.portOverrides),
         w: size.w,
@@ -186422,7 +186720,7 @@ function modelToFlow(model, opts) {
       position: { x: 0, y: 0 },
       data: {
         kind: model.kind,
-        frame: boundary,
+        frame: frameForCanvas(boundary),
         layoutKey: boundary.layoutKey ?? boundary.id,
         ports: assignPortHandles(boundary.ports, opts.portOverrides),
         w: size.w,
@@ -203679,7 +203977,6 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
   const x = rect.cx;
   const y = rect.cy;
   const half = rect.across / 2;
-  const size = rect.across;
   const d = ph.port.direction;
   const v = ph.side === "top" ? { x: 0, y: -1 } : ph.side === "bottom" ? { x: 0, y: 1 } : ph.side === "left" ? { x: -1, y: 0 } : { x: 1, y: 0 };
   const perp = { x: -v.y, y: v.x };
@@ -205182,7 +205479,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.28.0" : "dev";
+var VERSION2 = true ? "0.28.1" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;