@principal-ai/subsystems-react 0.25.0 → 0.26.0

package/src/subsystem/model.ts

@@ -435,6 +435,40 @@ export function deriveNameFromSymbol(
   return name;
 }
 
+const CONSTRUCT_PLURALS: Record<string, string> = {
+  class: 'classes',
+  function: 'functions',
+  method: 'methods',
+  interface: 'interfaces',
+  type_alias: 'type aliases',
+  enum: 'enums',
+  store: 'stores',
+  external: 'externals',
+  custom_entity: 'custom entities',
+};
+
+/**
+ * One-line summary of what a group of declarations contains, e.g.
+ * `6 functions · 2 classes`. Used for aggregate frame boxes, which describe
+ * their contents (constructs) rather than their container. Empty/blank
+ * constructs are ignored. At most three groups; the rest folds into `+N more`.
+ */
+export function describeConstructBreakdown(constructs: readonly string[]): string {
+  const counts = new Map<string, number>();
+  for (const raw of constructs) {
+    const c = (raw ?? '').trim();
+    if (!c) continue;
+    counts.set(c, (counts.get(c) ?? 0) + 1);
+  }
+  const ranked = [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  const parts = ranked.slice(0, 3).map(([c, n]) => {
+    if (n === 1) return `1 ${c}`;
+    return `${n} ${CONSTRUCT_PLURALS[c] ?? `${c}s`}`;
+  });
+  if (ranked.length > 3) parts.push(`+${ranked.length - 3} more`);
+  return parts.join(' · ') || 'empty';
+}
+
 /**
  * Human-readable purl identity — drops the `pkg:<type>/` scheme wrapper and
  * trailing version, keeping the package / owner-repo identity:
@@ -717,6 +751,30 @@ export function buildBoundaryLayoutGroups(
   );
   const keptProcessKeys = new Set(processes.map((r) => r.key));
 
+  // Leaves owned by a multi-member module belong to that module's frame
+  // exclusively. Multi-member modules are always built by ELK (never skipped
+  // as singletons), so letting a process/package group also list them
+  // directly would parent the same leaf twice and ELK throws
+  // ("value already present"). Mixed-process modules (common in composed
+  // graphs, where models frame one file under different processes) never
+  // nest — without this claim they land in both frames.
+  const claimedByModule = new Set<string>();
+  for (const r of modules) {
+    if (r.memberAliases.length >= 2) {
+      for (const alias of r.memberAliases) claimedByModule.add(alias);
+    }
+  }
+  // Same rule one level up: a leaf owned by a multi-member process frame
+  // must not also sit directly in a package frame. (Singleton processes
+  // never claim — ELK skips them and promotes the member upward, so the
+  // member has to stay reachable through its package or ungrouped.)
+  const claimedByProcess = new Set<string>();
+  for (const r of processes) {
+    if (r.memberAliases.length >= 2) {
+      for (const alias of r.memberAliases) claimedByProcess.add(alias);
+    }
+  }
+
   const moduleGroups: BoundaryLayoutGroup[] = modules.map((r) => {
     const processesOfMembers = new Set<string>();
     const packagesOfMembers = new Set<string>();
@@ -749,6 +807,7 @@ export function buildBoundaryLayoutGroups(
     const nestedModules = moduleGroups.filter((m) => m.parentId === processId);
     const nestedModuleKeys = new Set(nestedModules.map((m) => m.region.key));
     const directLeaves = r.memberAliases.filter((alias) => {
+      if (claimedByModule.has(alias)) return false;
       const mod = byAlias.get(alias)?.module?.trim();
       if (!mod) return true;
       return !nestedModuleKeys.has(mod);
@@ -785,7 +844,12 @@ export function buildBoundaryLayoutGroups(
     for (const m of nestedModules) {
       for (const alias of m.region.memberAliases) claimed.add(alias);
     }
-    const directLeaves = r.memberAliases.filter((alias) => !claimed.has(alias));
+    const directLeaves = r.memberAliases.filter(
+      (alias) =>
+        !claimed.has(alias) &&
+        !claimedByModule.has(alias) &&
+        !claimedByProcess.has(alias),
+    );
     return {
       id: packageId,
       memberAliases: [