@trops/dash-core 0.1.434 → 0.1.435

package/dist/index.js

@@ -14583,27 +14583,18 @@ var LayoutBuilderConfigModal = function LayoutBuilderConfigModal(_ref) {
     return s.key === activeSection;
   }) || sections[0];
 
-  // Scope/package label for the footer so the user can tell which
-  // package a widget comes from (ambiguous component names like
-  // `ProspectListColumn` can live under either `@ai-built/…` or
-  // `@trops/pipeline`). Same derivation order as WidgetCardHeader:
-  // widget config id → widget config package → layout item workspace.
+  // Footer label: derive @scope/package straight from the layout
+  // item's scoped component id. Strict — no workspace fallback.
   var footerPackageLabel = function () {
-    if (!itemSelected) return "";
-    var cfg = ComponentManager.config(itemSelected.component, itemSelected);
-    var dropTrailingComponent = function dropTrailingComponent(s) {
-      if (typeof s !== "string") return "";
-      var lastDot = s.lastIndexOf(".");
-      return lastDot > 0 ? s.slice(0, lastDot) : s;
-    };
-    var fromId = dropTrailingComponent((cfg === null || cfg === void 0 ? void 0 : cfg.id) || "");
-    if (fromId) return fromId;
-    if (cfg !== null && cfg !== void 0 && cfg["package"]) return String(cfg["package"]);
-    var ws = itemSelected.workspace;
-    if (typeof ws === "string" && ws && ws !== "layout") {
-      return ws.startsWith("@") ? ws : "@".concat(ws);
-    }
-    return "";
+    var scopedId = (itemSelected === null || itemSelected === void 0 ? void 0 : itemSelected.component) || "";
+    if (typeof scopedId !== "string") return "";
+    var parts = scopedId.split(".");
+    if (parts.length !== 3) return "";
+    var _parts = _slicedToArray(parts, 2),
+      scope = _parts[0],
+      pkg = _parts[1];
+    if (!scope || !pkg) return "";
+    return "@".concat(scope, "/").concat(pkg);
   }();
   var componentName = itemSelected ? itemSelected["component"] : "";
   var footerLeftContent = footerPackageLabel ? /*#__PURE__*/jsxRuntime.jsxs("span", {
@@ -18909,29 +18900,21 @@ var WidgetCardHeader = function WidgetCardHeader(_ref) {
   // Get widget name from config or item
   var widgetName = (widgetConfig === null || widgetConfig === void 0 ? void 0 : widgetConfig.displayName) || (widgetConfig === null || widgetConfig === void 0 ? void 0 : widgetConfig.name) || (widgetItem === null || widgetItem === void 0 ? void 0 : widgetItem.name) || (widgetItem === null || widgetItem === void 0 ? void 0 : widgetItem.component);
 
-  // Build a scope/package subtitle so ambiguous component names like
-  // `ProspectListColumn` (which might come from `@ai-built/…` or
-  // `@trops/pipeline`) are disambiguated in the layout builder. Derives
-  // from whatever identity the config / layout item carries:
-  //   - widgetConfig.id:   e.g. "@ai-built/prospectlistcolumn.ProspectListColumn"
-  //   - widgetConfig.package: e.g. "@ai-built/prospectlistcolumn"
-  //   - widgetItem.workspace: fallback hint ("ai-built" / "@trops/pipeline")
-  // Falls back to empty string so we can skip rendering if we have
-  // nothing meaningful beyond the component name itself.
+  // Derive the "@scope/package" label from the layout item's scoped
+  // component id (`scope.package.Component`). Strict — the layout item
+  // is the source of truth. If the item isn't scoped (a legacy layout
+  // that LayoutModel couldn't migrate, or a missing widget) the label
+  // is empty rather than guessed from the workspace category.
   var packageLabel = function () {
-    var dropTrailingComponent = function dropTrailingComponent(s) {
-      if (typeof s !== "string") return "";
-      var lastDot = s.lastIndexOf(".");
-      return lastDot > 0 ? s.slice(0, lastDot) : s;
-    };
-    var fromId = dropTrailingComponent((widgetConfig === null || widgetConfig === void 0 ? void 0 : widgetConfig.id) || "");
-    if (fromId) return fromId;
-    if (widgetConfig !== null && widgetConfig !== void 0 && widgetConfig["package"]) return String(widgetConfig["package"]);
-    var wsHint = widgetItem === null || widgetItem === void 0 ? void 0 : widgetItem.workspace;
-    if (typeof wsHint === "string" && wsHint && wsHint !== "layout") {
-      return wsHint.startsWith("@") ? wsHint : "@".concat(wsHint);
-    }
-    return "";
+    var scopedId = (widgetItem === null || widgetItem === void 0 ? void 0 : widgetItem.component) || (widgetConfig === null || widgetConfig === void 0 ? void 0 : widgetConfig.id) || "";
+    if (typeof scopedId !== "string") return "";
+    var parts = scopedId.split(".");
+    if (parts.length !== 3) return "";
+    var _parts = _slicedToArray(parts, 2),
+      scope = _parts[0],
+      pkg = _parts[1];
+    if (!scope || !pkg) return "";
+    return "@".concat(scope, "/").concat(pkg);
   }();
 
   // Get provider requirements from widget config (not from item directly)
@@ -27515,10 +27498,10 @@ function addChildToLayoutItem(childComponent, layoutItem, workspace) {
  *                        widgets share the same bare name
  * @returns {boolean} true if the widget can be rendered
  */
-function isWidgetResolvable(componentKey, data) {
+function isWidgetResolvable(componentKey) {
   // Layout containers are always resolvable (handled specially by WidgetFactory)
   if (ComponentManager.isLayoutContainer(componentKey)) return true;
-  var config = ComponentManager.resolve(componentKey, data);
+  var config = ComponentManager.resolve(componentKey);
   return !!(config && typeof config.component === "function");
 }
 
@@ -27548,6 +27531,52 @@ function isWidgetResolvable(componentKey, data) {
 //     isMinOrderForItem
 // }
 
+/**
+ * One-shot legacy bare-name → canonical scoped-id migration.
+ *
+ * Pre-v0.1.435 dashboards stored layout items with bare component
+ * names (`component: "PipelineKanban"`). Post-v0.1.435 the registry
+ * is keyed strictly by scoped ids (`scope.package.Component`) and
+ * `resolveComponentKey` does no fallback scanning. This helper
+ * bridges the two: at workspace-load time, walk the registry once
+ * and rewrite any bare name that maps unambiguously to a scoped
+ * registration.
+ *
+ * Behavior (deliberately strict):
+ *   - Already-scoped (3 dot-separated parts) → return verbatim.
+ *   - Bare name with exactly one matching registry key ending in
+ *     `.${bareName}` → return the scoped key.
+ *   - Zero matches OR multiple matches → return verbatim. The
+ *     renderer surfaces `WidgetNotFound` rather than guessing wrong;
+ *     the user can resave or republish to fix the layout.
+ *
+ * Should be called once per layout item on workspace load. After the
+ * workspace is saved, every item carries a scoped id and this helper
+ * is a no-op.
+ *
+ * @param {Object} componentMap - The live registry map keyed by scoped ids
+ * @param {string} component - The layout item's `component` field
+ * @returns {string} - The canonical scoped id, or the input unchanged
+ */
+function migrateBareComponentName(componentMap, component) {
+  if (!componentMap || typeof component !== "string" || !component) {
+    return component;
+  }
+  // Already scoped — fast path. Three dot-separated parts is the
+  // canonical shape (`scope.package.Component`); anything else
+  // (bare names, two-part forms, four-part typos) goes through the
+  // suffix scan.
+  if (component.split(".").length === 3) return component;
+  // Already in the registry under its current key — also a fast path.
+  if (component in componentMap) return component;
+  var suffix = ".".concat(component);
+  var matches = Object.keys(componentMap).filter(function (k) {
+    return k.endsWith(suffix);
+  });
+  if (matches.length === 1) return matches[0];
+  return component;
+}
+
 function ownKeys$C(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$C(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$C(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$C(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _createForOfIteratorHelper$k(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$k(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
@@ -27625,6 +27654,14 @@ var LayoutModel = function LayoutModel(layoutItem, workspaceLayout, dashboardId)
       layout.component = obj["componentName"];
     }
 
+    // Legacy bare-name migration. Pre-v0.1.435 layouts stored
+    // `component: "PipelineKanban"`; the registry is now strictly
+    // keyed by `scope.package.Component`. If the layout item still
+    // carries a bare name AND the registry has exactly one matching
+    // scoped key, rewrite to the scoped form. The next save persists
+    // the migration. Idempotent — already-scoped names pass through.
+    layout.component = migrateBareComponentName(ComponentManager.componentMap(), layout.component);
+
     /**
      * @param {String} direction Layout direction (row|col)
      * @deprecated Use grid layout instead of flexbox direction
@@ -27686,7 +27723,10 @@ var LayoutModel = function LayoutModel(layoutItem, workspaceLayout, dashboardId)
 
     layout.uuid = dashboardId !== undefined ? "".concat(dashboardId, "-").concat(layout["component"], "-").concat(layout.id) : "".concat(layout["component"], "-").concat(layout.id);
 
-    /// widget configuration
+    // Resolve widget configuration — strict scoped lookup. By this
+    // point `layout.component` has already been migrated from any
+    // legacy bare name above, so config() either returns the live
+    // entry or null (renderer shows WidgetNotFound).
     var widgetConfig = ComponentManager.config(layout["component"], obj);
     layout.userPrefs = {};
     layout.widgetConfig = widgetConfig;
@@ -27701,16 +27741,6 @@ var LayoutModel = function LayoutModel(layoutItem, workspaceLayout, dashboardId)
       if (Array.isArray(widgetConfig.eventHandlers)) {
         layout.eventHandlers = widgetConfig.eventHandlers;
       }
-      // Migrate legacy bare `component` references to the canonical
-      // scoped form (`scope.package.Component`). ComponentManager.config
-      // returns the resolved scoped key on `widgetConfig.component`, so
-      // we just lift it. Idempotent: items already scoped pass through
-      // unchanged because resolveComponentKey returns the input verbatim
-      // when it's already in the map. Persisted on next save — no
-      // separate migration step needed.
-      if (typeof widgetConfig.component === "string" && widgetConfig.component && widgetConfig.component !== layout.component) {
-        layout.component = widgetConfig.component;
-      }
     }
 
     // Merge user-entered config values (from EnhancedWidgetDropdown) into userPrefs
@@ -31396,6 +31426,34 @@ var ContextModel = /*#__PURE__*/function () {
   }]);
 }();
 
+/**
+ * Resolve a component reference to its registry key.
+ *
+ * Strict exact-match lookup. Layout items carry the canonical scoped
+ * id (`scope.package.Component`); the registry stores entries under
+ * the same key. If the layout item's `component` doesn't match a
+ * registered key exactly, the renderer shows `WidgetNotFound` — there
+ * is no suffix-scan fallback and no `packageId` hint, because both
+ * could silently resolve a typo / legacy bare name to the wrong widget.
+ *
+ * Legacy dashboards that still carry a bare `component` (pre-scope
+ * migration) are handled in `LayoutModel`, which performs a one-shot
+ * suffix-scan rewrite on load. By the time `resolveComponentKey` is
+ * called, every layout item is expected to have a fully scoped id.
+ *
+ * Pure function. No side effects. Stays outside ComponentManager so
+ * it can be tested in isolation without the Models/Layout import chain.
+ *
+ * @param {Object} componentMap - The registry map keyed by scoped ids
+ * @param {string} component - The scoped id from the layout item
+ * @returns {string|null} The matching registry key, or null
+ */
+function resolveComponentKey(componentMap, component) {
+  if (!componentMap || !component) return null;
+  if (typeof component !== "string") return null;
+  return component in componentMap ? component : null;
+}
+
 /**
  * scopedComponentId.js
  *
@@ -31462,57 +31520,48 @@ function bareComponentName(idOrName) {
   return parts[parts.length - 1] || "";
 }
 
+var _componentMap = {};
+var _containerComponent = null;
+var _gridContainerComponent = null;
+
 /**
- * Resolve a component name to a registry key. Returns null if no
- * match exists.
+ * Compute the canonical `scope.package.Component` id for a widget
+ * config. Throws if the config doesn't carry enough origin metadata
+ * to derive an id.
  *
- * Pure function — depends only on the passed-in `componentMap` and
- * `data`. Lives outside ComponentManager so it can be tested without
- * pulling in the full Component/Layout import chain (and so other
- * call sites can route through it without circular deps).
+ * Order of precedence:
+ *   - `config.id` already scoped (3 dot-separated parts, no leading "@")
+ *   - `config.scope` + `config.packageName` + (`config.name` |
+ *     `config.component?.displayName` | `config.component?.name`)
+ *   - Otherwise throw — the config is missing origin info and would
+ *     register under an ambiguous key.
  *
- * Lookup order (the LAYOUT ITEM is the source of truth):
- *   1. EXACT match on `component` — covers the new scoped form
- *      (`scope.package.X`) and any legacy `.dash.js` that already
- *      set `config.id` to a scoped value.
- *   2. If `component` is bare (no dots) AND we have a packageId hint
- *      on the layout item, build the scoped id and try that.
- *   3. Bare-name fallback: scan the map for any key ending in
- *      `.${component}`. If exactly one matches, use it. If multiple
- *      match (the collision case), prefer the one matching the
- *      layout item's `packageId` / `_sourcePackage`; otherwise fall
- *      through to the first match (deterministic, but also logs a
- *      warning so callers can spot the ambiguity).
- *
- * Step (3) is the back-compat path for layouts authored before
- * scoped registration landed. New layouts ALWAYS resolve via step (1).
+ * The `widgetKey` is consulted ONLY when both above paths fail and
+ * the key itself is already a scoped id; this preserves compat with
+ * callers that pass a fully-qualified registration key.
  */
-function resolveComponentKey(componentMap, component, data) {
-  if (!componentMap || !component) return null;
-  if (component in componentMap) return component;
-  if (typeof component !== "string") return null;
-  if (component.includes(".")) return null;
-  var packageId = (data === null || data === void 0 ? void 0 : data.packageId) || (data === null || data === void 0 ? void 0 : data._sourcePackage) || (data === null || data === void 0 ? void 0 : data.packageName) || null;
-  if (packageId) {
-    var scoped = makeScopedComponentId(packageId, component);
-    if (scoped in componentMap) return scoped;
-  }
-  var suffix = ".".concat(component);
-  var matches = Object.keys(componentMap).filter(function (k) {
-    return k.endsWith(suffix);
-  });
-  if (matches.length === 0) return null;
-  if (matches.length === 1) return matches[0];
-  if (packageId) {
-    var target = makeScopedComponentId(packageId, component);
-    if (matches.includes(target)) return target;
-  }
-  return matches[0];
+function canonicalScopedId(config, widgetKey) {
+  var looksScoped = function looksScoped(s) {
+    return typeof s === "string" && s.split(".").length === 3 && !s.includes("/");
+  };
+  if (looksScoped(config === null || config === void 0 ? void 0 : config.id)) return config.id;
+  if (looksScoped(widgetKey)) return widgetKey;
+  if (config !== null && config !== void 0 && config.scope && config !== null && config !== void 0 && config.packageName) {
+    var _config$component, _config$component2;
+    var componentName = config.name || ((_config$component = config.component) === null || _config$component === void 0 ? void 0 : _config$component.displayName) || ((_config$component2 = config.component) === null || _config$component2 === void 0 ? void 0 : _config$component2.name) || null;
+    if (componentName) {
+      return makeScopedComponentId("".concat(String(config.scope).replace(/^@/, ""), "/").concat(config.packageName), componentName);
+    }
+  }
+  var dump = JSON.stringify({
+    id: config === null || config === void 0 ? void 0 : config.id,
+    scope: config === null || config === void 0 ? void 0 : config.scope,
+    packageName: config === null || config === void 0 ? void 0 : config.packageName,
+    name: config === null || config === void 0 ? void 0 : config.name,
+    widgetKey: widgetKey
+  });
+  throw new Error("[ComponentManager] Cannot register widget \u2014 missing origin metadata. " + "Need either a scoped `id` (scope.package.Component) or " + "`scope` + `packageName` + `name`. Got: ".concat(dump));
 }
-
-var _componentMap = {};
-var _containerComponent = null;
-var _gridContainerComponent = null;
 var ComponentManager = {
   // _componentMap: {},
 
@@ -31547,39 +31596,50 @@ var ComponentManager = {
     return _componentMap;
   },
   /**
-   * Resolve a component name to its registered config — single source
-   * of truth for every render-path lookup. Routes through
-   * `resolveComponentKey` so legacy bare names (`"ProspectWorkspace"`)
-   * still find their registered scoped counterpart
-   * (`"ai-built.pipeline.ProspectWorkspace"`). Returns null when the
-   * widget isn't registered. Pass the layout item as `data` to use
-   * its `packageId` / `_sourcePackage` for disambiguation.
+   * Resolve a component reference to its registered config. Strict
+   * exact-match lookup against the registry. Layout items are
+   * expected to carry the canonical scoped id
+   * (`scope.package.Component`); `LayoutModel` migrates legacy bare
+   * names to the scoped form on dashboard load.
    *
-   * @param {string} component
-   * @param {object} [data]
+   * Returns null when the widget isn't registered — the renderer then
+   * shows `WidgetNotFound`. There is no fallback.
+   *
+   * @param {string} component - The scoped widget id
    * @returns {object|null} the live registered config, or null
    */
-  resolve: function resolve(component, data) {
+  resolve: function resolve(component) {
     var m = _componentMap;
     if (!m) return null;
-    var key = resolveComponentKey(m, component, data);
+    var key = resolveComponentKey(m, component);
     return key ? m[key] || null : null;
   },
   /**
-   * The method for registering the widget into the Dashboard application
-   * This is a requirement for the widget to be included into the Dash
+   * Register a widget config under its canonical scoped id.
+   *
+   * Every widget that enters the registry MUST have a scope.package
+   * .Component id. The id is determined in this order:
+   *   1. `config.id` already in scoped form → trust it.
+   *   2. `config.scope` + `config.packageName` + `config.name` → derive.
+   *   3. Otherwise → throw. Silent fallbacks here are how layouts end
+   *      up referencing widgets that were registered under the wrong
+   *      key, so we fail loudly at registration instead of producing
+   *      a corrupt registry.
    *
-   * @param {Object} widgetConfig the widget configuration script created by the developer
-   * @param {*} widgetKey the unique id for the widget
+   * `widgetKey` is kept for backwards compatibility with callers that
+   * pass a string key; it is consulted ONLY as a tiebreak when the
+   * config is otherwise complete.
+   *
+   * @param {Object} widgetConfig the widget configuration script
+   * @param {string} [widgetKey] legacy fallback key (informational only)
+   * @throws if origin metadata is missing
    */
   registerWidget: function registerWidget(widgetConfig, widgetKey) {
     var tempComponentMap = this.componentMap();
-    // Handle both module exports (widgetConfig.default) and direct config objects
     var config = widgetConfig["default"] || widgetConfig;
-    // Register under a single canonical key: config.id (scoped widget ID) if
-    // available, otherwise the provided widgetKey. No aliases — one widget, one key.
-    var registrationKey = config.id || widgetKey;
-    tempComponentMap[registrationKey] = ComponentConfigModel(config);
+    var id = canonicalScopedId(config, widgetKey);
+    config.id = id;
+    tempComponentMap[id] = ComponentConfigModel(config);
     this.setComponentMap(tempComponentMap);
   },
   /**
@@ -31633,15 +31693,14 @@ var ComponentManager = {
    * @returns {Widget} the Widget in the component map
    */
   getComponent: function getComponent(component) {
-    var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     try {
-      // console.log("get component");
       if (component && this.componentMap()) {
         if (ComponentManager.isLayoutContainer(component) === false) {
           var m = this.componentMap();
-          // Resolve through the scoped/bare lookup pipeline so layouts
-          // authored under either format land at the same registry key.
-          var resolvedKey = resolveComponentKey(m, component, data);
+          // Strict scoped-id lookup. If the layout item didn't carry
+          // a scoped id, LayoutModel should have migrated it before
+          // we get here.
+          var resolvedKey = resolveComponentKey(m, component);
           var cmp = resolvedKey ? m[resolvedKey] : null;
           if (cmp !== null && cmp !== undefined) {
             cmp["componentName"] = resolvedKey;
@@ -31804,7 +31863,6 @@ var ComponentManager = {
     var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     try {
       if (component) {
-        // console.log("config");
         var requiredFields = {
           type: {
             value: "text"
@@ -31819,35 +31877,19 @@ var ComponentManager = {
             value: ""
           }
         };
-
-        // get the component configuration from the map
         var components = this.map();
-        var resolvedKey = resolveComponentKey(components, component, data);
+        var resolvedKey = resolveComponentKey(components, component);
         if (resolvedKey && resolvedKey in components) {
-          // let c = deepCopy(components['component']);
-
-          // we have to make sure that we remove the component if this is a context
-
           var tempComponent = components[resolvedKey];
           delete tempComponent["component"];
           var c = JSON.parse(JSON.stringify(tempComponent));
-
-          // Carry the canonical scoped id forward so callers (LayoutModel,
-          // ComponentManager.getComponent) can rewrite layout items'
-          // `component` to the scoped form on first load.
           c["component"] = resolvedKey;
-
-          // if no userConfig key. let's add it for the next step
           if ("userConfig" in c === false) {
             c["userConfig"] = {};
           }
-
-          // if (isLayout === false) {
           var userPrefs = {};
-          // now we can make sure the configuration is "complete"
           if ("userConfig" in c) {
             Object.keys(c["userConfig"]).forEach(function (key) {
-              // check the required fields!
               Object.keys(requiredFields).forEach(function (k) {
                 if (k in c["userConfig"][key]) {
                   if (k in c["userConfig"][key] === false) {
@@ -31855,16 +31897,21 @@ var ComponentManager = {
                   }
                 }
               });
-              // set the user preferences
               userPrefs[key] = ComponentManager.userPrefsForItem("userPrefs" in data ? data : c, key, c["userConfig"][key]);
             });
           }
-
-          // set the user preferences here
           c["userPrefs"] = userPrefs;
+
+          // Identity fields (id/package/scope/...) are forwarded so
+          // consumers can derive the package label without reading
+          // the live registry directly. Without these, callers fall
+          // back to `item.workspace` which is a category, not a
+          // package, and produce labels like `@DashSamples-workspace`.
           return {
+            id: resolvedKey,
             type: c["type"],
             name: c["name"],
+            displayName: c["displayName"],
             workspace: c["workspace"],
             canHaveChildren: c["canHaveChildren"],
             userPrefs: c["userPrefs"],
@@ -31875,7 +31922,13 @@ var ComponentManager = {
             providers: "providers" in c ? c["providers"] : [],
             notifications: "notifications" in c ? c["notifications"] : [],
             scheduledTasks: "scheduledTasks" in c ? c["scheduledTasks"] : [],
-            icon: "icon" in c ? c["icon"] : null
+            icon: "icon" in c ? c["icon"] : null,
+            scope: c["scope"],
+            packageName: c["packageName"],
+            "package": c["package"],
+            author: c["author"],
+            version: c["version"],
+            _sourcePackage: c["_sourcePackage"]
           };
         }
         return null;
@@ -55554,26 +55607,23 @@ var DashboardConfigModal = function DashboardConfigModal(_ref) {
   // footer so the same package label shows in every surface.
   var dependencies = React.useMemo(function () {
     var byPackage = new Map();
-    var stripTrailingComponent = function stripTrailingComponent(s) {
-      if (typeof s !== "string") return "";
-      var lastDot = s.lastIndexOf(".");
-      return lastDot > 0 ? s.slice(0, lastDot) : s;
-    };
+    // Derive the @scope/package label from the layout item's scoped
+    // component id. Layout items are always scoped post-v0.1.435
+    // (LayoutModel migrates legacy bare names on load), so this is
+    // the single source of truth — no config lookup, no workspace
+    // fallback, no heuristics.
     var derivePackage = function derivePackage(item) {
-      // The layout item records the exact source package id when the
-      // widget was added. If present, trust it — no heuristics. This
-      // matches the publish flow's attribution, so the Dependencies
-      // tab and the Publish modal always agree.
+      var scopedId = typeof (item === null || item === void 0 ? void 0 : item.component) === "string" ? item.component : "";
+      var parts = scopedId.split(".");
+      if (parts.length === 3) {
+        var _parts = _slicedToArray(parts, 2),
+          scope = _parts[0],
+          pkg = _parts[1];
+        if (scope && pkg) return "@".concat(scope, "/").concat(pkg);
+      }
+      // Defensive: an explicit packageId on the item still wins for
+      // legacy items the migration couldn't auto-resolve.
       if (item !== null && item !== void 0 && item.packageId) return String(item.packageId);
-      var cfg = typeof getWidgetConfig === "function" ? getWidgetConfig(item.component) : null;
-      if (cfg !== null && cfg !== void 0 && cfg._sourcePackage) return String(cfg._sourcePackage);
-      var fromId = stripTrailingComponent((cfg === null || cfg === void 0 ? void 0 : cfg.id) || "");
-      if (fromId) return fromId;
-      if (cfg !== null && cfg !== void 0 && cfg["package"]) return String(cfg["package"]);
-      var ws = item === null || item === void 0 ? void 0 : item.workspace;
-      if (typeof ws === "string" && ws && ws !== "layout") {
-        return ws.startsWith("@") ? ws : "@".concat(ws);
-      }
       return "(unknown)";
     };