@trops/dash-core 0.1.422 → 0.1.425

package/dist/electron/index.js

@@ -28520,13 +28520,16 @@ var schedulerController_1 = schedulerController$2;
 	  backfillMetadataFromDisk() {
 	    let changed = false;
 	    for (const [pkgId, entry] of this.widgets.entries()) {
-	      const needsBackfill =
-	        !Array.isArray(entry.componentNames) ||
-	        entry.componentNames.length === 0 ||
-	        !Array.isArray(entry.widgets) ||
-	        entry.widgets.length === 0;
-	      if (!needsBackfill) continue;
 	      if (!entry.path || !fs.existsSync(entry.path)) continue;
+	      // Always re-enrich from disk — don't gate on whether the cache
+	      // looks populated. A package's `dash.json` can gain new widgets
+	      // between sessions (author edits, AI-builder adds, etc.), and
+	      // skipping enrichment here is exactly how publish ends up
+	      // attributing a shared component to the wrong package:
+	      // `@scope/bundle` appears to not provide it (stale cache),
+	      // so a singleton `@scope/name` wins by elimination.
+	      // `enrichEntryFromDisk` already guards against shrinking the
+	      // list, so re-running it on every entry is idempotent.
 	      const before = {
 	        cn: (entry.componentNames || []).length,
 	        w: (entry.widgets || []).length,
@@ -28538,7 +28541,7 @@ var schedulerController_1 = schedulerController$2;
 	      };
 	      if (after.cn !== before.cn || after.w !== before.w) {
 	        console.log(
-	          `[WidgetRegistry] Back-filled metadata for ${pkgId}: ` +
+	          `[WidgetRegistry] Refreshed metadata for ${pkgId}: ` +
 	            `componentNames ${before.cn} → ${after.cn}, widgets ${before.w} → ${after.w}`,
 	        );
 	        changed = true;
@@ -62937,6 +62940,15 @@ var properties = {
 			"1.0.0"
 		]
 	},
+	version: {
+		type: "string",
+		description: "Package version (semver) of the published dashboard. Distinct from workspace.version (integer schema revision). Bumped on each republish.",
+		pattern: "^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$",
+		examples: [
+			"1.0.0",
+			"1.2.3-beta"
+		]
+	},
 	name: {
 		type: "string",
 		description: "Display name of the dashboard",
@@ -63602,16 +63614,87 @@ function stripScopePrefix(fullName, scope) {
  * @returns {Array} Widget dependency objects for the dashboard config
  */
 function buildWidgetDependencies$1(
-  componentNames,
+  componentNamesOrRefs,
   widgetRegistry = null,
   componentConfigs = null,
 ) {
   const widgets = [];
   const seen = new Set();
 
-  for (const name of componentNames) {
-    if (seen.has(name)) continue;
-    seen.add(name);
+  // Accept both the legacy string-array shape and the new
+  // `{component, packageId}` ref shape. Refs carry the exact source
+  // package recorded at widget-add time — no guessing needed. Legacy
+  // layout items that predate packageId pass `packageId: null` and
+  // still fall through to the registry fallback.
+  const refs = (componentNamesOrRefs || []).map((entry) =>
+    typeof entry === "string"
+      ? { component: entry, packageId: null }
+      : { component: entry.component, packageId: entry.packageId || null },
+  );
+
+  // Pre-index the installed widgets by packageId for O(1) lookup when
+  // refs specify one. The secondary map by component name is used for
+  // the legacy/fallback path where packageId isn't known. When a
+  // shared component appears without a packageId, rank candidates by
+  // how many of THIS dashboard's widgets they provide so the
+  // best-fit bundle wins over a single-widget package that happens
+  // to share the name.
+  const installedWidgets = widgetRegistry ? widgetRegistry.getWidgets() : [];
+  const byPackageId = new Map();
+  const byComponentName = new Map();
+  for (const w of installedWidgets) {
+    // packageId on the registry entry is usually `@scope/name`; also
+    // index by the bare `scope/name` form since callers occasionally
+    // strip the @.
+    const ids = new Set();
+    if (w.packageId) ids.add(w.packageId);
+    if (w.name) ids.add(w.name);
+    if (w.scope && w.name) {
+      const bareScope = String(w.scope).replace(/^@/, "");
+      const bareName = stripScopePrefix(w.name, w.scope);
+      ids.add(`@${bareScope}/${bareName}`);
+      ids.add(`${bareScope}/${bareName}`);
+    }
+    for (const id of ids) {
+      if (id && !byPackageId.has(id)) byPackageId.set(id, w);
+    }
+    if (Array.isArray(w.componentNames)) {
+      for (const cn of w.componentNames) {
+        if (!byComponentName.has(cn)) byComponentName.set(cn, []);
+        byComponentName.get(cn).push(w);
+      }
+    }
+  }
+
+  const requestedComponentSet = new Set(refs.map((r) => r.component));
+  const rankCandidates = (candidates) =>
+    [...candidates].sort((a, b) => {
+      const aMatches = (a.componentNames || []).filter((n) =>
+        requestedComponentSet.has(n),
+      ).length;
+      const bMatches = (b.componentNames || []).filter((n) =>
+        requestedComponentSet.has(n),
+      ).length;
+      if (aMatches !== bMatches) return bMatches - aMatches;
+      return (b.componentNames?.length || 0) - (a.componentNames?.length || 0);
+    });
+
+  const applyRegistryMatch = (w, name, resolved) => {
+    if (!resolved.scope && w.scope) resolved.scope = w.scope;
+    if (!resolved.packageName || resolved.packageName === name) {
+      resolved.packageName =
+        stripScopePrefix(w.name, w.scope || resolved.scope) || "";
+    }
+    resolved.version = w.version || "*";
+    resolved.author =
+      typeof w.author === "string" ? w.author : w.author?.name || "";
+  };
+
+  for (const ref of refs) {
+    const name = ref.component;
+    const dedupeKey = `${name}|${ref.packageId || ""}`;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
 
     let scope = "";
     let packageName = "";
@@ -63627,23 +63710,34 @@ function buildWidgetDependencies$1(
       widgetName = parts[2];
     }
 
-    // Try to resolve from widget registry
-    if (widgetRegistry) {
-      const installedWidgets = widgetRegistry.getWidgets();
-      for (const w of installedWidgets) {
-        if (w.componentNames && w.componentNames.includes(name)) {
-          if (!scope && w.scope) scope = w.scope;
-          if (!packageName || packageName === name) {
-            packageName = stripScopePrefix(w.name, w.scope || scope) || "";
-          }
-          version = w.version || "*";
-          author =
-            typeof w.author === "string" ? w.author : w.author?.name || "";
-          break;
-        }
+    const resolved = { scope, packageName, version, author };
+
+    // Authoritative path: the layout item told us exactly which
+    // package this widget came from. Look it up directly. No guessing.
+    let matched = false;
+    if (ref.packageId) {
+      const w = byPackageId.get(ref.packageId);
+      if (w) {
+        applyRegistryMatch(w, name, resolved);
+        matched = true;
       }
     }
 
+    // Fallback path: no packageId on the layout item (legacy data).
+    // Rank candidates by how much of this dashboard they cover so
+    // shared-component bundles beat stray singleton packages.
+    if (!matched) {
+      const candidates = byComponentName.get(name);
+      if (Array.isArray(candidates) && candidates.length > 0) {
+        const ranked = rankCandidates(candidates);
+        applyRegistryMatch(ranked[0], name, resolved);
+      }
+    }
+    scope = resolved.scope;
+    packageName = resolved.packageName;
+    version = resolved.version;
+    author = resolved.author;
+
     // Fallback: resolve from component configs (built-in widgets)
     if (componentConfigs && componentConfigs[name]) {
       const config = componentConfigs[name];
@@ -64244,6 +64338,68 @@ function collectComponentNamesFromWorkspace$1(workspace) {
   return Array.from(names);
 }
 
+/**
+ * Walk the workspace and return one dependency ref per unique
+ * (component, packageId) pair. `packageId` is the exact source
+ * package id (e.g. `"@ai-built/pipeline"`) that was recorded on the
+ * layout item when the widget was added. Items that predate the
+ * packageId field carry `packageId: null`, and the caller falls back
+ * to registry-based resolution for those.
+ *
+ * Unlike `collectComponentNamesFromWorkspace`, this walk is the
+ * authoritative source for publish-time attribution — the publish
+ * flow no longer needs to guess which installed package provides a
+ * shared component when the layout item already says so.
+ *
+ * @param {Object} workspace - Workspace (layout/pages/sidebarLayout)
+ * @returns {Array<{component: string, packageId: string|null}>}
+ */
+function collectDependencyRefsFromWorkspace$1(workspace) {
+  const byKey = new Map();
+  const walk = (items) => {
+    if (!Array.isArray(items)) return;
+    for (const item of items) {
+      if (!item || typeof item !== "object") continue;
+      const component = item.component;
+      if (
+        component &&
+        component !== "Container" &&
+        component !== "LayoutGridContainer"
+      ) {
+        const packageId = item.packageId || null;
+        const key = `${component}|${packageId || ""}`;
+        if (!byKey.has(key)) byKey.set(key, { component, packageId });
+      }
+      // Grid cells may carry a string component name (new widget
+      // placed directly in a cell) with no corresponding layout item
+      // yet — capture it without a packageId so the fallback path
+      // still picks it up.
+      if (item.grid && typeof item.grid === "object") {
+        for (const [cellKey, cell] of Object.entries(item.grid)) {
+          if (!/^\d+\.\d+$/.test(cellKey)) continue;
+          if (cell && typeof cell.component === "string") {
+            const cellKey2 = `${cell.component}|`;
+            if (!byKey.has(cellKey2)) {
+              byKey.set(cellKey2, {
+                component: cell.component,
+                packageId: null,
+              });
+            }
+          }
+        }
+      }
+      if (Array.isArray(item.items)) walk(item.items);
+      if (Array.isArray(item.layout)) walk(item.layout);
+    }
+  };
+  walk(workspace?.layout);
+  walk(workspace?.sidebarLayout);
+  if (Array.isArray(workspace?.pages)) {
+    for (const page of workspace.pages) walk(page?.layout);
+  }
+  return Array.from(byKey.values());
+}
+
 /**
  * Extract event wiring across a workspace's main layout, every page
  * layout, and the sidebar layout. Mirrors collectComponentNamesFromWorkspace
@@ -64333,6 +64489,7 @@ function stripPersonalizationFromWorkspace$1(workspace) {
 var dashboardConfigUtils$1 = {
   collectComponentNames: collectComponentNames$1,
   collectComponentNamesFromWorkspace: collectComponentNamesFromWorkspace$1,
+  collectDependencyRefsFromWorkspace: collectDependencyRefsFromWorkspace$1,
   extractEventWiring: extractEventWiring$1,
   extractEventWiringFromWorkspace: extractEventWiringFromWorkspace$1,
   buildWidgetDependencies: buildWidgetDependencies$1,
@@ -65373,6 +65530,7 @@ const {
 const {
   collectComponentNames,
   collectComponentNamesFromWorkspace,
+  collectDependencyRefsFromWorkspace,
   extractEventWiring,
   extractEventWiringFromWorkspace,
   buildWidgetDependencies,
@@ -66486,12 +66644,14 @@ async function collectDashboardDependencies$1(
       };
     }
 
-    // 2. Collect component names from main + pages + sidebar layouts
-    const componentNames = collectComponentNamesFromWorkspace(workspace);
+    // 2. Collect dependency refs — each carries the exact packageId
+    //    recorded on the layout item when the widget was added, so
+    //    publish attribution is authoritative instead of heuristic.
+    const refs = collectDependencyRefsFromWorkspace(workspace);
 
     // 3. Resolve widget refs (scope, packageName, widgetName, version)
     const deps = buildWidgetDependencies(
-      componentNames,
+      refs,
       widgetRegistry,
       options.componentConfigs || null,
     );