@trops/dash-core 0.1.132 → 0.1.133

package/dist/electron/index.js

@@ -1289,7 +1289,7 @@ const { getFileContents: getFileContents$6 } = file;
 const configFilename$4 = "themes.json";
 const appName$6 = "Dashboard";
 
-const themeController$2 = {
+const themeController$3 = {
   /**
    * saveTheme
    * Create a new Theme that can be used in the application
@@ -1420,7 +1420,7 @@ const themeController$2 = {
   },
 };
 
-var themeController_1 = themeController$2;
+var themeController_1 = themeController$3;
 
 /**
  * Utils/tranaform
@@ -7991,6 +7991,25 @@ var properties = {
 		description: "Originating app package name (from package.json). Informational — indicates which app this dashboard was built for.",
 		maxLength: 200
 	},
+	theme: {
+		type: "object",
+		description: "Optional bundled theme for the dashboard",
+		properties: {
+			key: {
+				type: "string",
+				description: "Theme key in the app"
+			},
+			data: {
+				type: "object",
+				description: "Full raw theme source object"
+			},
+			registryPackage: {
+				type: "string",
+				description: "Scoped registry package name (e.g. 'username/ocean-depth')"
+			}
+		},
+		additionalProperties: false
+	},
 	eventWiring: {
 		type: "array",
 		description: "Pre-configured event connections between widgets",
@@ -10702,765 +10721,435 @@ var registryApiController$2 = {
 };
 
 /**
- * dashboardConfigController.js
- *
- * Handles export and import of dashboard configuration files.
- * Runs in the Electron main process.
- *
- * Export: serializes a workspace into a .dashboard.json config,
- * resolving widget dependencies, extracting event wiring from
- * layout listeners, and aggregating provider requirements.
+ * themeRegistryController.js
  *
- * Import: validates and processes a .dashboard.json config,
- * auto-installs missing widgets, creates workspace, and
- * applies event wiring. (Import is implemented in DASH-13.)
+ * Handles publishing themes to and installing themes from the Dash registry.
+ * Mirrors dashboardConfigController patterns for ZIP creation, manifest generation,
+ * and registry interaction.
  */
-
-const { app: app$2, dialog: dialog$1 } = require$$0$1;
 const path$2 = require$$1$1;
+const { app: app$2, dialog: dialog$1 } = require$$0$1;
 const AdmZip$1 = require$$3$3;
-const { getFileContents: getFileContents$1 } = file;
-const {
-  validateDashboardConfig,
-  applyDefaults,
-  CURRENT_SCHEMA_VERSION,
-} = dashboardConfigValidator$1;
-const {
-  collectComponentNames,
-  extractEventWiring,
-  buildWidgetDependencies,
-  buildProviderRequirements,
-  applyEventWiringToLayout,
-} = dashboardConfigUtils$1;
-const { searchRegistry, getPackage } = registryController$2;
 
-const configFilename = "workspaces.json";
-const appName$1 = "Dashboard";
+const themeController$2 = themeController_1;
+const registryController$1 = registryController$2;
+const registryApiController$1 = registryApiController$2;
+const { getAuthStatus } = registryAuthController$1;
 
 /**
- * Export a workspace as a .dashboard.json config inside a ZIP file.
+ * Sanitize a name for use as a filename (lowercase, hyphens only).
+ */
+function sanitizeName(name) {
+  return (name || "theme")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+/**
+ * Generate a registry manifest for a theme package.
  *
- * @param {BrowserWindow} win - The main window (for dialog)
+ * @param {Object} themeData - The raw theme object
+ * @param {string} themeKey - The theme key/name
+ * @param {Object} options - Publish options { authorName, description, tags, scope }
+ * @returns {Object} Registry manifest
+ */
+function generateThemeRegistryManifest(themeData, themeKey, options = {}) {
+  const sanitizedName = sanitizeName(themeKey);
+  const colors = extractColors(themeData);
+
+  return {
+    scope: options.scope || "",
+    name: sanitizedName,
+    displayName: themeKey,
+    author: options.authorName || "",
+    description: options.description || "",
+    version: "1.0.0",
+    type: "theme",
+    category: "general",
+    tags: options.tags || [],
+    icon: "palette",
+    colors,
+    appOrigin: options.appOrigin || "",
+    publishedAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Extract primary/secondary/tertiary/neutral colors from a theme object.
+ * Theme objects store colors in various structures; this normalizes them.
+ */
+function extractColors(themeData) {
+  const colors = {
+    primary: "",
+    secondary: "",
+    tertiary: "",
+    neutral: "",
+  };
+
+  if (!themeData) return colors;
+
+  // Direct color fields
+  if (themeData.primary) colors.primary = themeData.primary;
+  if (themeData.secondary) colors.secondary = themeData.secondary;
+  if (themeData.tertiary) colors.tertiary = themeData.tertiary;
+  if (themeData.neutral) colors.neutral = themeData.neutral;
+
+  // Nested under "colors" key
+  if (themeData.colors) {
+    if (themeData.colors.primary) colors.primary = themeData.colors.primary;
+    if (themeData.colors.secondary)
+      colors.secondary = themeData.colors.secondary;
+    if (themeData.colors.tertiary) colors.tertiary = themeData.colors.tertiary;
+    if (themeData.colors.neutral) colors.neutral = themeData.colors.neutral;
+  }
+
+  return colors;
+}
+
+/**
+ * Prepare a theme for publishing to the registry.
+ *
+ * Reads the theme from themes.json, generates a manifest, creates a ZIP,
+ * and publishes via the registry API.
+ *
+ * @param {BrowserWindow} win - The sender window
  * @param {string} appId - Application identifier
- * @param {number|string} workspaceId - ID of the workspace to export
- * @param {Object} options - Export options
- * @param {string} options.authorName - Dashboard author name
- * @param {string} options.authorId - Dashboard author ID
- * @param {Object} widgetRegistry - WidgetRegistry instance (optional)
- * @returns {Promise<Object>} Result with success flag and file path
+ * @param {string} themeKey - Key of the theme to publish
+ * @param {Object} options - { authorName, description, tags }
+ * @returns {Object} Result with success, manifest, registryResult
  */
-async function exportDashboardConfig$1(
-  win,
-  appId,
-  workspaceId,
-  options = {},
-  widgetRegistry = null,
-) {
+async function prepareThemeForPublish$1(win, appId, themeKey, options = {}) {
   try {
-    // 1. Read workspace from workspaces.json
-    const filename = path$2.join(
-      app$2.getPath("userData"),
-      appName$1,
-      appId,
-      configFilename,
-    );
-    const workspacesArray = getFileContents$1(filename);
-    const workspace = workspacesArray.find(
-      (w) => w.id === workspaceId || w.id === Number(workspaceId),
-    );
+    // Read the theme data
+    const themesResult = themeController$2.listThemesForApplication(win, appId);
+    if (themesResult.error) {
+      return { success: false, error: "Failed to read themes: " + themesResult.message };
+    }
 
-    if (!workspace) {
+    const themeData = themesResult.themes[themeKey];
+    if (!themeData) {
+      return { success: false, error: `Theme "${themeKey}" not found` };
+    }
+
+    // Get auth status for scope
+    const auth = getAuthStatus();
+    const scope = auth.profile?.username || options.scope || "";
+    if (!scope) {
       return {
         success: false,
-        error: `Workspace not found: ${workspaceId}`,
+        error: "Not authenticated with registry",
+        authRequired: true,
       };
     }
 
-    const layout = workspace.layout || [];
-
-    // 2. Collect components, extract wiring, resolve deps
-    const componentNames = collectComponentNames(layout);
-    const eventWiring = extractEventWiring(layout);
-    const widgets = buildWidgetDependencies(componentNames, widgetRegistry);
-    const providers = buildProviderRequirements(componentNames, widgetRegistry);
-
-    // 3. Build the dashboard config
-    const dashboardConfig = applyDefaults({
-      schemaVersion: CURRENT_SCHEMA_VERSION,
-      name: workspace.name || workspace.label || "Exported Dashboard",
-      description: options.description || "",
-      ...(options.authorName
-        ? { author: { name: options.authorName, id: options.authorId || "" } }
-        : {}),
-      shareable: true,
-      tags: options.tags || [],
-      icon: options.icon || "grip",
-      workspace: {
-        id: workspace.id,
-        name: workspace.name,
-        type: workspace.type || "workspace",
-        label: workspace.label || workspace.name,
-        version: workspace.version || 1,
-        layout,
-        menuId: workspace.menuId || 1,
-      },
-      widgets,
-      providers,
-      eventWiring,
+    // Generate manifest
+    const manifest = generateThemeRegistryManifest(themeData, themeKey, {
+      ...options,
+      scope,
+      appOrigin: appId,
     });
 
-    // 4. Validate the generated config
-    const validation = validateDashboardConfig(dashboardConfig);
-    if (!validation.valid) {
+    // Validate colors
+    if (!manifest.colors.primary || !manifest.colors.secondary || !manifest.colors.tertiary) {
       return {
         success: false,
-        error: `Generated config is invalid: ${validation.errors.join(", ")}`,
+        error: "Theme must have primary, secondary, and tertiary colors defined",
       };
     }
 
-    // 5. Show save dialog
-    const sanitizedName = (workspace.name || "dashboard")
-      .replace(/[^a-zA-Z0-9-_ ]/g, "")
-      .replace(/\s+/g, "-")
-      .toLowerCase();
+    // Show save dialog
+    const sanitizedName = sanitizeName(themeKey);
+    const defaultFilename = `theme-${sanitizedName}-v${manifest.version}.zip`;
 
-    const { canceled, filePath } = await dialog$1.showSaveDialog(win, {
-      title: "Export Dashboard as ZIP",
-      defaultPath: path$2.join(
-        app$2.getPath("desktop"),
-        `dashboard-${sanitizedName}.zip`,
-      ),
-      filters: [{ name: "ZIP Archive", extensions: ["zip"] }],
+    const saveResult = await dialog$1.showSaveDialog(win, {
+      title: "Save Theme Package",
+      defaultPath: defaultFilename,
+      filters: [{ name: "ZIP Files", extensions: ["zip"] }],
     });
 
-    if (canceled || !filePath) {
-      return { success: false, canceled: true };
+    if (saveResult.canceled || !saveResult.filePath) {
+      return { success: false, error: "Save canceled" };
     }
 
-    // 6. Create ZIP with the config
+    const filePath = saveResult.filePath;
+
+    // Create ZIP with manifest.json + {name}.theme.json
     const zip = new AdmZip$1();
-    const configJson = JSON.stringify(dashboardConfig, null, 2);
     zip.addFile(
-      `${sanitizedName}.dashboard.json`,
-      Buffer.from(configJson, "utf-8"),
+      "manifest.json",
+      Buffer.from(JSON.stringify(manifest, null, 2), "utf-8"),
+    );
+    zip.addFile(
+      `${sanitizedName}.theme.json`,
+      Buffer.from(JSON.stringify(themeData, null, 2), "utf-8"),
     );
-
     zip.writeZip(filePath);
 
-    console.log(
-      `[DashboardConfigController] Exported dashboard to: ${filePath}`,
-    );
+    console.log("[ThemeRegistryController] ZIP created at:", filePath);
+
+    // Attempt to publish to registry
+    let registryResult = null;
+    if (auth.authenticated) {
+      registryResult = await registryApiController$1.publishToRegistry(
+        filePath,
+        manifest,
+      );
+      console.log("[ThemeRegistryController] Registry publish result:", registryResult);
+    }
 
     return {
       success: true,
+      manifest,
       filePath,
-      config: dashboardConfig,
-    };
-  } catch (error) {
-    console.error(
-      "[DashboardConfigController] Error exporting dashboard:",
-      error,
-    );
-    return {
-      success: false,
-      error: error.message,
+      registryResult,
     };
+  } catch (err) {
+    console.error("[ThemeRegistryController] Error preparing theme for publish:", err);
+    return { success: false, error: err.message };
   }
 }
 
 /**
- * Select and preview a dashboard ZIP file without importing it.
- * Opens the file picker, extracts and validates the .dashboard.json,
- * and returns a preview of the config + the file path for later import.
+ * Install a theme from the registry.
  *
- * @param {BrowserWindow} win - The main window (for dialog)
- * @returns {Promise<Object>} Result with success, filePath, and dashboardConfig preview
+ * Looks up the theme package, downloads the ZIP, extracts the .theme.json,
+ * and saves it via themeController.
+ *
+ * @param {BrowserWindow} win - The sender window
+ * @param {string} appId - Application identifier
+ * @param {string} packageName - Registry package name (e.g., "username/ocean-depth")
+ * @returns {Object} Result with success, themeKey, theme
  */
-async function selectDashboardFile$1(win) {
+async function installThemeFromRegistry$1(win, appId, packageName) {
   try {
-    const { canceled, filePaths } = await dialog$1.showOpenDialog(win, {
-      title: "Import Dashboard Configuration",
-      filters: [{ name: "ZIP Archive", extensions: ["zip"] }],
-      properties: ["openFile"],
-    });
-
-    if (canceled || !filePaths || !filePaths.length) {
-      return { success: false, canceled: true };
+    // Look up the package
+    const pkg = await registryController$1.getPackage(packageName);
+    if (!pkg) {
+      return { success: false, error: `Theme package "${packageName}" not found in registry` };
     }
 
-    const zipPath = filePaths[0];
-
-    // Extract and validate
-    const zip = new AdmZip$1(zipPath);
-    const tempDir = path$2.join(app$2.getPath("temp"), "dash-import");
-    const { validateZipEntries } = widgetRegistryExports;
-    validateZipEntries(zip, tempDir);
+    // Resolve download URL
+    let downloadUrl = pkg.downloadUrl;
+    if (!downloadUrl) {
+      return { success: false, error: "Package has no download URL" };
+    }
 
-    const entries = zip.getEntries();
-    const configEntry = entries.find((e) =>
-      e.entryName.endsWith(".dashboard.json"),
-    );
+    // Resolve template variables
+    downloadUrl = downloadUrl
+      .replace("{version}", pkg.version || "1.0.0")
+      .replace("{name}", pkg.name || "");
 
-    if (!configEntry) {
-      return {
-        success: false,
-        error: "No .dashboard.json file found in ZIP archive",
-      };
+    // Enforce HTTPS
+    if (!downloadUrl.startsWith("https://")) {
+      return { success: false, error: "Download URL must use HTTPS" };
     }
 
-    const configJson = configEntry.getData().toString("utf-8");
-    let dashboardConfig;
-    try {
-      dashboardConfig = JSON.parse(configJson);
-    } catch (parseError) {
-      return {
-        success: false,
-        error: `Invalid JSON: ${parseError.message}`,
-      };
-    }
+    console.log("[ThemeRegistryController] Downloading theme from:", downloadUrl);
 
-    const validation = validateDashboardConfig(dashboardConfig);
-    if (!validation.valid) {
+    // Download the ZIP
+    const response = await fetch(downloadUrl);
+    if (!response.ok) {
       return {
         success: false,
-        error: `Invalid config: ${validation.errors.join(", ")}`,
+        error: `Failed to download theme: ${response.status} ${response.statusText}`,
       };
     }
 
-    dashboardConfig = applyDefaults(dashboardConfig);
-
-    return {
-      success: true,
-      filePath: zipPath,
-      dashboardConfig: {
-        name: dashboardConfig.name,
-        description: dashboardConfig.description,
-        author: dashboardConfig.author,
-        workspace: dashboardConfig.workspace,
-        widgets: dashboardConfig.widgets || [],
-        providers: dashboardConfig.providers || [],
-      },
-    };
-  } catch (error) {
-    console.error(
-      "[DashboardConfigController] Error selecting dashboard file:",
-      error,
-    );
-    return { success: false, error: error.message };
-  }
-}
-
-/**
- * Import a dashboard from a ZIP file containing a .dashboard.json config.
- *
- * Steps:
- * 1. Show native file picker for .zip selection (or use options.filePath)
- * 2. Extract and validate .dashboard.json
- * 3. Auto-install missing widgets from registry
- * 4. Create workspace in workspaces.json
- * 5. Apply event wiring to layout
- * 6. Mark imported dashboard shareable: false
- *
- * @param {BrowserWindow} win - The main window (for dialog)
- * @param {string} appId - Application identifier
- * @param {Object} widgetRegistry - WidgetRegistry instance (needs getWidgets(), downloadWidget())
- * @param {Object} options - Import options
- * @param {string} options.filePath - Skip file picker, use this path directly
- * @param {string} options.name - Override workspace name
- * @param {number} options.menuId - Override workspace menuId (folder)
- * @param {string} options.themeKey - Override workspace themeKey
- * @returns {Promise<Object>} Result with success, workspace, and import summary
- */
-async function importDashboardConfig$1(
-  win,
-  appId,
-  widgetRegistry = null,
-  options = {},
-) {
-  try {
-    let zipPath;
+    const arrayBuffer = await response.arrayBuffer();
+    const zipBuffer = Buffer.from(arrayBuffer);
 
-    if (options.filePath) {
-      // Use the provided file path (from selectDashboardFile)
-      zipPath = options.filePath;
-    } else {
-      // Show file picker
-      const { canceled, filePaths } = await dialog$1.showOpenDialog(win, {
-        title: "Import Dashboard Configuration",
-        filters: [{ name: "ZIP Archive", extensions: ["zip"] }],
-        properties: ["openFile"],
-      });
+    // Extract .theme.json from ZIP
+    const zip = new AdmZip$1(zipBuffer);
+    const entries = zip.getEntries();
 
-      if (canceled || !filePaths || !filePaths.length) {
-        return { success: false, canceled: true };
-      }
+    const themeEntry = entries.find((entry) =>
+      entry.entryName.endsWith(".theme.json"),
+    );
 
-      zipPath = filePaths[0];
+    if (!themeEntry) {
+      return { success: false, error: "ZIP does not contain a .theme.json file" };
     }
 
-    // 2. Extract and validate .dashboard.json from ZIP
-    const zip = new AdmZip$1(zipPath);
-
-    // Validate ZIP entries for path traversal
-    const tempDir = path$2.join(app$2.getPath("temp"), "dash-import");
-    const { validateZipEntries } = widgetRegistryExports;
-    validateZipEntries(zip, tempDir);
-
-    // Find the .dashboard.json file
-    const entries = zip.getEntries();
-    const configEntry = entries.find((e) =>
-      e.entryName.endsWith(".dashboard.json"),
-    );
-
-    if (!configEntry) {
-      return {
-        success: false,
-        error: "No .dashboard.json file found in ZIP archive",
-      };
+    // Validate entry path (security: prevent path traversal)
+    if (themeEntry.entryName.includes("..") || path$2.isAbsolute(themeEntry.entryName)) {
+      return { success: false, error: "Invalid file path in ZIP" };
     }
 
-    const configJson = configEntry.getData().toString("utf-8");
-    let dashboardConfig;
+    // Parse theme data
+    const themeJson = themeEntry.getData().toString("utf-8");
+    let themeData;
     try {
-      dashboardConfig = JSON.parse(configJson);
-    } catch (parseError) {
-      return {
-        success: false,
-        error: `Invalid JSON in ${configEntry.entryName}: ${parseError.message}`,
-      };
+      themeData = JSON.parse(themeJson);
+    } catch (parseErr) {
+      return { success: false, error: "Invalid JSON in theme file: " + parseErr.message };
     }
 
-    // Validate against schema
-    const validation = validateDashboardConfig(dashboardConfig);
-    if (!validation.valid) {
-      return {
-        success: false,
-        error: `Invalid dashboard config: ${validation.errors.join(", ")}`,
-      };
-    }
+    // Add registry metadata
+    themeData._registryMeta = {
+      source: "registry",
+      packageName,
+      installedAt: new Date().toISOString(),
+    };
 
-    // Apply defaults to fill in optional fields
-    dashboardConfig = applyDefaults(dashboardConfig);
+    // Determine theme key from package display name or name
+    const themeKey = pkg.displayName || pkg.name;
 
-    // Delegate to shared import pipeline with overrides
-    return await processDashboardConfig(
+    // Save via themeController
+    const saveResult = themeController$2.saveThemeForApplication(
       win,
       appId,
-      dashboardConfig,
-      widgetRegistry,
-      {
-        name: options.name,
-        menuId: options.menuId,
-        themeKey: options.themeKey,
-      },
-    );
-  } catch (error) {
-    console.error(
-      "[DashboardConfigController] Error importing dashboard:",
-      error,
+      themeKey,
+      themeData,
     );
+
+    if (saveResult.error) {
+      return { success: false, error: "Failed to save theme: " + saveResult.message };
+    }
+
+    console.log("[ThemeRegistryController] Theme installed:", themeKey);
+
     return {
-      success: false,
-      error: error.message,
+      success: true,
+      themeKey,
+      theme: themeData,
+      themes: saveResult.themes,
     };
+  } catch (err) {
+    console.error("[ThemeRegistryController] Error installing theme:", err);
+    return { success: false, error: err.message };
   }
 }
 
 /**
- * Shared import pipeline: install widgets, create workspace, wire events.
- * Used by both importDashboardConfig (ZIP) and installDashboardFromRegistry.
+ * Get a preview of theme data for the publish modal.
  *
- * @param {BrowserWindow} win - The main window
  * @param {string} appId - Application identifier
- * @param {Object} dashboardConfig - Validated dashboard config object
- * @param {Object} widgetRegistry - WidgetRegistry instance
- * @param {Object} options - Additional options
- * @param {string} options.source - Source label ("zip" or "registry")
- * @returns {Promise<Object>} Result with success, workspace, and summary
+ * @param {string} themeKey - Theme key
+ * @returns {Object} Preview data with theme name, colors, etc.
  */
-async function processDashboardConfig(
-  win,
-  appId,
-  dashboardConfig,
-  widgetRegistry = null,
-  options = {},
-) {
-  const source = options.source || "zip";
-
-  // 1. Auto-install missing widgets from registry
-  const installSummary = {
-    installed: [],
-    alreadyInstalled: [],
-    failed: [],
-  };
-
-  if (
-    widgetRegistry &&
-    dashboardConfig.widgets &&
-    dashboardConfig.widgets.length
-  ) {
-    const installedWidgets = widgetRegistry.getWidgets();
-    const installedPackages = new Set(installedWidgets.map((w) => w.name));
-
-    for (const widgetDep of dashboardConfig.widgets) {
-      const packageName = widgetDep.package;
-
-      if (installedPackages.has(packageName)) {
-        installSummary.alreadyInstalled.push(packageName);
-        continue;
-      }
-
-      // Try to find the widget in the registry and install it
-      try {
-        const registryPkg = await getPackage(packageName);
-        if (registryPkg && registryPkg.downloadUrl) {
-          await widgetRegistry.downloadWidget(
-            packageName,
-            registryPkg.downloadUrl,
-            registryPkg.dashConfigUrl || null,
-          );
-          installSummary.installed.push(packageName);
-          installedPackages.add(packageName);
-        } else {
-          installSummary.failed.push({
-            package: packageName,
-            reason: "Not found in registry",
-          });
-        }
-      } catch (installError) {
-        installSummary.failed.push({
-          package: packageName,
-          reason: installError.message,
-        });
-      }
+function getThemePublishPreview$1(appId, themeKey) {
+  try {
+    const themesResult = themeController$2.listThemesForApplication(null, appId);
+    if (themesResult.error) {
+      return { success: false, error: "Failed to read themes: " + themesResult.message };
     }
-  }
-
-  // 2. Build workspace from config
-  const workspace = { ...dashboardConfig.workspace };
-
-  if (!workspace || !workspace.layout) {
-    return {
-      success: false,
-      error: "Dashboard config has no workspace data",
-    };
-  }
-
-  // Generate a unique ID for the imported workspace
-  workspace.id = Date.now();
-
-  // Apply name/menuId/themeKey overrides if provided
-  if (options.name) workspace.name = options.name;
-  if (options.menuId !== undefined) workspace.menuId = options.menuId;
-  if (options.themeKey !== undefined) workspace.themeKey = options.themeKey;
 
-  // 3. Apply event wiring to layout
-  const eventWiringSummary = [];
-  if (
-    dashboardConfig.eventWiring &&
-    dashboardConfig.eventWiring.length &&
-    workspace.layout
-  ) {
-    applyEventWiringToLayout(workspace.layout, dashboardConfig.eventWiring);
-    for (const wire of dashboardConfig.eventWiring) {
-      eventWiringSummary.push(
-        `${wire.source?.widget}.${wire.source?.event} → ${wire.target?.widget}.${wire.target?.handler}`,
-      );
+    const themeData = themesResult.themes[themeKey];
+    if (!themeData) {
+      return { success: false, error: `Theme "${themeKey}" not found` };
     }
-  }
-
-  // 4. Mark as not shareable (imported dashboards cannot be re-published)
-  workspace._dashboardConfig = {
-    shareable: false,
-    source,
-    importedFrom: dashboardConfig.name,
-    importedAt: new Date().toISOString(),
-    originalAuthor: dashboardConfig.author,
-    schemaVersion: dashboardConfig.schemaVersion,
-    registryPackage: options.registryPackage || null,
-    installedVersion: options.installedVersion || null,
-  };
 
-  // Save workspace to workspaces.json
-  const workspaceController = workspaceController_1;
-  const saveResult = workspaceController.saveWorkspaceForApplication(
-    win,
-    appId,
-    workspace,
-  );
+    const colors = extractColors(themeData);
 
-  if (saveResult.error) {
     return {
-      success: false,
-      error: `Failed to save workspace: ${saveResult.message}`,
+      success: true,
+      themeName: themeKey,
+      colors,
+      hasRegistryMeta: !!themeData._registryMeta,
     };
+  } catch (err) {
+    console.error("[ThemeRegistryController] Error getting preview:", err);
+    return { success: false, error: err.message };
   }
+}
 
-  // Build provider requirements summary
-  const providerSummary = (dashboardConfig.providers || []).map((p) => ({
-    type: p.type,
-    providerClass: p.providerClass,
-    required: p.required,
-    usedBy: p.usedBy,
-  }));
+var themeRegistryController$1 = {
+  prepareThemeForPublish: prepareThemeForPublish$1,
+  installThemeFromRegistry: installThemeFromRegistry$1,
+  getThemePublishPreview: getThemePublishPreview$1,
+  generateThemeRegistryManifest,
+  extractColors,
+};
 
-  console.log(
-    `[DashboardConfigController] Imported dashboard "${dashboardConfig.name}" (${source}) as workspace ${workspace.id}`,
-  );
+/**
+ * dashboardConfigController.js
+ *
+ * Handles export and import of dashboard configuration files.
+ * Runs in the Electron main process.
+ *
+ * Export: serializes a workspace into a .dashboard.json config,
+ * resolving widget dependencies, extracting event wiring from
+ * layout listeners, and aggregating provider requirements.
+ *
+ * Import: validates and processes a .dashboard.json config,
+ * auto-installs missing widgets, creates workspace, and
+ * applies event wiring. (Import is implemented in DASH-13.)
+ */
 
-  return {
-    success: true,
-    workspace,
-    summary: {
-      name: dashboardConfig.name,
-      description: dashboardConfig.description || "",
-      author: dashboardConfig.author,
-      widgets: installSummary,
-      eventsWired: eventWiringSummary,
-      providersRequired: providerSummary,
-    },
-  };
-}
+const { app: app$1, dialog } = require$$0$1;
+const path$1 = require$$1$1;
+const AdmZip = require$$3$3;
+const { getFileContents: getFileContents$1 } = file;
+const {
+  validateDashboardConfig,
+  applyDefaults,
+  CURRENT_SCHEMA_VERSION,
+} = dashboardConfigValidator$1;
+const {
+  collectComponentNames,
+  extractEventWiring,
+  buildWidgetDependencies,
+  buildProviderRequirements,
+  applyEventWiringToLayout,
+} = dashboardConfigUtils$1;
+const { searchRegistry, getPackage } = registryController$2;
+const themeController$1 = themeController_1;
+
+const configFilename = "workspaces.json";
+const appName$1 = "Dashboard";
 
 /**
- * Install a dashboard from the registry by package name.
- *
- * Fetches the dashboard ZIP from the registry, extracts the .dashboard.json,
- * validates it, and delegates to the shared import pipeline.
+ * Export a workspace as a .dashboard.json config inside a ZIP file.
  *
- * @param {BrowserWindow} win - The main window
+ * @param {BrowserWindow} win - The main window (for dialog)
  * @param {string} appId - Application identifier
- * @param {string} packageName - Registry package name for the dashboard
- * @param {Object} widgetRegistry - WidgetRegistry instance
- * @returns {Promise<Object>} Result with success, workspace, and summary
+ * @param {number|string} workspaceId - ID of the workspace to export
+ * @param {Object} options - Export options
+ * @param {string} options.authorName - Dashboard author name
+ * @param {string} options.authorId - Dashboard author ID
+ * @param {Object} widgetRegistry - WidgetRegistry instance (optional)
+ * @returns {Promise<Object>} Result with success flag and file path
  */
-async function installDashboardFromRegistry$1(
+async function exportDashboardConfig$1(
   win,
   appId,
-  packageName,
+  workspaceId,
+  options = {},
   widgetRegistry = null,
 ) {
   try {
-    // 1. Look up the dashboard package in the registry
-    const registryPkg = await getPackage(packageName);
-    if (!registryPkg) {
-      return {
-        success: false,
-        error: `Dashboard package not found in registry: ${packageName}`,
-      };
-    }
-
-    if (!registryPkg.downloadUrl) {
-      return {
-        success: false,
-        error: `Dashboard package has no download URL: ${packageName}`,
-      };
-    }
-
-    // 2. Resolve the download URL and fetch the ZIP
-    const version = registryPkg.version || "1.0.0";
-    let downloadUrl = registryPkg.downloadUrl;
-    downloadUrl = downloadUrl.replace("{version}", version);
-    downloadUrl = downloadUrl.replace("{name}", packageName);
-
-    // Enforce HTTPS
-    const parsedUrl = new URL(downloadUrl);
-    if (parsedUrl.protocol !== "https:") {
-      return {
-        success: false,
-        error: `Dashboard downloads must use HTTPS. Refusing: ${downloadUrl}`,
-      };
-    }
-
-    console.log(
-      `[DashboardConfigController] Fetching dashboard from: ${downloadUrl}`,
+    // 1. Read workspace from workspaces.json
+    const filename = path$1.join(
+      app$1.getPath("userData"),
+      appName$1,
+      appId,
+      configFilename,
+    );
+    const workspacesArray = getFileContents$1(filename);
+    const workspace = workspacesArray.find(
+      (w) => w.id === workspaceId || w.id === Number(workspaceId),
     );
 
-    const response = await fetch(downloadUrl);
-    if (!response.ok) {
+    if (!workspace) {
       return {
         success: false,
-        error: `Failed to download dashboard: ${response.status} ${response.statusText}`,
+        error: `Workspace not found: ${workspaceId}`,
       };
     }
 
-    const buffer = await response.arrayBuffer();
-    const zip = new AdmZip$1(Buffer.from(buffer));
+    const layout = workspace.layout || [];
 
-    // 3. Validate ZIP entries
-    const tempDir = path$2.join(app$2.getPath("temp"), "dash-registry-import");
-    const { validateZipEntries } = widgetRegistryExports;
-    validateZipEntries(zip, tempDir);
-
-    // 4. Find and parse .dashboard.json
-    const entries = zip.getEntries();
-    const configEntry = entries.find((e) =>
-      e.entryName.endsWith(".dashboard.json"),
-    );
-
-    if (!configEntry) {
-      return {
-        success: false,
-        error: "No .dashboard.json file found in downloaded archive",
-      };
-    }
-
-    const configJson = configEntry.getData().toString("utf-8");
-    let dashboardConfig;
-    try {
-      dashboardConfig = JSON.parse(configJson);
-    } catch (parseError) {
-      return {
-        success: false,
-        error: `Invalid JSON in dashboard config: ${parseError.message}`,
-      };
-    }
-
-    // 5. Validate against schema
-    const validation = validateDashboardConfig(dashboardConfig);
-    if (!validation.valid) {
-      return {
-        success: false,
-        error: `Invalid dashboard config: ${validation.errors.join(", ")}`,
-      };
-    }
-
-    dashboardConfig = applyDefaults(dashboardConfig);
-
-    // 6. Delegate to shared import pipeline
-    return await processDashboardConfig(
-      win,
-      appId,
-      dashboardConfig,
-      widgetRegistry,
-      {
-        source: "registry",
-        registryPackage: packageName,
-        installedVersion: registryPkg.version || null,
-      },
-    );
-  } catch (error) {
-    console.error(
-      "[DashboardConfigController] Error installing dashboard from registry:",
-      error,
-    );
-    return {
-      success: false,
-      error: error.message,
-    };
-  }
-}
-
-/**
- * Check compatibility of a dashboard's widget dependencies against
- * installed widgets and registry availability.
- *
- * @param {Array} dashboardWidgets - Widget deps from dashboard config
- * @param {Object} widgetRegistry - WidgetRegistry instance (needs getWidgets())
- * @returns {Promise<Object>} Compatibility report
- */
-async function checkCompatibility$1(dashboardWidgets, widgetRegistry = null) {
-  const {
-    checkDashboardCompatibility,
-  } = dashboardConfigUtils$1;
-  const { fetchRegistryIndex } = registryController$2;
-
-  const installedWidgets = widgetRegistry ? widgetRegistry.getWidgets() : [];
-
-  let registryPackages = [];
-  try {
-    const index = await fetchRegistryIndex();
-    registryPackages = index.packages || [];
-  } catch (err) {
-    console.warn(
-      "[DashboardConfigController] Could not fetch registry index for compatibility check:",
-      err.message,
-    );
-  }
-
-  return checkDashboardCompatibility(
-    dashboardWidgets,
-    installedWidgets,
-    registryPackages,
-  );
-}
-
-/**
- * Prepare a dashboard for publishing to the registry.
- *
- * Validates that the workspace is shareable, builds the dashboard config,
- * checks that all widgets exist in the registry, generates a registry
- * manifest, and creates a ZIP containing both the manifest and
- * .dashboard.json config.
- *
- * @param {BrowserWindow} win - The main window (for save dialog)
- * @param {string} appId - Application identifier
- * @param {number|string} workspaceId - ID of the workspace to publish
- * @param {Object} options - Publishing options
- * @param {string} options.authorName - Author name
- * @param {string} options.authorId - Author ID
- * @param {string} options.description - Dashboard description
- * @param {string[]} options.tags - Tags
- * @param {string} options.icon - Icon name
- * @param {string} options.githubUser - GitHub user/org for registry scope
- * @param {string} options.category - Registry category
- * @param {Object} widgetRegistry - WidgetRegistry instance
- * @returns {Promise<Object>} Result with success, manifest, and filePath
- */
-async function prepareDashboardForPublish$1(
-  win,
-  appId,
-  workspaceId,
-  options = {},
-  widgetRegistry = null,
-) {
-  try {
-    const {
-      generateRegistryManifest,
-    } = dashboardConfigUtils$1;
-
-    // 1. Read workspace
-    const filename = path$2.join(
-      app$2.getPath("userData"),
-      appName$1,
-      appId,
-      configFilename,
-    );
-    const workspacesArray = getFileContents$1(filename);
-    const workspace = workspacesArray.find(
-      (w) => w.id === workspaceId || w.id === Number(workspaceId),
-    );
-
-    if (!workspace) {
-      return {
-        success: false,
-        error: `Workspace not found: ${workspaceId}`,
-      };
-    }
-
-    // 2. Check shareable flag — imported dashboards cannot be published
-    if (
-      workspace._dashboardConfig &&
-      workspace._dashboardConfig.shareable === false
-    ) {
-      return {
-        success: false,
-        error:
-          "This dashboard was imported and cannot be published. Only dashboards you created can be shared.",
-      };
-    }
-
-    const layout = workspace.layout || [];
-
-    // 3. Build the dashboard config (reuse export logic)
+    // 2. Collect components, extract wiring, resolve deps
     const componentNames = collectComponentNames(layout);
     const eventWiring = extractEventWiring(layout);
     const widgets = buildWidgetDependencies(componentNames, widgetRegistry);
     const providers = buildProviderRequirements(componentNames, widgetRegistry);
 
+    // 3. Build the dashboard config
     const dashboardConfig = applyDefaults({
       schemaVersion: CURRENT_SCHEMA_VERSION,
-      name: workspace.name || workspace.label || "Dashboard",
+      name: workspace.name || workspace.label || "Exported Dashboard",
       description: options.description || "",
       ...(options.authorName
         ? { author: { name: options.authorName, id: options.authorId || "" } }
@@ -11482,7 +11171,33 @@ async function prepareDashboardForPublish$1(
       eventWiring,
     });
 
-    // 4. Validate the config
+    // 4. Bundle theme if workspace has a themeKey
+    if (workspace.themeKey) {
+      try {
+        const themeResult = themeController$1.listThemesForApplication(
+          win,
+          appId,
+        );
+        const themeData = themeResult.themes?.[workspace.themeKey];
+        if (themeData) {
+          dashboardConfig.theme = {
+            key: workspace.themeKey,
+            data: themeData,
+          };
+          if (themeData._registryMeta?.packageName) {
+            dashboardConfig.theme.registryPackage =
+              themeData._registryMeta.packageName;
+          }
+        }
+      } catch (themeErr) {
+        console.warn(
+          "[DashboardConfigController] Could not bundle theme:",
+          themeErr.message,
+        );
+      }
+    }
+
+    // 5. Validate the generated config
     const validation = validateDashboardConfig(dashboardConfig);
     if (!validation.valid) {
       return {
@@ -11491,53 +11206,17 @@ async function prepareDashboardForPublish$1(
       };
     }
 
-    // 5. Check which widgets exist in the registry (soft warning, not blocking)
-    const { fetchRegistryIndex } = registryController$2;
-    let registryPackages = [];
-    let registryCheckFailed = false;
-    try {
-      const index = await fetchRegistryIndex();
-      registryPackages = index.packages || [];
-    } catch (err) {
-      console.warn(
-        `[DashboardConfigController] Unable to verify registry: ${err.message}`,
-      );
-      registryCheckFailed = true;
-    }
-
-    let missingFromRegistry = [];
-    if (!registryCheckFailed) {
-      const registryNames = new Set(registryPackages.map((p) => p.name));
-      const missingWidgets = widgets.filter(
-        (w) => w.required !== false && !registryNames.has(w.package),
-      );
-      const grouped = {};
-      for (const w of missingWidgets) {
-        if (!grouped[w.package]) grouped[w.package] = [];
-        const widgetName = w.id.includes(".") ? w.id.split(".")[1] : w.id;
-        if (!grouped[w.package].includes(widgetName)) {
-          grouped[w.package].push(widgetName);
-        }
-      }
-      missingFromRegistry = Object.entries(grouped).map(
-        ([pkg, widgetNames]) => ({ package: pkg, widgets: widgetNames }),
-      );
-    }
-
-    // 6. Generate registry manifest
-    const manifest = generateRegistryManifest(dashboardConfig, {
-      githubUser: options.githubUser || options.authorId || "",
-      category: options.category || "general",
-      repository: options.repository || "",
-    });
+    // 6. Show save dialog
+    const sanitizedName = (workspace.name || "dashboard")
+      .replace(/[^a-zA-Z0-9-_ ]/g, "")
+      .replace(/\s+/g, "-")
+      .toLowerCase();
 
-    // 7. Show save dialog for the publish package
-    const sanitizedName = manifest.name;
-    const { canceled, filePath } = await dialog$1.showSaveDialog(win, {
-      title: "Save Dashboard Package for Registry",
-      defaultPath: path$2.join(
-        app$2.getPath("desktop"),
-        `dashboard-${sanitizedName}-v${manifest.version}.zip`,
+    const { canceled, filePath } = await dialog.showSaveDialog(win, {
+      title: "Export Dashboard as ZIP",
+      defaultPath: path$1.join(
+        app$1.getPath("desktop"),
+        `dashboard-${sanitizedName}.zip`,
       ),
       filters: [{ name: "ZIP Archive", extensions: ["zip"] }],
     });
@@ -11546,840 +11225,1301 @@ async function prepareDashboardForPublish$1(
       return { success: false, canceled: true };
     }
 
-    // 8. Create ZIP with manifest and dashboard config
-    const zip = new AdmZip$1();
-    zip.addFile(
-      "manifest.json",
-      Buffer.from(JSON.stringify(manifest, null, 2), "utf-8"),
-    );
+    // 7. Create ZIP with the config
+    const zip = new AdmZip();
+    const configJson = JSON.stringify(dashboardConfig, null, 2);
     zip.addFile(
       `${sanitizedName}.dashboard.json`,
-      Buffer.from(JSON.stringify(dashboardConfig, null, 2), "utf-8"),
+      Buffer.from(configJson, "utf-8"),
     );
+
     zip.writeZip(filePath);
 
     console.log(
-      `[DashboardConfigController] Prepared publish package: ${filePath}`,
+      `[DashboardConfigController] Exported dashboard to: ${filePath}`,
     );
 
-    // 9. Attempt to publish to registry if authenticated
-    let registrySubmission = null;
-    try {
-      const { getAuthStatus } = registryAuthController$1;
-      const { publishToRegistry } = registryApiController$2;
-      const authStatus = getAuthStatus();
+    return {
+      success: true,
+      filePath,
+      config: dashboardConfig,
+    };
+  } catch (error) {
+    console.error(
+      "[DashboardConfigController] Error exporting dashboard:",
+      error,
+    );
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
+}
 
-      if (authStatus.authenticated) {
-        console.log("[DashboardConfigController] Publishing to registry...");
-        registrySubmission = await publishToRegistry(filePath, manifest);
-        if (registrySubmission.success) {
-          console.log(
-            `[DashboardConfigController] Published to registry: ${registrySubmission.registryUrl}`,
-          );
-        } else {
-          console.warn(
-            `[DashboardConfigController] Registry publish failed: ${registrySubmission.error}`,
-          );
-        }
-      } else {
-        registrySubmission = { success: false, authRequired: true };
-      }
-    } catch (err) {
-      console.warn(
-        `[DashboardConfigController] Registry publish error: ${err.message}`,
-      );
-      registrySubmission = { success: false, error: err.message };
+/**
+ * Select and preview a dashboard ZIP file without importing it.
+ * Opens the file picker, extracts and validates the .dashboard.json,
+ * and returns a preview of the config + the file path for later import.
+ *
+ * @param {BrowserWindow} win - The main window (for dialog)
+ * @returns {Promise<Object>} Result with success, filePath, and dashboardConfig preview
+ */
+async function selectDashboardFile$1(win) {
+  try {
+    const { canceled, filePaths } = await dialog.showOpenDialog(win, {
+      title: "Import Dashboard Configuration",
+      filters: [{ name: "ZIP Archive", extensions: ["zip"] }],
+      properties: ["openFile"],
+    });
+
+    if (canceled || !filePaths || !filePaths.length) {
+      return { success: false, canceled: true };
+    }
+
+    const zipPath = filePaths[0];
+
+    // Extract and validate
+    const zip = new AdmZip(zipPath);
+    const tempDir = path$1.join(app$1.getPath("temp"), "dash-import");
+    const { validateZipEntries } = widgetRegistryExports;
+    validateZipEntries(zip, tempDir);
+
+    const entries = zip.getEntries();
+    const configEntry = entries.find((e) =>
+      e.entryName.endsWith(".dashboard.json"),
+    );
+
+    if (!configEntry) {
+      return {
+        success: false,
+        error: "No .dashboard.json file found in ZIP archive",
+      };
+    }
+
+    const configJson = configEntry.getData().toString("utf-8");
+    let dashboardConfig;
+    try {
+      dashboardConfig = JSON.parse(configJson);
+    } catch (parseError) {
+      return {
+        success: false,
+        error: `Invalid JSON: ${parseError.message}`,
+      };
+    }
+
+    const validation = validateDashboardConfig(dashboardConfig);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: `Invalid config: ${validation.errors.join(", ")}`,
+      };
     }
 
+    dashboardConfig = applyDefaults(dashboardConfig);
+
     return {
       success: true,
-      filePath,
-      manifest,
-      config: dashboardConfig,
-      warnings:
-        missingFromRegistry.length > 0 ? missingFromRegistry : undefined,
-      registryCheckFailed: registryCheckFailed || undefined,
-      registrySubmission,
+      filePath: zipPath,
+      dashboardConfig: {
+        name: dashboardConfig.name,
+        description: dashboardConfig.description,
+        author: dashboardConfig.author,
+        workspace: dashboardConfig.workspace,
+        widgets: dashboardConfig.widgets || [],
+        providers: dashboardConfig.providers || [],
+      },
     };
   } catch (error) {
     console.error(
-      "[DashboardConfigController] Error preparing dashboard for publish:",
+      "[DashboardConfigController] Error selecting dashboard file:",
       error,
     );
-    return {
-      success: false,
-      error: error.message,
-    };
+    return { success: false, error: error.message };
   }
 }
 
 /**
- * Get a full preview of a dashboard package from the registry.
- * Combines the structured preview data with a compatibility check.
+ * Import a dashboard from a ZIP file containing a .dashboard.json config.
  *
- * @param {string} packageName - Registry package name
- * @param {Object} widgetRegistry - WidgetRegistry instance
- * @returns {Promise<Object>} Preview data with compatibility report
+ * Steps:
+ * 1. Show native file picker for .zip selection (or use options.filePath)
+ * 2. Extract and validate .dashboard.json
+ * 3. Auto-install missing widgets from registry
+ * 4. Create workspace in workspaces.json
+ * 5. Apply event wiring to layout
+ * 6. Mark imported dashboard shareable: false
+ *
+ * @param {BrowserWindow} win - The main window (for dialog)
+ * @param {string} appId - Application identifier
+ * @param {Object} widgetRegistry - WidgetRegistry instance (needs getWidgets(), downloadWidget())
+ * @param {Object} options - Import options
+ * @param {string} options.filePath - Skip file picker, use this path directly
+ * @param {string} options.name - Override workspace name
+ * @param {number} options.menuId - Override workspace menuId (folder)
+ * @param {string} options.themeKey - Override workspace themeKey
+ * @returns {Promise<Object>} Result with success, workspace, and import summary
  */
-async function getDashboardPreview$1(packageName, widgetRegistry = null) {
-  const {
-    buildDashboardPreview,
-    checkDashboardCompatibility,
-  } = dashboardConfigUtils$1;
-  const { getPackage, fetchRegistryIndex } = registryController$2;
-
-  const pkg = await getPackage(packageName);
-  if (!pkg) {
-    return {
-      success: false,
-      error: `Dashboard package not found: ${packageName}`,
-    };
-  }
+async function importDashboardConfig$1(
+  win,
+  appId,
+  widgetRegistry = null,
+  options = {},
+) {
+  try {
+    let zipPath;
 
-  const preview = buildDashboardPreview(pkg);
+    if (options.filePath) {
+      // Use the provided file path (from selectDashboardFile)
+      zipPath = options.filePath;
+    } else {
+      // Show file picker
+      const { canceled, filePaths } = await dialog.showOpenDialog(win, {
+        title: "Import Dashboard Configuration",
+        filters: [{ name: "ZIP Archive", extensions: ["zip"] }],
+        properties: ["openFile"],
+      });
 
-  // Get compatibility report
-  const installedWidgets = widgetRegistry ? widgetRegistry.getWidgets() : [];
-  let registryPackages = [];
-  try {
-    const index = await fetchRegistryIndex();
-    registryPackages = index.packages || [];
-  } catch (err) {
-    // Non-fatal — preview still works without compatibility
-  }
+      if (canceled || !filePaths || !filePaths.length) {
+        return { success: false, canceled: true };
+      }
 
-  const compatibility = checkDashboardCompatibility(
-    pkg.widgets || [],
-    installedWidgets,
-    registryPackages,
-  );
+      zipPath = filePaths[0];
+    }
 
-  return {
-    success: true,
-    preview,
-    compatibility,
-  };
-}
+    // 2. Extract and validate .dashboard.json from ZIP
+    const zip = new AdmZip(zipPath);
 
-/**
- * Check installed dashboards for available updates.
- * Reads workspaces, finds those installed from the registry,
- * and compares versions against the current registry index.
- *
- * @param {string} appId - Application identifier
- * @returns {Promise<Object>} Result with updates array
- */
-async function checkDashboardUpdatesForApp$1(appId) {
-  const { checkDashboardUpdates } = dashboardConfigUtils$1;
-  const { fetchRegistryIndex } = registryController$2;
+    // Validate ZIP entries for path traversal
+    const tempDir = path$1.join(app$1.getPath("temp"), "dash-import");
+    const { validateZipEntries } = widgetRegistryExports;
+    validateZipEntries(zip, tempDir);
 
-  try {
-    const filename = path$2.join(
-      app$2.getPath("userData"),
-      appName$1,
-      appId,
-      configFilename,
+    // Find the .dashboard.json file
+    const entries = zip.getEntries();
+    const configEntry = entries.find((e) =>
+      e.entryName.endsWith(".dashboard.json"),
     );
-    const workspaces = getFileContents$1(filename) || [];
 
-    const index = await fetchRegistryIndex();
-    const registryPackages = index.packages || [];
+    if (!configEntry) {
+      return {
+        success: false,
+        error: "No .dashboard.json file found in ZIP archive",
+      };
+    }
 
-    const updates = checkDashboardUpdates(workspaces, registryPackages);
+    const configJson = configEntry.getData().toString("utf-8");
+    let dashboardConfig;
+    try {
+      dashboardConfig = JSON.parse(configJson);
+    } catch (parseError) {
+      return {
+        success: false,
+        error: `Invalid JSON in ${configEntry.entryName}: ${parseError.message}`,
+      };
+    }
 
-    return {
-      success: true,
-      updates,
-      totalInstalled: workspaces.filter(
-        (w) => w._dashboardConfig?.registryPackage,
-      ).length,
-    };
+    // Validate against schema
+    const validation = validateDashboardConfig(dashboardConfig);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: `Invalid dashboard config: ${validation.errors.join(", ")}`,
+      };
+    }
+
+    // Apply defaults to fill in optional fields
+    dashboardConfig = applyDefaults(dashboardConfig);
+
+    // Delegate to shared import pipeline with overrides
+    return await processDashboardConfig(
+      win,
+      appId,
+      dashboardConfig,
+      widgetRegistry,
+      {
+        name: options.name,
+        menuId: options.menuId,
+        themeKey: options.themeKey,
+      },
+    );
   } catch (error) {
     console.error(
-      "[DashboardConfigController] Error checking dashboard updates:",
+      "[DashboardConfigController] Error importing dashboard:",
       error,
     );
     return {
       success: false,
       error: error.message,
-      updates: [],
     };
   }
 }
 
 /**
- * Get a provider setup manifest for a dashboard's requirements.
- * Compares required providers against the user's configured providers.
- *
+ * Shared import pipeline: install widgets, create workspace, wire events.
+ * Used by both importDashboardConfig (ZIP) and installDashboardFromRegistry.
+ *
+ * @param {BrowserWindow} win - The main window
  * @param {string} appId - Application identifier
- * @param {Array} requiredProviders - Provider requirements from dashboard config
- * @returns {Object} Setup manifest with per-provider status
+ * @param {Object} dashboardConfig - Validated dashboard config object
+ * @param {Object} widgetRegistry - WidgetRegistry instance
+ * @param {Object} options - Additional options
+ * @param {string} options.source - Source label ("zip" or "registry")
+ * @returns {Promise<Object>} Result with success, workspace, and summary
  */
-function getProviderSetupManifest$1(appId, requiredProviders = []) {
-  const {
-    buildProviderSetupManifest,
-  } = dashboardConfigUtils$1;
-  const { listProviders } = requireProviderController();
+async function processDashboardConfig(
+  win,
+  appId,
+  dashboardConfig,
+  widgetRegistry = null,
+  options = {},
+) {
+  const source = options.source || "zip";
 
-  let configuredProviders = [];
-  try {
-    configuredProviders = listProviders(null, appId) || [];
-  } catch (err) {
-    console.warn(
-      "[DashboardConfigController] Could not list providers:",
-      err.message,
-    );
-  }
+  // 1. Auto-install missing widgets from registry
+  const installSummary = {
+    installed: [],
+    alreadyInstalled: [],
+    failed: [],
+  };
 
-  return buildProviderSetupManifest(requiredProviders, configuredProviders);
-}
+  if (
+    widgetRegistry &&
+    dashboardConfig.widgets &&
+    dashboardConfig.widgets.length
+  ) {
+    const installedWidgets = widgetRegistry.getWidgets();
+    const installedPackages = new Set(installedWidgets.map((w) => w.name));
 
-/**
- * Get a publish preview for a dashboard workspace.
- * Returns widget/layout info without creating a ZIP or uploading.
- *
- * @param {string} appId - Application identifier
- * @param {number|string} workspaceId - Workspace to preview
- * @param {Object} widgetRegistry - WidgetRegistry instance (optional)
- * @returns {Object} Preview with dashboardName, widgetCount, widgets, componentNames
- */
-function getDashboardPublishPreview$1(appId, workspaceId, widgetRegistry = null) {
-  try {
-    const filename = path$2.join(
-      app$2.getPath("userData"),
-      appName$1,
-      appId,
-      configFilename,
-    );
-    const workspacesArray = getFileContents$1(filename);
-    const workspace = workspacesArray.find(
-      (w) => w.id === workspaceId || w.id === Number(workspaceId),
-    );
+    for (const widgetDep of dashboardConfig.widgets) {
+      const packageName = widgetDep.package;
 
-    if (!workspace) {
-      return { success: false, error: `Workspace not found: ${workspaceId}` };
+      if (installedPackages.has(packageName)) {
+        installSummary.alreadyInstalled.push(packageName);
+        continue;
+      }
+
+      // Try to find the widget in the registry and install it
+      try {
+        const registryPkg = await getPackage(packageName);
+        if (registryPkg && registryPkg.downloadUrl) {
+          await widgetRegistry.downloadWidget(
+            packageName,
+            registryPkg.downloadUrl,
+            registryPkg.dashConfigUrl || null,
+          );
+          installSummary.installed.push(packageName);
+          installedPackages.add(packageName);
+        } else {
+          installSummary.failed.push({
+            package: packageName,
+            reason: "Not found in registry",
+          });
+        }
+      } catch (installError) {
+        installSummary.failed.push({
+          package: packageName,
+          reason: installError.message,
+        });
+      }
     }
+  }
 
-    const layout = workspace.layout || [];
-    const componentNames = collectComponentNames(layout);
-    const widgets = buildWidgetDependencies(componentNames, widgetRegistry);
+  // 2. Install bundled theme if present
+  let themeInstalled = null;
+  if (dashboardConfig.theme) {
+    const bundledTheme = dashboardConfig.theme;
+    try {
+      const themeResult = themeController$1.listThemesForApplication(win, appId);
+      const existingThemes = themeResult.themes || {};
+      const themeKey = bundledTheme.key;
+
+      if (bundledTheme.data && themeKey && !existingThemes[themeKey]) {
+        // Embed registry origin metadata if present
+        const themeData = { ...bundledTheme.data };
+        if (bundledTheme.registryPackage) {
+          themeData._registryMeta = {
+            source: "dashboard-import",
+            packageName: bundledTheme.registryPackage,
+            installedAt: new Date().toISOString(),
+          };
+        }
+        themeController$1.saveThemeForApplication(
+          win,
+          appId,
+          themeKey,
+          themeData,
+        );
+        themeInstalled = themeKey;
+        console.log(
+          `[DashboardConfigController] Installed bundled theme: ${themeKey}`,
+        );
+      } else if (
+        !bundledTheme.data &&
+        bundledTheme.registryPackage &&
+        themeKey &&
+        !existingThemes[themeKey]
+      ) {
+        // Fallback: try to install from registry by package name
+        try {
+          const {
+            installThemeFromRegistry,
+          } = themeRegistryController$1;
+          await installThemeFromRegistry(
+            win,
+            appId,
+            bundledTheme.registryPackage,
+          );
+          themeInstalled = themeKey;
+          console.log(
+            `[DashboardConfigController] Installed theme from registry: ${bundledTheme.registryPackage}`,
+          );
+        } catch (registryErr) {
+          console.warn(
+            `[DashboardConfigController] Could not install theme from registry: ${registryErr.message}`,
+          );
+        }
+      }
+    } catch (themeErr) {
+      console.warn(
+        `[DashboardConfigController] Could not install bundled theme: ${themeErr.message}`,
+      );
+    }
+  }
+
+  // 3. Build workspace from config
+  const workspace = { ...dashboardConfig.workspace };
 
+  if (!workspace || !workspace.layout) {
     return {
-      success: true,
-      dashboardName: workspace.name || workspace.label || "Dashboard",
-      widgetCount: componentNames.length,
-      widgets: widgets.map((w) => ({ name: w.name, package: w.package })),
-      componentNames: [...componentNames],
+      success: false,
+      error: "Dashboard config has no workspace data",
     };
-  } catch (error) {
-    console.error(
-      "[DashboardConfigController] Error getting publish preview:",
-      error,
-    );
-    return { success: false, error: error.message };
   }
-}
 
-var dashboardConfigController$1 = {
-  exportDashboardConfig: exportDashboardConfig$1,
-  selectDashboardFile: selectDashboardFile$1,
-  importDashboardConfig: importDashboardConfig$1,
-  installDashboardFromRegistry: installDashboardFromRegistry$1,
-  checkCompatibility: checkCompatibility$1,
-  prepareDashboardForPublish: prepareDashboardForPublish$1,
-  getDashboardPreview: getDashboardPreview$1,
-  checkDashboardUpdatesForApp: checkDashboardUpdatesForApp$1,
-  getProviderSetupManifest: getProviderSetupManifest$1,
-  getDashboardPublishPreview: getDashboardPublishPreview$1,
-};
+  // Generate a unique ID for the imported workspace
+  workspace.id = Date.now();
 
-/**
- * notificationController.js
- *
- * Main process controller for OS-level notifications.
- * Manages preferences (electron-store), rate limiting, deduplication,
- * and dispatching native Notification instances.
- */
+  // Apply name/menuId/themeKey overrides if provided
+  if (options.name) workspace.name = options.name;
+  if (options.menuId !== undefined) workspace.menuId = options.menuId;
+  if (options.themeKey !== undefined) workspace.themeKey = options.themeKey;
 
-const { Notification } = require$$0$1;
-const Store = require$$1;
+  // Set themeKey from bundled theme if it was installed and no override given
+  if (themeInstalled && options.themeKey === undefined) {
+    workspace.themeKey = themeInstalled;
+  }
 
-const store$1 = new Store({ name: "dash-notifications" });
+  // 4. Apply event wiring to layout
+  const eventWiringSummary = [];
+  if (
+    dashboardConfig.eventWiring &&
+    dashboardConfig.eventWiring.length &&
+    workspace.layout
+  ) {
+    applyEventWiringToLayout(workspace.layout, dashboardConfig.eventWiring);
+    for (const wire of dashboardConfig.eventWiring) {
+      eventWiringSummary.push(
+        `${wire.source?.widget}.${wire.source?.event} → ${wire.target?.widget}.${wire.target?.handler}`,
+      );
+    }
+  }
 
-// --- Rate limiting ---
-// Sliding window: max 10 notifications per 60s per widget
-const RATE_LIMIT_WINDOW_MS = 60_000;
-const RATE_LIMIT_MAX = 10;
-const rateBuckets = new Map(); // widgetId -> [timestamp, ...]
+  // 5. Mark as not shareable (imported dashboards cannot be re-published)
+  workspace._dashboardConfig = {
+    shareable: false,
+    source,
+    importedFrom: dashboardConfig.name,
+    importedAt: new Date().toISOString(),
+    originalAuthor: dashboardConfig.author,
+    schemaVersion: dashboardConfig.schemaVersion,
+    registryPackage: options.registryPackage || null,
+    installedVersion: options.installedVersion || null,
+  };
 
-// --- Deduplication ---
-// Same (widgetName, type, title, body) within 5s is dropped
-const DEDUP_WINDOW_MS = 5_000;
-const recentNotifications = new Map(); // dedup key -> timestamp
+  // Save workspace to workspaces.json
+  const workspaceController = workspaceController_1;
+  const saveResult = workspaceController.saveWorkspaceForApplication(
+    win,
+    appId,
+    workspace,
+  );
 
-function getDedupKey(payload) {
-  return `${payload.widgetName}:${payload.type}:${payload.title}:${payload.body}`;
-}
+  if (saveResult.error) {
+    return {
+      success: false,
+      error: `Failed to save workspace: ${saveResult.message}`,
+    };
+  }
 
-function isRateLimited(widgetId) {
-  const now = Date.now();
-  let timestamps = rateBuckets.get(widgetId) || [];
-  // Prune old entries
-  timestamps = timestamps.filter((t) => now - t < RATE_LIMIT_WINDOW_MS);
-  rateBuckets.set(widgetId, timestamps);
-  return timestamps.length >= RATE_LIMIT_MAX;
-}
+  // Build provider requirements summary
+  const providerSummary = (dashboardConfig.providers || []).map((p) => ({
+    type: p.type,
+    providerClass: p.providerClass,
+    required: p.required,
+    usedBy: p.usedBy,
+  }));
 
-function recordNotification(widgetId) {
-  const timestamps = rateBuckets.get(widgetId) || [];
-  timestamps.push(Date.now());
-  rateBuckets.set(widgetId, timestamps);
+  console.log(
+    `[DashboardConfigController] Imported dashboard "${dashboardConfig.name}" (${source}) as workspace ${workspace.id}`,
+  );
+
+  return {
+    success: true,
+    workspace,
+    summary: {
+      name: dashboardConfig.name,
+      description: dashboardConfig.description || "",
+      author: dashboardConfig.author,
+      widgets: installSummary,
+      eventsWired: eventWiringSummary,
+      providersRequired: providerSummary,
+      themeInstalled: themeInstalled || null,
+    },
+  };
 }
 
-function isDuplicate(payload) {
-  const key = getDedupKey(payload);
-  const now = Date.now();
-  const lastSent = recentNotifications.get(key);
-  if (lastSent && now - lastSent < DEDUP_WINDOW_MS) {
-    return true;
-  }
-  recentNotifications.set(key, now);
-  return false;
-}
-
-// Clean up stale dedup entries periodically
-setInterval(() => {
-  const now = Date.now();
-  for (const [key, ts] of recentNotifications) {
-    if (now - ts > DEDUP_WINDOW_MS) {
-      recentNotifications.delete(key);
+/**
+ * Install a dashboard from the registry by package name.
+ *
+ * Fetches the dashboard ZIP from the registry, extracts the .dashboard.json,
+ * validates it, and delegates to the shared import pipeline.
+ *
+ * @param {BrowserWindow} win - The main window
+ * @param {string} appId - Application identifier
+ * @param {string} packageName - Registry package name for the dashboard
+ * @param {Object} widgetRegistry - WidgetRegistry instance
+ * @returns {Promise<Object>} Result with success, workspace, and summary
+ */
+async function installDashboardFromRegistry$1(
+  win,
+  appId,
+  packageName,
+  widgetRegistry = null,
+) {
+  try {
+    // 1. Look up the dashboard package in the registry
+    const registryPkg = await getPackage(packageName);
+    if (!registryPkg) {
+      return {
+        success: false,
+        error: `Dashboard package not found in registry: ${packageName}`,
+      };
     }
-  }
-}, 30_000);
-
-const notificationController$2 = {
-  /**
-   * Send a notification if it passes all checks.
-   *
-   * @param {BrowserWindow} win - the main window (for click routing)
-   * @param {Object} payload
-   * @param {string} payload.widgetName - component name of the widget
-   * @param {string} payload.widgetId - widget instance UUID
-   * @param {string} payload.workspaceId - workspace containing the widget
-   * @param {string} payload.type - notification type key (must match .dash.js config)
-   * @param {string} payload.title - notification title
-   * @param {string} payload.body - notification body
-   * @param {Object} [payload.data] - arbitrary data returned on click
-   * @param {boolean} [payload.silent] - suppress sound
-   * @param {string} [payload.urgency] - "low" | "normal" | "critical"
-   * @returns {{ success: boolean, reason?: string }}
-   */
-  send: (win, payload) => {
-    try {
-      const {
-        widgetName,
-        widgetId,
-        workspaceId,
-        type,
-        title,
-        body,
-        data,
-        silent,
-        urgency,
-      } = payload;
 
-      // 1. Check globalEnabled
-      const globalEnabled = store$1.get("globalEnabled", true);
-      if (!globalEnabled) {
-        return { success: false, reason: "notifications_disabled" };
-      }
-
-      // 2. Check doNotDisturb
-      const dnd = store$1.get("doNotDisturb", false);
-      if (dnd) {
-        return { success: false, reason: "do_not_disturb" };
-      }
+    if (!registryPkg.downloadUrl) {
+      return {
+        success: false,
+        error: `Dashboard package has no download URL: ${packageName}`,
+      };
+    }
 
-      // 3. Check per-widget per-type preference
-      const instances = store$1.get("instances", {});
-      const widgetPrefs = instances[widgetId];
-      if (widgetPrefs && widgetPrefs[type] === false) {
-        return { success: false, reason: "type_disabled" };
-      }
+    // 2. Resolve the download URL and fetch the ZIP
+    const version = registryPkg.version || "1.0.0";
+    let downloadUrl = registryPkg.downloadUrl;
+    downloadUrl = downloadUrl.replace("{version}", version);
+    downloadUrl = downloadUrl.replace("{name}", packageName);
 
-      // 4. Rate limit
-      if (isRateLimited(widgetId)) {
-        return { success: false, reason: "rate_limited" };
-      }
+    // Enforce HTTPS
+    const parsedUrl = new URL(downloadUrl);
+    if (parsedUrl.protocol !== "https:") {
+      return {
+        success: false,
+        error: `Dashboard downloads must use HTTPS. Refusing: ${downloadUrl}`,
+      };
+    }
 
-      // 5. Deduplication
-      if (isDuplicate(payload)) {
-        return { success: false, reason: "duplicate" };
-      }
+    console.log(
+      `[DashboardConfigController] Fetching dashboard from: ${downloadUrl}`,
+    );
 
-      // 6. All checks passed — send native notification
-      const notification = new Notification({
-        title,
-        body,
-        silent: silent || false,
-        urgency: urgency || "normal",
-      });
+    const response = await fetch(downloadUrl);
+    if (!response.ok) {
+      return {
+        success: false,
+        error: `Failed to download dashboard: ${response.status} ${response.statusText}`,
+      };
+    }
 
-      notification.on("click", () => {
-        if (win && !win.isDestroyed()) {
-          win.show();
-          win.focus();
-          win.webContents.send("notification:clicked", {
-            widgetName,
-            widgetId,
-            workspaceId,
-            type,
-            data: data || null,
-          });
-        }
-      });
+    const buffer = await response.arrayBuffer();
+    const zip = new AdmZip(Buffer.from(buffer));
 
-      notification.show();
-      recordNotification(widgetId);
+    // 3. Validate ZIP entries
+    const tempDir = path$1.join(app$1.getPath("temp"), "dash-registry-import");
+    const { validateZipEntries } = widgetRegistryExports;
+    validateZipEntries(zip, tempDir);
 
-      console.log(
-        `[notificationController] Sent: ${widgetName}.${type} — "${title}"`,
-      );
+    // 4. Find and parse .dashboard.json
+    const entries = zip.getEntries();
+    const configEntry = entries.find((e) =>
+      e.entryName.endsWith(".dashboard.json"),
+    );
 
-      return { success: true };
-    } catch (error) {
-      console.error(
-        "[notificationController] Error sending notification:",
-        error,
-      );
-      return { error: true, message: error.message };
+    if (!configEntry) {
+      return {
+        success: false,
+        error: "No .dashboard.json file found in downloaded archive",
+      };
     }
-  },
 
-  /**
-   * Get all notification preferences.
-   *
-   * @returns {{ globalEnabled: boolean, doNotDisturb: boolean, instances: Object }}
-   */
-  getPreferences: () => {
+    const configJson = configEntry.getData().toString("utf-8");
+    let dashboardConfig;
     try {
+      dashboardConfig = JSON.parse(configJson);
+    } catch (parseError) {
       return {
-        globalEnabled: store$1.get("globalEnabled", true),
-        doNotDisturb: store$1.get("doNotDisturb", false),
-        instances: store$1.get("instances", {}),
+        success: false,
+        error: `Invalid JSON in dashboard config: ${parseError.message}`,
       };
-    } catch (error) {
-      console.error(
-        "[notificationController] Error getting preferences:",
-        error,
-      );
+    }
+
+    // 5. Validate against schema
+    const validation = validateDashboardConfig(dashboardConfig);
+    if (!validation.valid) {
       return {
-        error: true,
-        message: error.message,
-        globalEnabled: true,
-        doNotDisturb: false,
-        instances: {},
+        success: false,
+        error: `Invalid dashboard config: ${validation.errors.join(", ")}`,
       };
     }
-  },
 
-  /**
-   * Set notification preferences for a specific widget instance.
-   *
-   * @param {string} widgetId - widget instance UUID
-   * @param {Object} prefs - { [notificationType]: boolean }
-   * @returns {{ success: boolean }}
-   */
-  setPreferences: (widgetId, prefs) => {
-    try {
-      const instances = store$1.get("instances", {});
-      instances[widgetId] = { ...(instances[widgetId] || {}), ...prefs };
-      store$1.set("instances", instances);
-      console.log(
-        `[notificationController] Preferences updated for widget ${widgetId}`,
-      );
-      return { success: true };
-    } catch (error) {
-      console.error(
-        "[notificationController] Error setting preferences:",
-        error,
-      );
-      return { error: true, message: error.message };
-    }
-  },
+    dashboardConfig = applyDefaults(dashboardConfig);
 
-  /**
-   * Set global notification settings.
-   *
-   * @param {Object} settings
-   * @param {boolean} [settings.globalEnabled]
-   * @param {boolean} [settings.doNotDisturb]
-   * @returns {{ success: boolean }}
-   */
-  setGlobal: (settings) => {
-    try {
-      if (typeof settings.globalEnabled === "boolean") {
-        store$1.set("globalEnabled", settings.globalEnabled);
-      }
-      if (typeof settings.doNotDisturb === "boolean") {
-        store$1.set("doNotDisturb", settings.doNotDisturb);
-      }
-      console.log(
-        "[notificationController] Global settings updated:",
-        settings,
-      );
-      return { success: true };
-    } catch (error) {
-      console.error("[notificationController] Error setting global:", error);
-      return { error: true, message: error.message };
-    }
-  },
-};
-
-var notificationController_1 = notificationController$2;
-
-/**
- * themeRegistryController.js
- *
- * Handles publishing themes to and installing themes from the Dash registry.
- * Mirrors dashboardConfigController patterns for ZIP creation, manifest generation,
- * and registry interaction.
- */
-const path$1 = require$$1$1;
-const { app: app$1, dialog } = require$$0$1;
-const AdmZip = require$$3$3;
-
-const themeController$1 = themeController_1;
-const registryController$1 = registryController$2;
-const registryApiController$1 = registryApiController$2;
-const { getAuthStatus } = registryAuthController$1;
-
-/**
- * Sanitize a name for use as a filename (lowercase, hyphens only).
- */
-function sanitizeName(name) {
-  return (name || "theme")
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-|-$/g, "");
+    // 6. Delegate to shared import pipeline
+    return await processDashboardConfig(
+      win,
+      appId,
+      dashboardConfig,
+      widgetRegistry,
+      {
+        source: "registry",
+        registryPackage: packageName,
+        installedVersion: registryPkg.version || null,
+      },
+    );
+  } catch (error) {
+    console.error(
+      "[DashboardConfigController] Error installing dashboard from registry:",
+      error,
+    );
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
 }
 
 /**
- * Generate a registry manifest for a theme package.
+ * Check compatibility of a dashboard's widget dependencies against
+ * installed widgets and registry availability.
  *
- * @param {Object} themeData - The raw theme object
- * @param {string} themeKey - The theme key/name
- * @param {Object} options - Publish options { authorName, description, tags, scope }
- * @returns {Object} Registry manifest
- */
-function generateThemeRegistryManifest(themeData, themeKey, options = {}) {
-  const sanitizedName = sanitizeName(themeKey);
-  const colors = extractColors(themeData);
-
-  return {
-    scope: options.scope || "",
-    name: sanitizedName,
-    displayName: themeKey,
-    author: options.authorName || "",
-    description: options.description || "",
-    version: "1.0.0",
-    type: "theme",
-    category: "general",
-    tags: options.tags || [],
-    icon: "palette",
-    colors,
-    appOrigin: options.appOrigin || "",
-    publishedAt: new Date().toISOString(),
-  };
-}
-
-/**
- * Extract primary/secondary/tertiary/neutral colors from a theme object.
- * Theme objects store colors in various structures; this normalizes them.
+ * @param {Array} dashboardWidgets - Widget deps from dashboard config
+ * @param {Object} widgetRegistry - WidgetRegistry instance (needs getWidgets())
+ * @returns {Promise<Object>} Compatibility report
  */
-function extractColors(themeData) {
-  const colors = {
-    primary: "",
-    secondary: "",
-    tertiary: "",
-    neutral: "",
-  };
-
-  if (!themeData) return colors;
+async function checkCompatibility$1(dashboardWidgets, widgetRegistry = null) {
+  const {
+    checkDashboardCompatibility,
+  } = dashboardConfigUtils$1;
+  const { fetchRegistryIndex } = registryController$2;
 
-  // Direct color fields
-  if (themeData.primary) colors.primary = themeData.primary;
-  if (themeData.secondary) colors.secondary = themeData.secondary;
-  if (themeData.tertiary) colors.tertiary = themeData.tertiary;
-  if (themeData.neutral) colors.neutral = themeData.neutral;
+  const installedWidgets = widgetRegistry ? widgetRegistry.getWidgets() : [];
 
-  // Nested under "colors" key
-  if (themeData.colors) {
-    if (themeData.colors.primary) colors.primary = themeData.colors.primary;
-    if (themeData.colors.secondary)
-      colors.secondary = themeData.colors.secondary;
-    if (themeData.colors.tertiary) colors.tertiary = themeData.colors.tertiary;
-    if (themeData.colors.neutral) colors.neutral = themeData.colors.neutral;
+  let registryPackages = [];
+  try {
+    const index = await fetchRegistryIndex();
+    registryPackages = index.packages || [];
+  } catch (err) {
+    console.warn(
+      "[DashboardConfigController] Could not fetch registry index for compatibility check:",
+      err.message,
+    );
   }
 
-  return colors;
+  return checkDashboardCompatibility(
+    dashboardWidgets,
+    installedWidgets,
+    registryPackages,
+  );
 }
 
 /**
- * Prepare a theme for publishing to the registry.
+ * Prepare a dashboard for publishing to the registry.
  *
- * Reads the theme from themes.json, generates a manifest, creates a ZIP,
- * and publishes via the registry API.
+ * Validates that the workspace is shareable, builds the dashboard config,
+ * checks that all widgets exist in the registry, generates a registry
+ * manifest, and creates a ZIP containing both the manifest and
+ * .dashboard.json config.
  *
- * @param {BrowserWindow} win - The sender window
+ * @param {BrowserWindow} win - The main window (for save dialog)
  * @param {string} appId - Application identifier
- * @param {string} themeKey - Key of the theme to publish
- * @param {Object} options - { authorName, description, tags }
- * @returns {Object} Result with success, manifest, registryResult
+ * @param {number|string} workspaceId - ID of the workspace to publish
+ * @param {Object} options - Publishing options
+ * @param {string} options.authorName - Author name
+ * @param {string} options.authorId - Author ID
+ * @param {string} options.description - Dashboard description
+ * @param {string[]} options.tags - Tags
+ * @param {string} options.icon - Icon name
+ * @param {string} options.githubUser - GitHub user/org for registry scope
+ * @param {string} options.category - Registry category
+ * @param {Object} widgetRegistry - WidgetRegistry instance
+ * @returns {Promise<Object>} Result with success, manifest, and filePath
  */
-async function prepareThemeForPublish$1(win, appId, themeKey, options = {}) {
+async function prepareDashboardForPublish$1(
+  win,
+  appId,
+  workspaceId,
+  options = {},
+  widgetRegistry = null,
+) {
   try {
-    // Read the theme data
-    const themesResult = themeController$1.listThemesForApplication(win, appId);
-    if (themesResult.error) {
-      return { success: false, error: "Failed to read themes: " + themesResult.message };
-    }
+    const {
+      generateRegistryManifest,
+    } = dashboardConfigUtils$1;
 
-    const themeData = themesResult.themes[themeKey];
-    if (!themeData) {
-      return { success: false, error: `Theme "${themeKey}" not found` };
-    }
+    // 1. Read workspace
+    const filename = path$1.join(
+      app$1.getPath("userData"),
+      appName$1,
+      appId,
+      configFilename,
+    );
+    const workspacesArray = getFileContents$1(filename);
+    const workspace = workspacesArray.find(
+      (w) => w.id === workspaceId || w.id === Number(workspaceId),
+    );
 
-    // Get auth status for scope
-    const auth = getAuthStatus();
-    const scope = auth.profile?.username || options.scope || "";
-    if (!scope) {
+    if (!workspace) {
       return {
         success: false,
-        error: "Not authenticated with registry",
-        authRequired: true,
+        error: `Workspace not found: ${workspaceId}`,
       };
     }
 
-    // Generate manifest
-    const manifest = generateThemeRegistryManifest(themeData, themeKey, {
-      ...options,
-      scope,
-      appOrigin: appId,
-    });
-
-    // Validate colors
-    if (!manifest.colors.primary || !manifest.colors.secondary || !manifest.colors.tertiary) {
+    // 2. Check shareable flag — imported dashboards cannot be published
+    if (
+      workspace._dashboardConfig &&
+      workspace._dashboardConfig.shareable === false
+    ) {
       return {
         success: false,
-        error: "Theme must have primary, secondary, and tertiary colors defined",
+        error:
+          "This dashboard was imported and cannot be published. Only dashboards you created can be shared.",
       };
     }
 
-    // Show save dialog
-    const sanitizedName = sanitizeName(themeKey);
-    const defaultFilename = `theme-${sanitizedName}-v${manifest.version}.zip`;
+    const layout = workspace.layout || [];
 
-    const saveResult = await dialog.showSaveDialog(win, {
-      title: "Save Theme Package",
-      defaultPath: defaultFilename,
-      filters: [{ name: "ZIP Files", extensions: ["zip"] }],
+    // 3. Build the dashboard config (reuse export logic)
+    const componentNames = collectComponentNames(layout);
+    const eventWiring = extractEventWiring(layout);
+    const widgets = buildWidgetDependencies(componentNames, widgetRegistry);
+    const providers = buildProviderRequirements(componentNames, widgetRegistry);
+
+    const dashboardConfig = applyDefaults({
+      schemaVersion: CURRENT_SCHEMA_VERSION,
+      name: workspace.name || workspace.label || "Dashboard",
+      description: options.description || "",
+      ...(options.authorName
+        ? { author: { name: options.authorName, id: options.authorId || "" } }
+        : {}),
+      shareable: true,
+      tags: options.tags || [],
+      icon: options.icon || "grip",
+      workspace: {
+        id: workspace.id,
+        name: workspace.name,
+        type: workspace.type || "workspace",
+        label: workspace.label || workspace.name,
+        version: workspace.version || 1,
+        layout,
+        menuId: workspace.menuId || 1,
+      },
+      widgets,
+      providers,
+      eventWiring,
     });
 
-    if (saveResult.canceled || !saveResult.filePath) {
-      return { success: false, error: "Save canceled" };
+    // 4. Bundle theme if workspace has a themeKey
+    if (workspace.themeKey) {
+      try {
+        const themeResult = themeController$1.listThemesForApplication(
+          win,
+          appId,
+        );
+        const themeData = themeResult.themes?.[workspace.themeKey];
+        if (themeData) {
+          dashboardConfig.theme = {
+            key: workspace.themeKey,
+            data: themeData,
+          };
+          if (themeData._registryMeta?.packageName) {
+            dashboardConfig.theme.registryPackage =
+              themeData._registryMeta.packageName;
+          }
+        }
+      } catch (themeErr) {
+        console.warn(
+          "[DashboardConfigController] Could not bundle theme for publish:",
+          themeErr.message,
+        );
+      }
     }
 
-    const filePath = saveResult.filePath;
-
-    // Create ZIP with manifest.json + {name}.theme.json
-    const zip = new AdmZip();
-    zip.addFile(
-      "manifest.json",
+    // 5. Validate the config
+    const validation = validateDashboardConfig(dashboardConfig);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: `Generated config is invalid: ${validation.errors.join(", ")}`,
+      };
+    }
+
+    // 6. Check which widgets exist in the registry (soft warning, not blocking)
+    const { fetchRegistryIndex } = registryController$2;
+    let registryPackages = [];
+    let registryCheckFailed = false;
+    try {
+      const index = await fetchRegistryIndex();
+      registryPackages = index.packages || [];
+    } catch (err) {
+      console.warn(
+        `[DashboardConfigController] Unable to verify registry: ${err.message}`,
+      );
+      registryCheckFailed = true;
+    }
+
+    let missingFromRegistry = [];
+    if (!registryCheckFailed) {
+      const registryNames = new Set(registryPackages.map((p) => p.name));
+      const missingWidgets = widgets.filter(
+        (w) => w.required !== false && !registryNames.has(w.package),
+      );
+      const grouped = {};
+      for (const w of missingWidgets) {
+        if (!grouped[w.package]) grouped[w.package] = [];
+        const widgetName = w.id.includes(".") ? w.id.split(".")[1] : w.id;
+        if (!grouped[w.package].includes(widgetName)) {
+          grouped[w.package].push(widgetName);
+        }
+      }
+      missingFromRegistry = Object.entries(grouped).map(
+        ([pkg, widgetNames]) => ({ package: pkg, widgets: widgetNames }),
+      );
+    }
+
+    // 7. Generate registry manifest
+    const manifest = generateRegistryManifest(dashboardConfig, {
+      githubUser: options.githubUser || options.authorId || "",
+      category: options.category || "general",
+      repository: options.repository || "",
+    });
+
+    // 8. Show save dialog for the publish package
+    const sanitizedName = manifest.name;
+    const { canceled, filePath } = await dialog.showSaveDialog(win, {
+      title: "Save Dashboard Package for Registry",
+      defaultPath: path$1.join(
+        app$1.getPath("desktop"),
+        `dashboard-${sanitizedName}-v${manifest.version}.zip`,
+      ),
+      filters: [{ name: "ZIP Archive", extensions: ["zip"] }],
+    });
+
+    if (canceled || !filePath) {
+      return { success: false, canceled: true };
+    }
+
+    // 9. Create ZIP with manifest and dashboard config
+    const zip = new AdmZip();
+    zip.addFile(
+      "manifest.json",
       Buffer.from(JSON.stringify(manifest, null, 2), "utf-8"),
     );
     zip.addFile(
-      `${sanitizedName}.theme.json`,
-      Buffer.from(JSON.stringify(themeData, null, 2), "utf-8"),
+      `${sanitizedName}.dashboard.json`,
+      Buffer.from(JSON.stringify(dashboardConfig, null, 2), "utf-8"),
     );
     zip.writeZip(filePath);
 
-    console.log("[ThemeRegistryController] ZIP created at:", filePath);
+    console.log(
+      `[DashboardConfigController] Prepared publish package: ${filePath}`,
+    );
 
-    // Attempt to publish to registry
-    let registryResult = null;
-    if (auth.authenticated) {
-      registryResult = await registryApiController$1.publishToRegistry(
-        filePath,
-        manifest,
+    // 10. Attempt to publish to registry if authenticated
+    let registrySubmission = null;
+    try {
+      const { getAuthStatus } = registryAuthController$1;
+      const { publishToRegistry } = registryApiController$2;
+      const authStatus = getAuthStatus();
+
+      if (authStatus.authenticated) {
+        console.log("[DashboardConfigController] Publishing to registry...");
+        registrySubmission = await publishToRegistry(filePath, manifest);
+        if (registrySubmission.success) {
+          console.log(
+            `[DashboardConfigController] Published to registry: ${registrySubmission.registryUrl}`,
+          );
+        } else {
+          console.warn(
+            `[DashboardConfigController] Registry publish failed: ${registrySubmission.error}`,
+          );
+        }
+      } else {
+        registrySubmission = { success: false, authRequired: true };
+      }
+    } catch (err) {
+      console.warn(
+        `[DashboardConfigController] Registry publish error: ${err.message}`,
       );
-      console.log("[ThemeRegistryController] Registry publish result:", registryResult);
+      registrySubmission = { success: false, error: err.message };
     }
 
     return {
       success: true,
-      manifest,
       filePath,
-      registryResult,
+      manifest,
+      config: dashboardConfig,
+      warnings:
+        missingFromRegistry.length > 0 ? missingFromRegistry : undefined,
+      registryCheckFailed: registryCheckFailed || undefined,
+      registrySubmission,
+    };
+  } catch (error) {
+    console.error(
+      "[DashboardConfigController] Error preparing dashboard for publish:",
+      error,
+    );
+    return {
+      success: false,
+      error: error.message,
     };
-  } catch (err) {
-    console.error("[ThemeRegistryController] Error preparing theme for publish:", err);
-    return { success: false, error: err.message };
   }
 }
 
 /**
- * Install a theme from the registry.
- *
- * Looks up the theme package, downloads the ZIP, extracts the .theme.json,
- * and saves it via themeController.
+ * Get a full preview of a dashboard package from the registry.
+ * Combines the structured preview data with a compatibility check.
  *
- * @param {BrowserWindow} win - The sender window
- * @param {string} appId - Application identifier
- * @param {string} packageName - Registry package name (e.g., "username/ocean-depth")
- * @returns {Object} Result with success, themeKey, theme
+ * @param {string} packageName - Registry package name
+ * @param {Object} widgetRegistry - WidgetRegistry instance
+ * @returns {Promise<Object>} Preview data with compatibility report
  */
-async function installThemeFromRegistry$1(win, appId, packageName) {
-  try {
-    // Look up the package
-    const pkg = await registryController$1.getPackage(packageName);
-    if (!pkg) {
-      return { success: false, error: `Theme package "${packageName}" not found in registry` };
-    }
-
-    // Resolve download URL
-    let downloadUrl = pkg.downloadUrl;
-    if (!downloadUrl) {
-      return { success: false, error: "Package has no download URL" };
-    }
+async function getDashboardPreview$1(packageName, widgetRegistry = null) {
+  const {
+    buildDashboardPreview,
+    checkDashboardCompatibility,
+  } = dashboardConfigUtils$1;
+  const { getPackage, fetchRegistryIndex } = registryController$2;
 
-    // Resolve template variables
-    downloadUrl = downloadUrl
-      .replace("{version}", pkg.version || "1.0.0")
-      .replace("{name}", pkg.name || "");
+  const pkg = await getPackage(packageName);
+  if (!pkg) {
+    return {
+      success: false,
+      error: `Dashboard package not found: ${packageName}`,
+    };
+  }
 
-    // Enforce HTTPS
-    if (!downloadUrl.startsWith("https://")) {
-      return { success: false, error: "Download URL must use HTTPS" };
-    }
+  const preview = buildDashboardPreview(pkg);
 
-    console.log("[ThemeRegistryController] Downloading theme from:", downloadUrl);
+  // Get compatibility report
+  const installedWidgets = widgetRegistry ? widgetRegistry.getWidgets() : [];
+  let registryPackages = [];
+  try {
+    const index = await fetchRegistryIndex();
+    registryPackages = index.packages || [];
+  } catch (err) {
+    // Non-fatal — preview still works without compatibility
+  }
 
-    // Download the ZIP
-    const response = await fetch(downloadUrl);
-    if (!response.ok) {
-      return {
-        success: false,
-        error: `Failed to download theme: ${response.status} ${response.statusText}`,
-      };
-    }
+  const compatibility = checkDashboardCompatibility(
+    pkg.widgets || [],
+    installedWidgets,
+    registryPackages,
+  );
 
-    const arrayBuffer = await response.arrayBuffer();
-    const zipBuffer = Buffer.from(arrayBuffer);
+  return {
+    success: true,
+    preview,
+    compatibility,
+  };
+}
 
-    // Extract .theme.json from ZIP
-    const zip = new AdmZip(zipBuffer);
-    const entries = zip.getEntries();
+/**
+ * Check installed dashboards for available updates.
+ * Reads workspaces, finds those installed from the registry,
+ * and compares versions against the current registry index.
+ *
+ * @param {string} appId - Application identifier
+ * @returns {Promise<Object>} Result with updates array
+ */
+async function checkDashboardUpdatesForApp$1(appId) {
+  const { checkDashboardUpdates } = dashboardConfigUtils$1;
+  const { fetchRegistryIndex } = registryController$2;
 
-    const themeEntry = entries.find((entry) =>
-      entry.entryName.endsWith(".theme.json"),
+  try {
+    const filename = path$1.join(
+      app$1.getPath("userData"),
+      appName$1,
+      appId,
+      configFilename,
     );
+    const workspaces = getFileContents$1(filename) || [];
 
-    if (!themeEntry) {
-      return { success: false, error: "ZIP does not contain a .theme.json file" };
-    }
-
-    // Validate entry path (security: prevent path traversal)
-    if (themeEntry.entryName.includes("..") || path$1.isAbsolute(themeEntry.entryName)) {
-      return { success: false, error: "Invalid file path in ZIP" };
-    }
+    const index = await fetchRegistryIndex();
+    const registryPackages = index.packages || [];
 
-    // Parse theme data
-    const themeJson = themeEntry.getData().toString("utf-8");
-    let themeData;
-    try {
-      themeData = JSON.parse(themeJson);
-    } catch (parseErr) {
-      return { success: false, error: "Invalid JSON in theme file: " + parseErr.message };
-    }
+    const updates = checkDashboardUpdates(workspaces, registryPackages);
 
-    // Add registry metadata
-    themeData._registryMeta = {
-      source: "registry",
-      packageName,
-      installedAt: new Date().toISOString(),
+    return {
+      success: true,
+      updates,
+      totalInstalled: workspaces.filter(
+        (w) => w._dashboardConfig?.registryPackage,
+      ).length,
     };
-
-    // Determine theme key from package display name or name
-    const themeKey = pkg.displayName || pkg.name;
-
-    // Save via themeController
-    const saveResult = themeController$1.saveThemeForApplication(
-      win,
-      appId,
-      themeKey,
-      themeData,
+  } catch (error) {
+    console.error(
+      "[DashboardConfigController] Error checking dashboard updates:",
+      error,
     );
-
-    if (saveResult.error) {
-      return { success: false, error: "Failed to save theme: " + saveResult.message };
-    }
-
-    console.log("[ThemeRegistryController] Theme installed:", themeKey);
-
     return {
-      success: true,
-      themeKey,
-      theme: themeData,
-      themes: saveResult.themes,
+      success: false,
+      error: error.message,
+      updates: [],
     };
+  }
+}
+
+/**
+ * Get a provider setup manifest for a dashboard's requirements.
+ * Compares required providers against the user's configured providers.
+ *
+ * @param {string} appId - Application identifier
+ * @param {Array} requiredProviders - Provider requirements from dashboard config
+ * @returns {Object} Setup manifest with per-provider status
+ */
+function getProviderSetupManifest$1(appId, requiredProviders = []) {
+  const {
+    buildProviderSetupManifest,
+  } = dashboardConfigUtils$1;
+  const { listProviders } = requireProviderController();
+
+  let configuredProviders = [];
+  try {
+    configuredProviders = listProviders(null, appId) || [];
   } catch (err) {
-    console.error("[ThemeRegistryController] Error installing theme:", err);
-    return { success: false, error: err.message };
+    console.warn(
+      "[DashboardConfigController] Could not list providers:",
+      err.message,
+    );
   }
+
+  return buildProviderSetupManifest(requiredProviders, configuredProviders);
 }
 
 /**
- * Get a preview of theme data for the publish modal.
+ * Get a publish preview for a dashboard workspace.
+ * Returns widget/layout info without creating a ZIP or uploading.
  *
  * @param {string} appId - Application identifier
- * @param {string} themeKey - Theme key
- * @returns {Object} Preview data with theme name, colors, etc.
+ * @param {number|string} workspaceId - Workspace to preview
+ * @param {Object} widgetRegistry - WidgetRegistry instance (optional)
+ * @returns {Object} Preview with dashboardName, widgetCount, widgets, componentNames
  */
-function getThemePublishPreview$1(appId, themeKey) {
+function getDashboardPublishPreview$1(appId, workspaceId, widgetRegistry = null) {
   try {
-    const themesResult = themeController$1.listThemesForApplication(null, appId);
-    if (themesResult.error) {
-      return { success: false, error: "Failed to read themes: " + themesResult.message };
-    }
+    const filename = path$1.join(
+      app$1.getPath("userData"),
+      appName$1,
+      appId,
+      configFilename,
+    );
+    const workspacesArray = getFileContents$1(filename);
+    const workspace = workspacesArray.find(
+      (w) => w.id === workspaceId || w.id === Number(workspaceId),
+    );
 
-    const themeData = themesResult.themes[themeKey];
-    if (!themeData) {
-      return { success: false, error: `Theme "${themeKey}" not found` };
+    if (!workspace) {
+      return { success: false, error: `Workspace not found: ${workspaceId}` };
     }
 
-    const colors = extractColors(themeData);
+    const layout = workspace.layout || [];
+    const componentNames = collectComponentNames(layout);
+    const widgets = buildWidgetDependencies(componentNames, widgetRegistry);
 
     return {
       success: true,
-      themeName: themeKey,
-      colors,
-      hasRegistryMeta: !!themeData._registryMeta,
+      dashboardName: workspace.name || workspace.label || "Dashboard",
+      widgetCount: componentNames.length,
+      widgets: widgets.map((w) => ({ name: w.name, package: w.package })),
+      componentNames: [...componentNames],
     };
-  } catch (err) {
-    console.error("[ThemeRegistryController] Error getting preview:", err);
-    return { success: false, error: err.message };
+  } catch (error) {
+    console.error(
+      "[DashboardConfigController] Error getting publish preview:",
+      error,
+    );
+    return { success: false, error: error.message };
   }
 }
 
-var themeRegistryController$1 = {
-  prepareThemeForPublish: prepareThemeForPublish$1,
-  installThemeFromRegistry: installThemeFromRegistry$1,
-  getThemePublishPreview: getThemePublishPreview$1,
-  generateThemeRegistryManifest,
-  extractColors,
+var dashboardConfigController$1 = {
+  exportDashboardConfig: exportDashboardConfig$1,
+  selectDashboardFile: selectDashboardFile$1,
+  importDashboardConfig: importDashboardConfig$1,
+  installDashboardFromRegistry: installDashboardFromRegistry$1,
+  checkCompatibility: checkCompatibility$1,
+  prepareDashboardForPublish: prepareDashboardForPublish$1,
+  getDashboardPreview: getDashboardPreview$1,
+  checkDashboardUpdatesForApp: checkDashboardUpdatesForApp$1,
+  getProviderSetupManifest: getProviderSetupManifest$1,
+  getDashboardPublishPreview: getDashboardPublishPreview$1,
 };
 
+/**
+ * notificationController.js
+ *
+ * Main process controller for OS-level notifications.
+ * Manages preferences (electron-store), rate limiting, deduplication,
+ * and dispatching native Notification instances.
+ */
+
+const { Notification } = require$$0$1;
+const Store = require$$1;
+
+const store$1 = new Store({ name: "dash-notifications" });
+
+// --- Rate limiting ---
+// Sliding window: max 10 notifications per 60s per widget
+const RATE_LIMIT_WINDOW_MS = 60_000;
+const RATE_LIMIT_MAX = 10;
+const rateBuckets = new Map(); // widgetId -> [timestamp, ...]
+
+// --- Deduplication ---
+// Same (widgetName, type, title, body) within 5s is dropped
+const DEDUP_WINDOW_MS = 5_000;
+const recentNotifications = new Map(); // dedup key -> timestamp
+
+function getDedupKey(payload) {
+  return `${payload.widgetName}:${payload.type}:${payload.title}:${payload.body}`;
+}
+
+function isRateLimited(widgetId) {
+  const now = Date.now();
+  let timestamps = rateBuckets.get(widgetId) || [];
+  // Prune old entries
+  timestamps = timestamps.filter((t) => now - t < RATE_LIMIT_WINDOW_MS);
+  rateBuckets.set(widgetId, timestamps);
+  return timestamps.length >= RATE_LIMIT_MAX;
+}
+
+function recordNotification(widgetId) {
+  const timestamps = rateBuckets.get(widgetId) || [];
+  timestamps.push(Date.now());
+  rateBuckets.set(widgetId, timestamps);
+}
+
+function isDuplicate(payload) {
+  const key = getDedupKey(payload);
+  const now = Date.now();
+  const lastSent = recentNotifications.get(key);
+  if (lastSent && now - lastSent < DEDUP_WINDOW_MS) {
+    return true;
+  }
+  recentNotifications.set(key, now);
+  return false;
+}
+
+// Clean up stale dedup entries periodically
+setInterval(() => {
+  const now = Date.now();
+  for (const [key, ts] of recentNotifications) {
+    if (now - ts > DEDUP_WINDOW_MS) {
+      recentNotifications.delete(key);
+    }
+  }
+}, 30_000);
+
+const notificationController$2 = {
+  /**
+   * Send a notification if it passes all checks.
+   *
+   * @param {BrowserWindow} win - the main window (for click routing)
+   * @param {Object} payload
+   * @param {string} payload.widgetName - component name of the widget
+   * @param {string} payload.widgetId - widget instance UUID
+   * @param {string} payload.workspaceId - workspace containing the widget
+   * @param {string} payload.type - notification type key (must match .dash.js config)
+   * @param {string} payload.title - notification title
+   * @param {string} payload.body - notification body
+   * @param {Object} [payload.data] - arbitrary data returned on click
+   * @param {boolean} [payload.silent] - suppress sound
+   * @param {string} [payload.urgency] - "low" | "normal" | "critical"
+   * @returns {{ success: boolean, reason?: string }}
+   */
+  send: (win, payload) => {
+    try {
+      const {
+        widgetName,
+        widgetId,
+        workspaceId,
+        type,
+        title,
+        body,
+        data,
+        silent,
+        urgency,
+      } = payload;
+
+      // 1. Check globalEnabled
+      const globalEnabled = store$1.get("globalEnabled", true);
+      if (!globalEnabled) {
+        return { success: false, reason: "notifications_disabled" };
+      }
+
+      // 2. Check doNotDisturb
+      const dnd = store$1.get("doNotDisturb", false);
+      if (dnd) {
+        return { success: false, reason: "do_not_disturb" };
+      }
+
+      // 3. Check per-widget per-type preference
+      const instances = store$1.get("instances", {});
+      const widgetPrefs = instances[widgetId];
+      if (widgetPrefs && widgetPrefs[type] === false) {
+        return { success: false, reason: "type_disabled" };
+      }
+
+      // 4. Rate limit
+      if (isRateLimited(widgetId)) {
+        return { success: false, reason: "rate_limited" };
+      }
+
+      // 5. Deduplication
+      if (isDuplicate(payload)) {
+        return { success: false, reason: "duplicate" };
+      }
+
+      // 6. All checks passed — send native notification
+      const notification = new Notification({
+        title,
+        body,
+        silent: silent || false,
+        urgency: urgency || "normal",
+      });
+
+      notification.on("click", () => {
+        if (win && !win.isDestroyed()) {
+          win.show();
+          win.focus();
+          win.webContents.send("notification:clicked", {
+            widgetName,
+            widgetId,
+            workspaceId,
+            type,
+            data: data || null,
+          });
+        }
+      });
+
+      notification.show();
+      recordNotification(widgetId);
+
+      console.log(
+        `[notificationController] Sent: ${widgetName}.${type} — "${title}"`,
+      );
+
+      return { success: true };
+    } catch (error) {
+      console.error(
+        "[notificationController] Error sending notification:",
+        error,
+      );
+      return { error: true, message: error.message };
+    }
+  },
+
+  /**
+   * Get all notification preferences.
+   *
+   * @returns {{ globalEnabled: boolean, doNotDisturb: boolean, instances: Object }}
+   */
+  getPreferences: () => {
+    try {
+      return {
+        globalEnabled: store$1.get("globalEnabled", true),
+        doNotDisturb: store$1.get("doNotDisturb", false),
+        instances: store$1.get("instances", {}),
+      };
+    } catch (error) {
+      console.error(
+        "[notificationController] Error getting preferences:",
+        error,
+      );
+      return {
+        error: true,
+        message: error.message,
+        globalEnabled: true,
+        doNotDisturb: false,
+        instances: {},
+      };
+    }
+  },
+
+  /**
+   * Set notification preferences for a specific widget instance.
+   *
+   * @param {string} widgetId - widget instance UUID
+   * @param {Object} prefs - { [notificationType]: boolean }
+   * @returns {{ success: boolean }}
+   */
+  setPreferences: (widgetId, prefs) => {
+    try {
+      const instances = store$1.get("instances", {});
+      instances[widgetId] = { ...(instances[widgetId] || {}), ...prefs };
+      store$1.set("instances", instances);
+      console.log(
+        `[notificationController] Preferences updated for widget ${widgetId}`,
+      );
+      return { success: true };
+    } catch (error) {
+      console.error(
+        "[notificationController] Error setting preferences:",
+        error,
+      );
+      return { error: true, message: error.message };
+    }
+  },
+
+  /**
+   * Set global notification settings.
+   *
+   * @param {Object} settings
+   * @param {boolean} [settings.globalEnabled]
+   * @param {boolean} [settings.doNotDisturb]
+   * @returns {{ success: boolean }}
+   */
+  setGlobal: (settings) => {
+    try {
+      if (typeof settings.globalEnabled === "boolean") {
+        store$1.set("globalEnabled", settings.globalEnabled);
+      }
+      if (typeof settings.doNotDisturb === "boolean") {
+        store$1.set("doNotDisturb", settings.doNotDisturb);
+      }
+      console.log(
+        "[notificationController] Global settings updated:",
+        settings,
+      );
+      return { success: true };
+    } catch (error) {
+      console.error("[notificationController] Error setting global:", error);
+      return { error: true, message: error.message };
+    }
+  },
+};
+
+var notificationController_1 = notificationController$2;
+
 /**
  * clientFactories.js
  *