@trops/dash-core 0.1.429 → 0.1.432

package/dist/electron/index.js

@@ -27270,7 +27270,7 @@ function findWidgetsDir$2(widgetPath) {
  * @param {string} widgetPath - Absolute path to the widget directory
  * @returns {Promise<string|null>} Path to the compiled bundle, or null if nothing to compile
  */
-async function compileWidget(widgetPath) {
+async function compileWidget$1(widgetPath) {
   const widgetsDir = findWidgetsDir$2(widgetPath);
 
   if (!widgetsDir) {
@@ -27402,7 +27402,7 @@ async function compileWidget(widgetPath) {
   }
 }
 
-var widgetCompiler$1 = { compileWidget, findWidgetsDir: findWidgetsDir$2 };
+var widgetCompiler$1 = { compileWidget: compileWidget$1, findWidgetsDir: findWidgetsDir$2 };
 
 /**
  * Dynamic Widget Loader
@@ -29418,25 +29418,31 @@ var schedulerController_1 = schedulerController$2;
 
 	      let bundlePath = findBundlePath(widget.path);
 
-	      // Auto-compile if no bundle exists (same as read-all-bundles)
+	      // Auto-compile if no bundle exists (registry installs ship the
+	      // bundle pre-compiled, so this fallback only fires for older
+	      // packages or local installs).
+	      let compileError = null;
 	      if (!bundlePath) {
 	        try {
 	          const compiled = await compileWidget(widget.path);
 	          if (compiled) {
 	            bundlePath = compiled;
 	          }
-	        } catch (compileError) {
-	          console.warn(
-	            `[WidgetRegistry] Could not compile ${widgetName}:`,
-	            compileError,
-	          );
+	        } catch (err) {
+	          compileError = err;
+	          // dash-core's electron build strips console.* — surface
+	          // the actual cause through the IPC return so the renderer
+	          // can show it to the user.
 	        }
 	      }
 
 	      if (!bundlePath) {
+	        const detail = compileError
+	          ? ` (auto-compile failed: ${compileError.message})`
+	          : "";
 	        return {
 	          success: false,
-	          error: `No bundle found in: ${widget.path}`,
+	          error: `No bundle found in: ${widget.path}${detail}`,
 	        };
 	      }
 
@@ -64504,6 +64510,96 @@ function stripPersonalizationFromWorkspace$1(workspace) {
   return cleaned;
 }
 
+/**
+ * Remap each layout item's `packageId` from a local-only scope (e.g.
+ * `@ai-built/foo`) to the caller's published scope (`@<callerScope>/foo`)
+ * so the installer's ComponentManager — which registers widgets under
+ * the published scope — can look them up.
+ *
+ * Mirrors the scope-remap that `generateRegistryManifest` already does
+ * for the dashboard's widget DEPENDENCIES list. Without this, the deps
+ * list is correct (`@callerScope/foo`) but the per-instance layout
+ * items still say `packageId: "@ai-built/foo"` — every Dependencies
+ * tab + publish-flow attribution on the installer's machine misses.
+ *
+ * Returns a deep copy. Idempotent: items already under the caller
+ * scope (or any non-local scope) pass through untouched.
+ *
+ * @param {Object} workspace
+ * @param {string} callerScope - Publisher's registry username (e.g. "trops")
+ * @param {string[]} [localOnlyScopes=["ai-built"]] - Scopes that must be remapped
+ */
+function remapLayoutPackageScopes$1(
+  workspace,
+  callerScope,
+  localOnlyScopes = ["ai-built"],
+) {
+  if (!workspace || !callerScope) return workspace;
+  const localScopeSet = new Set(
+    localOnlyScopes.map((s) => String(s).replace(/^@/, "")),
+  );
+  const callerScopeBare = String(callerScope).replace(/^@/, "");
+  const remapPackageId = (pkgId) => {
+    if (typeof pkgId !== "string" || pkgId.length === 0) return pkgId;
+    // Match `@<scope>/<rest>` or `<scope>/<rest>`. Tolerant of either form.
+    const m = pkgId.match(/^@?([^/]+)\/(.+)$/);
+    if (!m) return pkgId;
+    const scope = m[1];
+    const rest = m[2];
+    if (!localScopeSet.has(scope)) return pkgId;
+    return `@${callerScopeBare}/${rest}`;
+  };
+  // Layout items now carry a SCOPED `component` (e.g.
+  // "ai-built.pipeline.ProspectListColumn"). On publish we have to
+  // rewrite the scope segment to the caller's so the installer can
+  // resolve the same component against its registry-installed widget
+  // (which lives under "@<caller>/pipeline"). Bare component names
+  // (legacy layouts) pass through untouched — ComponentManager's
+  // bare-name fallback handles them on the install side.
+  const remapComponent = (component) => {
+    if (typeof component !== "string" || component.length === 0) {
+      return component;
+    }
+    const parts = component.split(".");
+    if (parts.length !== 3) return component;
+    const [scope, pkg, comp] = parts;
+    if (!localScopeSet.has(scope)) return component;
+    return `${callerScopeBare}.${pkg}.${comp}`;
+  };
+  const remapItem = (item) => {
+    if (!item || typeof item !== "object") return item;
+    const next = { ...item };
+    if (item.packageId) {
+      const remapped = remapPackageId(item.packageId);
+      if (remapped !== item.packageId) next.packageId = remapped;
+    }
+    if (item._sourcePackage) {
+      const remapped = remapPackageId(item._sourcePackage);
+      if (remapped !== item._sourcePackage) next._sourcePackage = remapped;
+    }
+    if (item.component) {
+      const remapped = remapComponent(item.component);
+      if (remapped !== item.component) next.component = remapped;
+    }
+    if (Array.isArray(item.items)) next.items = item.items.map(remapItem);
+    if (Array.isArray(item.layout)) next.layout = item.layout.map(remapItem);
+    return next;
+  };
+  const next = { ...workspace };
+  if (Array.isArray(next.layout)) next.layout = next.layout.map(remapItem);
+  if (Array.isArray(next.sidebarLayout)) {
+    next.sidebarLayout = next.sidebarLayout.map(remapItem);
+  }
+  if (Array.isArray(next.pages)) {
+    next.pages = next.pages.map((page) =>
+      page && Array.isArray(page.layout)
+        ? { ...page, layout: page.layout.map(remapItem) }
+        : page,
+    );
+  }
+  return next;
+}
+
 var dashboardConfigUtils$1 = {
   collectComponentNames: collectComponentNames$1,
   collectComponentNamesFromWorkspace: collectComponentNamesFromWorkspace$1,
@@ -64520,6 +64616,7 @@ var dashboardConfigUtils$1 = {
   buildProviderSetupManifest,
   checkApiCompatibility,
   stripPersonalizationFromWorkspace: stripPersonalizationFromWorkspace$1,
+  remapLayoutPackageScopes: remapLayoutPackageScopes$1,
 };
 
 /**
@@ -65561,6 +65658,7 @@ const {
   buildProviderRequirements,
   applyEventWiringToLayout,
   stripPersonalizationFromWorkspace,
+  remapLayoutPackageScopes,
 } = dashboardConfigUtils$1;
 const { searchRegistry, getPackage } = registryController$3;
 const { getStoredToken, clearToken } = registryAuthController$2;
@@ -66980,7 +67078,33 @@ async function prepareDashboardForPublish$1(
     // widget's own `defaultValue` on each field never gets a chance.
     // Layout position, ordering, nested containers, and any title text
     // are preserved (they're part of the template, not personal).
-    const sharedWorkspace = stripPersonalizationFromWorkspace(workspace);
+    let sharedWorkspace = stripPersonalizationFromWorkspace(workspace);
+
+    // Remap layout-item `packageId` from any local-only scope (e.g.
+    // `@ai-built/foo`) to the publisher's scope (`@<callerScope>/foo`).
+    // The widget-deps array in the dashboard manifest already gets
+    // remapped (see generateRegistryManifest), but the per-instance
+    // `packageId` on the layout items themselves was being shipped
+    // as-is — so installers' ComponentManager (which registers
+    // widgets under the published scope) couldn't reverse-look-up by
+    // `packageId` on a layout item, breaking the Dependencies tab and
+    // the publish-flow attribution on chained republishes.
+    let resolvedCallerScope = options.callerScope || options.githubUser || "";
+    if (!resolvedCallerScope) {
+      try {
+        const { getRegistryProfile } = registryAuthController$2;
+        const profile = await getRegistryProfile();
+        resolvedCallerScope = profile?.username || options.authorId || "";
+      } catch {
+        resolvedCallerScope = options.authorId || "";
+      }
+    }
+    if (resolvedCallerScope) {
+      sharedWorkspace = remapLayoutPackageScopes(
+        sharedWorkspace,
+        resolvedCallerScope,
+      );
+    }
     const layout = sharedWorkspace.layout || [];
 
     // 3. Build the dashboard config — walk main + pages + sidebar
@@ -73731,7 +73855,7 @@ const {
 } = registryAuthController$2;
 const widgetRegistryModule = widgetRegistryExports;
 const { dynamicWidgetLoader: dynamicWidgetLoader$1 } = dynamicWidgetLoaderExports;
-const { findWidgetsDir } = widgetCompiler$1;
+const { findWidgetsDir, compileWidget } = widgetCompiler$1;
 const {
   resolveNextVersion,
   parsePackageName,
@@ -73939,9 +74063,13 @@ async function stageOverrides(srcDir, dstDir, overrides) {
 
 // ─── ZIP builder ─────────────────────────────────────────────────────────────
 
+// `dist` is intentionally NOT excluded — the publish flow runs
+// `compileWidget` against the staged package right before zipping so
+// the installer doesn't have to recompile (and fail silently because
+// `console.*` is stripped from dash-core's electron build, masking
+// any esbuild error). Shipping the bundle makes install zero-config.
 const ZIP_EXCLUDE_DIRS = new Set([
   "node_modules",
-  "dist",
   ".git",
   ".DS_Store",
   ".next",
@@ -74152,6 +74280,25 @@ async function prepareWidgetForPublish$1(appId, packageId, options = {}) {
         await stageOverrides(widget.path, stagedDir, options.defaultsOverride);
         sourceDir = stagedDir;
       }
+
+      // Compile the widget into `dist/index.cjs.js` before zipping.
+      // The installer also runs compileWidget at first-load, but
+      // dash-core strips `console.*` from its electron bundle, so any
+      // esbuild error during install-time compile vanishes silently
+      // and the user just sees `No bundle found`. Compiling at
+      // publish time (where errors WILL surface to the publisher who
+      // can fix them) and shipping the bundle in the ZIP makes
+      // install zero-config.
+      try {
+        await compileWidget(sourceDir);
+      } catch (compileErr) {
+        return {
+          success: false,
+          error: `Widget compilation failed: ${compileErr.message}. Fix the source error and republish; otherwise installers won't be able to load the widget.`,
+          manifest,
+        };
+      }
+
       const zip = new AdmZip();
       addDirToZip(zip, sourceDir);
       zip.writeZip(zipPath);