@trops/dash-core 0.1.205 → 0.1.206

package/dist/electron/index.js

@@ -29580,1790 +29580,1785 @@ var dashboardConfigUtils$1 = {
   checkApiCompatibility,
 };
 
-var widgetRegistry$1 = {exports: {}};
-
-var dynamicWidgetLoader$2 = {exports: {}};
-
 /**
- * Widget Compiler
+ * registryAuthController.js
  *
- * Compiles raw widget source files (.js + .dash.js) into a single CJS bundle
- * using esbuild. The output bundle is consumable by the existing
- * widgetBundleLoader.js eval pipeline (new Function() + require shim).
+ * Manages authentication with the Dash registry service.
+ * Uses OAuth device code flow for desktop app authentication.
  *
- * Runs in the Electron main process at widget install time.
+ * Flow:
+ * 1. App calls initiateDeviceFlow() — gets device code + verification URL
+ * 2. User opens verification URL in browser, signs in, enters code
+ * 3. App polls pollForToken() until authorized
+ * 4. Token stored securely via electron-store (encrypted)
  */
 
-const fs$2 = require$$0$3;
-const path$5 = require$$1$2;
+const REGISTRY_BASE_URL$1 =
+  process.env.DASH_REGISTRY_API_URL ||
+  "https://main.d919rwhuzp7rj.amplifyapp.com";
+
+// Lazy-load electron-store to avoid issues when not installed
+let store$3 = null;
+function getStore$1() {
+  if (!store$3) {
+    const Store = require$$1$1;
+    store$3 = new Store({
+      name: "dash-registry-auth",
+      encryptionKey: "dash-registry-v1",
+    });
+  }
+  return store$3;
+}
 
 /**
- * Find the widgets/ directory, handling nested ZIP extraction.
- *
- * ZIP extraction can create a nested structure like:
- *   Weather/weather-widget/widgets/  instead of  Weather/widgets/
+ * Initiate the OAuth device code flow.
+ * Returns the device code, user code, and verification URL.
  *
- * If widgets/ doesn't exist at root, check one level deeper for a
- * single subdirectory that contains widgets/.
+ * @returns {Promise<Object>} { deviceCode, userCode, verificationUrl, verificationUrlComplete, expiresIn, interval }
+ */
+async function initiateDeviceFlow$1() {
+  const response = await fetch(`${REGISTRY_BASE_URL$1}/api/auth/device`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Device flow initiation failed: ${response.status}`);
+  }
+
+  const data = await response.json();
+
+  return {
+    deviceCode: data.device_code,
+    userCode: data.user_code,
+    verificationUrl: data.verification_uri,
+    verificationUrlComplete: data.verification_uri_complete,
+    expiresIn: data.expires_in,
+    interval: data.interval,
+  };
+}
+
+/**
+ * Poll the registry for token after user completes browser auth.
  *
- * @param {string} widgetPath - Absolute path to the widget directory
- * @returns {string|null} Path to the widgets/ directory, or null
+ * @param {string} deviceCode - The device code from initiateDeviceFlow()
+ * @returns {Promise<Object>} { status: 'pending' | 'authorized' | 'expired', token?, userId? }
  */
-function findWidgetsDir$1(widgetPath) {
-  const direct = path$5.join(widgetPath, "widgets");
-  if (fs$2.existsSync(direct)) {
-    return direct;
+async function pollForToken$1(deviceCode) {
+  const response = await fetch(
+    `${REGISTRY_BASE_URL$1}/api/auth/device?device_code=${encodeURIComponent(deviceCode)}`,
+  );
+
+  if (response.status === 428) {
+    return { status: "pending" };
   }
 
-  // Check configs/ directory (used by packageZip.js for distributed widgets)
-  const configs = path$5.join(widgetPath, "configs");
-  if (fs$2.existsSync(configs)) {
-    return configs;
+  if (response.status === 400) {
+    const data = await response.json();
+    if (data.error === "expired_token") {
+      return { status: "expired" };
+    }
+    return { status: "pending" };
   }
 
-  // Check one level deeper for nested ZIP extraction
-  try {
-    const entries = fs$2.readdirSync(widgetPath, { withFileTypes: true });
-    const subdirs = entries.filter(
-      (e) =>
-        e.isDirectory() &&
-        !e.name.startsWith(".") &&
-        e.name !== "dist" &&
-        e.name !== "node_modules",
-    );
+  if (response.ok) {
+    const data = await response.json();
 
-    for (const subdir of subdirs) {
-      const nested = path$5.join(widgetPath, subdir.name, "widgets");
-      if (fs$2.existsSync(nested)) {
-        console.log(`[WidgetCompiler] Found nested widgets/ at ${nested}`);
-        return nested;
-      }
-    }
-  } catch (err) {
-    // Non-fatal — fall through to null
+    // Store the token securely
+    const s = getStore$1();
+    s.set("accessToken", data.access_token);
+    s.set("userId", data.user_id);
+    s.set("tokenType", data.token_type);
+    s.set("authenticatedAt", new Date().toISOString());
+
+    return {
+      status: "authorized",
+      token: data.access_token,
+      userId: data.user_id,
+    };
   }
 
-  return null;
+  throw new Error(`Unexpected response: ${response.status}`);
 }
 
 /**
- * Compile widget source files into a CJS bundle at dist/index.cjs.js.
- *
- * For each {Name}.dash.js found in the widgets/ directory, a synthetic
- * entry point is generated that imports the component + config and
- * re-exports them as `{ ...config, component }` — matching what
- * extractWidgetConfigs() in widgetBundleLoader.js expects.
+ * Get the stored auth token.
  *
- * @param {string} widgetPath - Absolute path to the widget directory
- * @returns {Promise<string|null>} Path to the compiled bundle, or null if nothing to compile
+ * @returns {Object|null} { token, userId, authenticatedAt } or null if not authenticated
  */
-async function compileWidget(widgetPath) {
-  const widgetsDir = findWidgetsDir$1(widgetPath);
+function getStoredToken$3() {
+  try {
+    const s = getStore$1();
+    const token = s.get("accessToken");
+    if (!token) return null;
 
-  if (!widgetsDir) {
-    console.log(
-      `[WidgetCompiler] No widgets/ directory in ${widgetPath}, skipping`,
-    );
+    return {
+      token,
+      userId: s.get("userId"),
+      authenticatedAt: s.get("authenticatedAt"),
+    };
+  } catch {
     return null;
   }
+}
 
-  // Discover .dash.js config files
-  const files = fs$2.readdirSync(widgetsDir);
-  const dashFiles = files.filter((f) => f.endsWith(".dash.js"));
-
-  if (dashFiles.length === 0) {
-    console.log(
-      `[WidgetCompiler] No .dash.js files found in ${widgetsDir}, skipping`,
-    );
-    return null;
+/**
+ * Check if the user is authenticated with the registry.
+ *
+ * @returns {Object} { authenticated: boolean, userId?: string }
+ */
+function getAuthStatus$1() {
+  const stored = getStoredToken$3();
+  if (!stored) {
+    return { authenticated: false };
   }
 
-  // Build a synthetic entry point that pairs each component with its config.
-  // Compute relative path from the entry file (in widgetPath) to widgetsDir,
-  // since widgetsDir may be nested (e.g., ./weather-widget/widgets/).
-  const relWidgetsDir =
-    "./" + path$5.relative(widgetPath, widgetsDir).split(path$5.sep).join("/");
-  const imports = [];
-  const exportParts = [];
+  return {
+    authenticated: true,
+    userId: stored.userId,
+    authenticatedAt: stored.authenticatedAt,
+  };
+}
 
-  for (const dashFile of dashFiles) {
-    const componentName = dashFile.replace(".dash.js", "");
-    const componentFile = `${componentName}.js`;
-    const componentFilePath = path$5.join(widgetsDir, componentFile);
-    const hasComponent = fs$2.existsSync(componentFilePath);
+/**
+ * Get the user's registry profile.
+ *
+ * @returns {Promise<Object|null>} User profile or null
+ */
+async function getRegistryProfile$2() {
+  const stored = getStoredToken$3();
+  if (!stored) return null;
 
-    // Import the config (always)
-    imports.push(
-      `import ${componentName}Config from "${relWidgetsDir}/${dashFile}";`,
-    );
+  try {
+    const response = await fetch(`${REGISTRY_BASE_URL$1}/api/auth/me`, {
+      headers: {
+        Authorization: `Bearer ${stored.token}`,
+      },
+    });
 
-    if (hasComponent) {
-      // Import the component and merge with config
-      imports.push(
-        `import ${componentName}Comp from "${relWidgetsDir}/${componentFile}";`,
-      );
-      exportParts.push(
-        `export const ${componentName} = { ...${componentName}Config, component: ${componentName}Comp };`,
-      );
-    } else {
-      // Config-only (no component source file)
-      exportParts.push(
-        `export const ${componentName} = ${componentName}Config;`,
-      );
+    if (response.status === 401) {
+      // Token expired or invalid — clear stored credentials
+      clearToken();
+      return null;
     }
+    if (!response.ok) return null;
+
+    const data = await response.json();
+    return data.user || null;
+  } catch {
+    return null;
   }
+}
 
-  const entryContent = [...imports, "", ...exportParts, ""].join("\n");
+/**
+ * Clear stored auth token (logout).
+ */
+function clearToken() {
+  try {
+    const s = getStore$1();
+    s.clear();
+    console.log("[RegistryAuthController] Token cleared");
+  } catch (err) {
+    console.error("[RegistryAuthController] Error clearing token:", err);
+  }
+}
 
-  // Write temporary entry file in the widget root
-  const entryPath = path$5.join(widgetPath, "__compile_entry.js");
-  const distDir = path$5.join(widgetPath, "dist");
-  const outPath = path$5.join(distDir, "index.cjs.js");
+/**
+ * Update the authenticated user's registry profile.
+ *
+ * @param {Object} updates - Fields to update (e.g. { displayName })
+ * @returns {Promise<Object|null>} Updated user or null on 401
+ */
+async function updateRegistryProfile$1(updates) {
+  const stored = getStoredToken$3();
+  if (!stored) return null;
 
   try {
-    // Ensure dist/ directory exists
-    if (!fs$2.existsSync(distDir)) {
-      fs$2.mkdirSync(distDir, { recursive: true });
-    }
+    const response = await fetch(`${REGISTRY_BASE_URL$1}/api/auth/me`, {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${stored.token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(updates),
+    });
 
-    fs$2.writeFileSync(entryPath, entryContent, "utf8");
+    if (response.status === 401) {
+      clearToken();
+      return null;
+    }
+    if (!response.ok) return null;
 
-    console.log(
-      `[WidgetCompiler] Compiling ${dashFiles.length} component(s) from ${widgetPath}`,
-    );
+    const data = await response.json();
+    return data.user || null;
+  } catch {
+    return null;
+  }
+}
 
-    // Lazy-require esbuild so the module doesn't fail to load if
-    // esbuild is not yet installed (e.g., during first npm install)
-    const esbuild = require("esbuild");
+/**
+ * Get the authenticated user's published packages.
+ *
+ * @returns {Promise<Object|null>} { packages: [...] } or null
+ */
+async function getRegistryPackages$1() {
+  const stored = getStoredToken$3();
+  if (!stored) return null;
 
-    await esbuild.build({
-      entryPoints: [entryPath],
-      bundle: true,
-      format: "cjs",
-      outfile: outPath,
-      // These modules are provided by the host app via MODULE_MAP
-      // in widgetBundleLoader.js — do NOT bundle them
-      external: [
-        "react",
-        "react-dom",
-        "@trops/dash-react",
-        "@trops/dash-core",
-        "react/jsx-runtime",
-        "prop-types",
-      ],
-      // Treat .js files as JSX (widget sources use JSX in .js files)
-      loader: { ".js": "jsx" },
-      logLevel: "warning",
+  try {
+    const response = await fetch(`${REGISTRY_BASE_URL$1}/api/auth/me/packages`, {
+      headers: {
+        Authorization: `Bearer ${stored.token}`,
+      },
     });
 
-    console.log(`[WidgetCompiler] Compiled successfully → ${outPath}`);
-    return outPath;
-  } catch (error) {
-    console.error(
-      `[WidgetCompiler] Compilation failed for ${widgetPath}:`,
-      error,
-    );
-    throw error;
-  } finally {
-    // Clean up temporary entry file
-    try {
-      if (fs$2.existsSync(entryPath)) {
-        fs$2.unlinkSync(entryPath);
-      }
-    } catch (cleanupError) {
-      // Non-fatal
-      console.warn(
-        `[WidgetCompiler] Could not remove temp entry file:`,
-        cleanupError,
-      );
+    if (response.status === 401) {
+      clearToken();
+      return null;
     }
+    if (!response.ok) return null;
+
+    return await response.json();
+  } catch {
+    return null;
   }
 }
 
-var widgetCompiler$1 = { compileWidget, findWidgetsDir: findWidgetsDir$1 };
-
 /**
- * Dynamic Widget Loader
- *
- * Loads React components and configurations from downloaded/local widget paths
- * Works with widgets that follow the Dash widget structure:
- * - widgets/
- *   - WidgetName.js (React component)
- *   - WidgetName.dash.js (configuration)
+ * Update a published package's metadata.
  *
- * Integrates with ComponentManager for automatic registration
+ * @param {string} scope - Package scope (e.g. "@trops")
+ * @param {string} name - Package name
+ * @param {Object} updates - Fields to update (displayName, description, category, tags, visibility)
+ * @returns {Promise<Object|null>} Updated package or null
  */
+async function updateRegistryPackage$1(scope, name, updates) {
+  const stored = getStoredToken$3();
+  if (!stored) return null;
 
-const fs$1 = require$$0$3;
-const path$4 = require$$1$2;
-const vm = require$$2$3;
-const { findWidgetsDir } = widgetCompiler$1;
+  try {
+    const response = await fetch(
+      `${REGISTRY_BASE_URL$1}/api/packages/${encodeURIComponent(scope)}/${encodeURIComponent(name)}`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: `Bearer ${stored.token}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(updates),
+      },
+    );
 
-class DynamicWidgetLoader {
-  constructor(componentManager = null) {
-    this.loadedWidgets = new Map();
-    this.moduleCache = new Map();
-    this.componentManager = componentManager;
-  }
+    if (response.status === 401) {
+      clearToken();
+      return null;
+    }
+    if (!response.ok) return null;
 
-  /**
-   * Set ComponentManager instance for automatic widget registration
-   * @param {Object} manager - ComponentManager instance from @trops/dash-react
-   */
-  setComponentManager(manager) {
-    this.componentManager = manager;
+    return await response.json();
+  } catch {
+    return null;
   }
+}
 
-  /**
-   * Load a widget from a local path
-   * @param {string} widgetName - Name of the widget (e.g., "MyFirstWidget")
-   * @param {string} widgetPath - Path to the widget directory
-   * @param {string} componentName - Name of the component file (e.g., "MyFirstWidgetWidget")
-   * @param {boolean} autoRegister - Automatically register with ComponentManager (if available)
-   * @returns {Promise<Object>} { component, config, registered }
-   */
-  async loadWidget(widgetName, widgetPath, componentName, autoRegister = true) {
-    try {
-      const cacheKey = `${widgetName}:${componentName}`;
-
-      if (this.loadedWidgets.has(cacheKey)) {
-        console.log(`[DynamicWidgetLoader] Loading ${widgetName} from cache`);
-        return this.loadedWidgets.get(cacheKey);
-      }
-
-      console.log(
-        `[DynamicWidgetLoader] Loading widget: ${widgetName} from ${widgetPath}`,
-      );
+/**
+ * Delete a published package from the registry.
+ *
+ * @param {string} scope - Package scope (e.g. "@trops")
+ * @param {string} name - Package name
+ * @returns {Promise<Object|null>} Response or null
+ */
+async function deleteRegistryPackage(scope, name) {
+  const stored = getStoredToken$3();
+  if (!stored) return null;
 
-      const widgetsDir =
-        findWidgetsDir(widgetPath) || path$4.join(widgetPath, "widgets");
-      const componentPath = path$4.join(widgetsDir, `${componentName}.js`);
-      const configPath = path$4.join(widgetsDir, `${componentName}.dash.js`);
+  try {
+    const response = await fetch(
+      `${REGISTRY_BASE_URL$1}/api/packages/${encodeURIComponent(scope)}/${encodeURIComponent(name)}`,
+      {
+        method: "DELETE",
+        headers: {
+          Authorization: `Bearer ${stored.token}`,
+        },
+      },
+    );
 
-      if (!fs$1.existsSync(componentPath)) {
-        throw new Error(`Component file not found: ${componentPath}`);
-      }
-      if (!fs$1.existsSync(configPath)) {
-        throw new Error(`Config file not found: ${configPath}`);
-      }
+    if (response.status === 401) {
+      clearToken();
+      return null;
+    }
+    if (!response.ok) return null;
 
-      const config = await this.loadConfigFile(configPath);
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
 
-      const component = {
-        path: componentPath,
-        name: componentName,
-      };
+var registryAuthController$1 = {
+  initiateDeviceFlow: initiateDeviceFlow$1,
+  pollForToken: pollForToken$1,
+  getStoredToken: getStoredToken$3,
+  getAuthStatus: getAuthStatus$1,
+  getRegistryProfile: getRegistryProfile$2,
+  updateRegistryProfile: updateRegistryProfile$1,
+  getRegistryPackages: getRegistryPackages$1,
+  updateRegistryPackage: updateRegistryPackage$1,
+  deleteRegistryPackage,
+  clearToken,
+};
 
-      let registered = false;
+var widgetRegistry$1 = {exports: {}};
 
-      if (autoRegister && this.componentManager) {
-        try {
-          // Use scoped id as registration key if available,
-          // otherwise fall back to componentName
-          const registrationKey = config.id || componentName;
-          this.componentManager.registerWidget(config, registrationKey);
-          registered = true;
-          console.log(
-            `[DynamicWidgetLoader] ✓ Registered ${registrationKey} with ComponentManager`,
-          );
-        } catch (regError) {
-          console.warn(
-            `[DynamicWidgetLoader] Failed to register with ComponentManager:`,
-            regError,
-          );
-        }
-      }
+var dynamicWidgetLoader$2 = {exports: {}};
 
-      const result = { component, config, registered };
-      this.loadedWidgets.set(cacheKey, result);
+/**
+ * Widget Compiler
+ *
+ * Compiles raw widget source files (.js + .dash.js) into a single CJS bundle
+ * using esbuild. The output bundle is consumable by the existing
+ * widgetBundleLoader.js eval pipeline (new Function() + require shim).
+ *
+ * Runs in the Electron main process at widget install time.
+ */
 
-      return result;
-    } catch (error) {
-      console.error(
-        `[DynamicWidgetLoader] Error loading widget ${widgetName}:`,
-        error,
-      );
-      throw error;
-    }
-  }
+const fs$2 = require$$0$3;
+const path$5 = require$$1$2;
 
-  /**
-   * Load and parse a .dash.js configuration file
-   * @param {string} configPath - Path to the .dash.js file
-   * @returns {Promise<Object>} Configuration object
-   */
-  async loadConfigFile(configPath) {
-    try {
-      const source = fs$1.readFileSync(configPath, "utf8");
-
-      let exportMatch = source.match(/export\s+default\s+({[\s\S]*});?\s*$/);
-
-      // Handle variable export pattern: const x = {...}; export default x;
-      if (!exportMatch) {
-        const varExportMatch = source.match(
-          /export\s+default\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*;?\s*$/,
-        );
-        if (varExportMatch) {
-          const varName = varExportMatch[1];
-          const varDeclMatch = source.match(
-            new RegExp(
-              `(?:const|let|var)\\s+${varName}\\s*=\\s*({[\\s\\S]*?});\\s*(?:export\\s+default)`,
-            ),
-          );
-          if (varDeclMatch) {
-            exportMatch = varDeclMatch;
-          }
-        }
-      }
-
-      if (!exportMatch) {
-        throw new Error("Could not find default export in config file");
-      }
-
-      // Sanitize component references so vm.runInContext doesn't fail
-      // on unresolvable imports — replace component: SomeName with component: "SomeName"
-      const exportedObjectStr = exportMatch[1].replace(
-        /component\s*:\s*([A-Z][a-zA-Z0-9_$]*)/g,
-        'component: "$1"',
-      );
-
-      const context = vm.createContext({ module: { exports: {} } });
-      vm.runInContext(`module.exports = ${exportedObjectStr}`, context);
-
-      return context.module.exports;
-    } catch (error) {
-      console.error(`[DynamicWidgetLoader] Error loading config:`, error);
-      throw error;
-    }
+/**
+ * Find the widgets/ directory, handling nested ZIP extraction.
+ *
+ * ZIP extraction can create a nested structure like:
+ *   Weather/weather-widget/widgets/  instead of  Weather/widgets/
+ *
+ * If widgets/ doesn't exist at root, check one level deeper for a
+ * single subdirectory that contains widgets/.
+ *
+ * @param {string} widgetPath - Absolute path to the widget directory
+ * @returns {string|null} Path to the widgets/ directory, or null
+ */
+function findWidgetsDir$1(widgetPath) {
+  const direct = path$5.join(widgetPath, "widgets");
+  if (fs$2.existsSync(direct)) {
+    return direct;
   }
 
-  /**
-   * Discover available widgets in a directory
-   * @param {string} widgetPath - Path to search for widgets
-   * @returns {Array} List of available widget names
-   */
-  discoverWidgets(widgetPath) {
-    try {
-      const widgetsDir = findWidgetsDir(widgetPath);
-      if (!widgetsDir) {
-        return [];
-      }
-
-      const files = fs$1.readdirSync(widgetsDir);
-      const widgets = new Set();
+  // Check configs/ directory (used by packageZip.js for distributed widgets)
+  const configs = path$5.join(widgetPath, "configs");
+  if (fs$2.existsSync(configs)) {
+    return configs;
+  }
 
-      files.forEach((file) => {
-        if (file.endsWith(".dash.js")) {
-          const componentName = file.replace(".dash.js", "");
-          widgets.add(componentName);
-        }
-      });
+  // Check one level deeper for nested ZIP extraction
+  try {
+    const entries = fs$2.readdirSync(widgetPath, { withFileTypes: true });
+    const subdirs = entries.filter(
+      (e) =>
+        e.isDirectory() &&
+        !e.name.startsWith(".") &&
+        e.name !== "dist" &&
+        e.name !== "node_modules",
+    );
 
-      return Array.from(widgets);
-    } catch (error) {
-      console.error(`[DynamicWidgetLoader] Error discovering widgets:`, error);
-      return [];
+    for (const subdir of subdirs) {
+      const nested = path$5.join(widgetPath, subdir.name, "widgets");
+      if (fs$2.existsSync(nested)) {
+        console.log(`[WidgetCompiler] Found nested widgets/ at ${nested}`);
+        return nested;
+      }
     }
+  } catch (err) {
+    // Non-fatal — fall through to null
   }
 
-  /**
-   * Clear cache
-   */
-  clearCache() {
-    this.loadedWidgets.clear();
-    this.moduleCache.clear();
-  }
+  return null;
 }
 
-const dynamicWidgetLoader$1 = new DynamicWidgetLoader();
-
-dynamicWidgetLoader$2.exports = DynamicWidgetLoader;
-dynamicWidgetLoader$2.exports.dynamicWidgetLoader = dynamicWidgetLoader$1;
-
-var dynamicWidgetLoaderExports = dynamicWidgetLoader$2.exports;
-
 /**
- * schedulerController.js
+ * Compile widget source files into a CJS bundle at dist/index.cjs.js.
  *
- * Main process controller for widget scheduled tasks.
- * Manages a tick loop (1s resolution), persistence (electron-store),
- * and dispatching task-fired events to renderer windows.
+ * For each {Name}.dash.js found in the widgets/ directory, a synthetic
+ * entry point is generated that imports the component + config and
+ * re-exports them as `{ ...config, component }` — matching what
+ * extractWidgetConfigs() in widgetBundleLoader.js expects.
+ *
+ * @param {string} widgetPath - Absolute path to the widget directory
+ * @returns {Promise<string|null>} Path to the compiled bundle, or null if nothing to compile
  */
+async function compileWidget(widgetPath) {
+  const widgetsDir = findWidgetsDir$1(widgetPath);
 
-const Store$1 = require$$1$1;
-const { Cron } = require$$1$5;
-
-const store$3 = new Store$1({ name: "dash-scheduler" });
-
-// --- In-memory state ---
-const tasks = new Map(); // taskId -> task object
-const pendingResults = new Map(); // widgetId -> Array<{ taskId, taskKey, firedAt }>
+  if (!widgetsDir) {
+    console.log(
+      `[WidgetCompiler] No widgets/ directory in ${widgetPath}, skipping`,
+    );
+    return null;
+  }
 
-const MAX_TASKS_PER_WIDGET = 20;
-const MAX_PENDING_PER_WIDGET = 100;
-const PERSIST_DEBOUNCE_MS = 30_000;
+  // Discover .dash.js config files
+  const files = fs$2.readdirSync(widgetsDir);
+  const dashFiles = files.filter((f) => f.endsWith(".dash.js"));
 
-let tickInterval = null;
-let persistTimeout = null;
-let deps = {
-  getWindows: null,
-  notificationController: null,
-  getMainWindow: null,
-};
+  if (dashFiles.length === 0) {
+    console.log(
+      `[WidgetCompiler] No .dash.js files found in ${widgetsDir}, skipping`,
+    );
+    return null;
+  }
 
-// --- Day name to cron day number ---
-const DAY_MAP = {
-  sun: 0,
-  mon: 1,
-  tue: 2,
-  wed: 3,
-  thu: 4,
-  fri: 5,
-  sat: 6,
-};
+  // Build a synthetic entry point that pairs each component with its config.
+  // Compute relative path from the entry file (in widgetPath) to widgetsDir,
+  // since widgetsDir may be nested (e.g., ./weather-widget/widgets/).
+  const relWidgetsDir =
+    "./" + path$5.relative(widgetPath, widgetsDir).split(path$5.sep).join("/");
+  const imports = [];
+  const exportParts = [];
 
-/**
- * Build a cron expression from days + time for use with croner.
- * @param {string[]} days - ["mon","wed","fri"] or ["every"]
- * @param {string} time - "09:00" (HH:mm)
- * @returns {string} cron expression
- */
-function buildCronExpression(days, time) {
-  const [hours, minutes] = time.split(":").map(Number);
-  if (days.includes("every")) {
-    return `${minutes} ${hours} * * *`;
-  }
-  const dayNums = days.map((d) => DAY_MAP[d]).filter((n) => n !== undefined);
-  return `${minutes} ${hours} * * ${dayNums.join(",")}`;
-}
+  for (const dashFile of dashFiles) {
+    const componentName = dashFile.replace(".dash.js", "");
+    const componentFile = `${componentName}.js`;
+    const componentFilePath = path$5.join(widgetsDir, componentFile);
+    const hasComponent = fs$2.existsSync(componentFilePath);
 
-/**
- * Compute the next fire timestamp for a task.
- * @param {Object} task
- * @param {number} now - current timestamp in ms
- * @returns {number} next fire timestamp in ms
- */
-function computeNextFire(task, now) {
-  if (task.scheduleType === "interval") {
-    return now + (task.intervalMs || 60000);
-  }
+    // Import the config (always)
+    imports.push(
+      `import ${componentName}Config from "${relWidgetsDir}/${dashFile}";`,
+    );
 
-  if (task.scheduleType === "dayTime" && task.days && task.time) {
-    try {
-      const cronExpr = buildCronExpression(task.days, task.time);
-      const job = new Cron(cronExpr);
-      const next = job.nextRun();
-      if (next) {
-        return next.getTime();
-      }
-    } catch (err) {
-      console.error(
-        `[schedulerController] Error computing next fire for ${task.taskId}:`,
-        err,
+    if (hasComponent) {
+      // Import the component and merge with config
+      imports.push(
+        `import ${componentName}Comp from "${relWidgetsDir}/${componentFile}";`,
+      );
+      exportParts.push(
+        `export const ${componentName} = { ...${componentName}Config, component: ${componentName}Comp };`,
+      );
+    } else {
+      // Config-only (no component source file)
+      exportParts.push(
+        `export const ${componentName} = ${componentName}Config;`,
       );
     }
-    // Fallback: 1 hour from now
-    return now + 3600000;
   }
 
-  // Unknown schedule type — default 1 hour
-  return now + 3600000;
-}
+  const entryContent = [...imports, "", ...exportParts, ""].join("\n");
 
-/**
- * Fire a task: broadcast to renderer windows, queue pending, send notification if no windows.
- */
-function fireTask(task) {
-  const payload = {
-    taskId: task.taskId,
-    widgetId: task.widgetId,
-    taskKey: task.taskKey,
-    handler: task.handler,
-    firedAt: Date.now(),
-  };
-
-  console.log(
-    `[schedulerController] Fired: ${task.widgetName}.${task.taskKey} (${task.displayName})`,
-  );
-
-  // Add to pending results queue
-  let queue = pendingResults.get(task.widgetId) || [];
-  queue.push({
-    taskId: task.taskId,
-    taskKey: task.taskKey,
-    firedAt: payload.firedAt,
-  });
-  if (queue.length > MAX_PENDING_PER_WIDGET) {
-    queue = queue.slice(-MAX_PENDING_PER_WIDGET);
-  }
-  pendingResults.set(task.widgetId, queue);
+  // Write temporary entry file in the widget root
+  const entryPath = path$5.join(widgetPath, "__compile_entry.js");
+  const distDir = path$5.join(widgetPath, "dist");
+  const outPath = path$5.join(distDir, "index.cjs.js");
 
-  // Broadcast to all windows
-  const windows = deps.getWindows ? deps.getWindows() : [];
-  if (windows.length > 0) {
-    for (const win of windows) {
-      if (!win.isDestroyed()) {
-        win.webContents.send("scheduler:task-fired", payload);
-      }
-    }
-  } else {
-    // No windows open — send native OS notification
-    if (deps.notificationController && deps.getMainWindow) {
-      deps.notificationController.send(deps.getMainWindow(), {
-        widgetName: task.widgetName,
-        widgetId: task.widgetId,
-        workspaceId: task.workspaceId || "",
-        type: "scheduled-task",
-        title: task.displayName || task.taskKey,
-        body: `Scheduled task "${task.displayName}" fired`,
-        silent: false,
-      });
+  try {
+    // Ensure dist/ directory exists
+    if (!fs$2.existsSync(distDir)) {
+      fs$2.mkdirSync(distDir, { recursive: true });
     }
-  }
-}
 
-/**
- * Main tick — runs every 1s, checks all enabled tasks.
- */
-function tick() {
-  const now = Date.now();
-  for (const [, task] of tasks) {
-    if (!task.enabled || !task.nextFireAt || task.nextFireAt > now) continue;
-    fireTask(task);
-    task.nextFireAt = computeNextFire(task, now);
-    task.lastFiredAt = now;
-    task.fireCount = (task.fireCount || 0) + 1;
-  }
-  debouncedPersist();
-}
+    fs$2.writeFileSync(entryPath, entryContent, "utf8");
 
-/**
- * Persist tasks to electron-store (debounced).
- */
-function debouncedPersist() {
-  if (persistTimeout) return;
-  persistTimeout = setTimeout(() => {
-    persistTimeout = null;
-    persistNow();
-  }, PERSIST_DEBOUNCE_MS);
-}
+    console.log(
+      `[WidgetCompiler] Compiling ${dashFiles.length} component(s) from ${widgetPath}`,
+    );
 
-function persistNow() {
-  try {
-    const data = {};
-    for (const [taskId, task] of tasks) {
-      data[taskId] = { ...task };
-    }
-    store$3.set("tasks", data);
-  } catch (err) {
-    console.error("[schedulerController] Error persisting tasks:", err);
-  }
-}
+    // Lazy-require esbuild so the module doesn't fail to load if
+    // esbuild is not yet installed (e.g., during first npm install)
+    const esbuild = require("esbuild");
 
-/**
- * Load persisted tasks from electron-store.
- */
-function loadFromStore() {
-  try {
-    const data = store$3.get("tasks", {});
-    const now = Date.now();
-    for (const [taskId, task] of Object.entries(data)) {
-      // Recompute nextFireAt if it's in the past
-      if (task.nextFireAt && task.nextFireAt <= now && task.enabled) {
-        task.nextFireAt = computeNextFire(task, now);
+    await esbuild.build({
+      entryPoints: [entryPath],
+      bundle: true,
+      format: "cjs",
+      outfile: outPath,
+      // These modules are provided by the host app via MODULE_MAP
+      // in widgetBundleLoader.js — do NOT bundle them
+      external: [
+        "react",
+        "react-dom",
+        "@trops/dash-react",
+        "@trops/dash-core",
+        "react/jsx-runtime",
+        "prop-types",
+      ],
+      // Treat .js files as JSX (widget sources use JSX in .js files)
+      loader: { ".js": "jsx" },
+      logLevel: "warning",
+    });
+
+    console.log(`[WidgetCompiler] Compiled successfully → ${outPath}`);
+    return outPath;
+  } catch (error) {
+    console.error(
+      `[WidgetCompiler] Compilation failed for ${widgetPath}:`,
+      error,
+    );
+    throw error;
+  } finally {
+    // Clean up temporary entry file
+    try {
+      if (fs$2.existsSync(entryPath)) {
+        fs$2.unlinkSync(entryPath);
       }
-      tasks.set(taskId, task);
+    } catch (cleanupError) {
+      // Non-fatal
+      console.warn(
+        `[WidgetCompiler] Could not remove temp entry file:`,
+        cleanupError,
+      );
     }
-    console.log(`[schedulerController] Loaded ${tasks.size} tasks from store`);
-  } catch (err) {
-    console.error("[schedulerController] Error loading tasks:", err);
   }
 }
 
+var widgetCompiler$1 = { compileWidget, findWidgetsDir: findWidgetsDir$1 };
+
 /**
- * Count tasks for a given widget instance.
+ * Dynamic Widget Loader
+ *
+ * Loads React components and configurations from downloaded/local widget paths
+ * Works with widgets that follow the Dash widget structure:
+ * - widgets/
+ *   - WidgetName.js (React component)
+ *   - WidgetName.dash.js (configuration)
+ *
+ * Integrates with ComponentManager for automatic registration
  */
-function countTasksForWidget(widgetId) {
-  let count = 0;
-  for (const [, task] of tasks) {
-    if (task.widgetId === widgetId) count++;
-  }
-  return count;
-}
 
-const schedulerController$2 = {
-  /**
-   * Wire dependencies from the Electron main process.
-   */
-  init({ getWindows, notificationController, getMainWindow }) {
-    deps.getWindows = getWindows;
-    deps.notificationController = notificationController;
-    deps.getMainWindow = getMainWindow;
-  },
+const fs$1 = require$$0$3;
+const path$4 = require$$1$2;
+const vm = require$$2$3;
+const { findWidgetsDir } = widgetCompiler$1;
 
-  /**
-   * Start the tick loop and load persisted tasks.
-   */
-  start() {
-    loadFromStore();
-    if (!tickInterval) {
-      tickInterval = setInterval(tick, 1000);
-      console.log("[schedulerController] Tick loop started");
-    }
-  },
+class DynamicWidgetLoader {
+  constructor(componentManager = null) {
+    this.loadedWidgets = new Map();
+    this.moduleCache = new Map();
+    this.componentManager = componentManager;
+  }
 
   /**
-   * Stop the tick loop and persist immediately.
+   * Set ComponentManager instance for automatic widget registration
+   * @param {Object} manager - ComponentManager instance from @trops/dash-react
    */
-  stop() {
-    if (tickInterval) {
-      clearInterval(tickInterval);
-      tickInterval = null;
-    }
-    if (persistTimeout) {
-      clearTimeout(persistTimeout);
-      persistTimeout = null;
-    }
-    persistNow();
-    console.log("[schedulerController] Stopped");
-  },
+  setComponentManager(manager) {
+    this.componentManager = manager;
+  }
 
   /**
-   * Register or update a scheduled task.
-   *
-   * @param {Object} payload
-   * @param {string} payload.widgetId - widget instance UUID
-   * @param {string} payload.widgetName - component name
-   * @param {string} [payload.workspaceId]
-   * @param {string} payload.taskKey - key from .dash.js
-   * @param {string} payload.handler - handler function name
-   * @param {string} payload.displayName - human-readable name
-   * @param {string} payload.scheduleType - "interval" | "dayTime"
-   * @param {number} [payload.intervalMs] - for interval type
-   * @param {string[]} [payload.days] - for dayTime type
-   * @param {string} [payload.time] - for dayTime type (HH:mm)
-   * @param {boolean} [payload.enabled] - defaults to true
-   * @returns {{ success: boolean, taskId?: string, error?: string }}
+   * Load a widget from a local path
+   * @param {string} widgetName - Name of the widget (e.g., "MyFirstWidget")
+   * @param {string} widgetPath - Path to the widget directory
+   * @param {string} componentName - Name of the component file (e.g., "MyFirstWidgetWidget")
+   * @param {boolean} autoRegister - Automatically register with ComponentManager (if available)
+   * @returns {Promise<Object>} { component, config, registered }
    */
-  registerTask(payload) {
+  async loadWidget(widgetName, widgetPath, componentName, autoRegister = true) {
     try {
-      const {
-        widgetId,
-        widgetName,
-        workspaceId,
-        taskKey,
-        handler,
-        displayName,
-        scheduleType,
-        intervalMs,
-        days,
-        time,
-      } = payload;
+      const cacheKey = `${widgetName}:${componentName}`;
 
-      const taskId = `${widgetId}:${taskKey}`;
-      const existing = tasks.get(taskId);
+      if (this.loadedWidgets.has(cacheKey)) {
+        console.log(`[DynamicWidgetLoader] Loading ${widgetName} from cache`);
+        return this.loadedWidgets.get(cacheKey);
+      }
 
-      // Rate limit: max tasks per widget
-      if (!existing && countTasksForWidget(widgetId) >= MAX_TASKS_PER_WIDGET) {
-        return { success: false, error: "max_tasks_reached" };
+      console.log(
+        `[DynamicWidgetLoader] Loading widget: ${widgetName} from ${widgetPath}`,
+      );
+
+      const widgetsDir =
+        findWidgetsDir(widgetPath) || path$4.join(widgetPath, "widgets");
+      const componentPath = path$4.join(widgetsDir, `${componentName}.js`);
+      const configPath = path$4.join(widgetsDir, `${componentName}.dash.js`);
+
+      if (!fs$1.existsSync(componentPath)) {
+        throw new Error(`Component file not found: ${componentPath}`);
+      }
+      if (!fs$1.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
       }
 
-      const now = Date.now();
-      const task = {
-        taskId,
-        widgetId,
-        widgetName: widgetName || existing?.widgetName || "",
-        workspaceId: workspaceId || existing?.workspaceId || "",
-        taskKey,
-        handler: handler || existing?.handler || taskKey,
-        displayName: displayName || existing?.displayName || taskKey,
-        scheduleType: scheduleType || existing?.scheduleType || "interval",
-        intervalMs:
-          intervalMs !== undefined ? intervalMs : existing?.intervalMs || null,
-        days: days !== undefined ? days : existing?.days || null,
-        time: time !== undefined ? time : existing?.time || null,
-        enabled:
-          payload.enabled !== undefined
-            ? payload.enabled
-            : existing?.enabled !== undefined
-              ? existing.enabled
-              : true,
-        nextFireAt: 0,
-        lastFiredAt: existing?.lastFiredAt || null,
-        fireCount: existing?.fireCount || 0,
-        createdAt: existing?.createdAt || new Date().toISOString(),
+      const config = await this.loadConfigFile(configPath);
+
+      const component = {
+        path: componentPath,
+        name: componentName,
       };
 
-      // Compute next fire
-      task.nextFireAt = task.enabled ? computeNextFire(task, now) : 0;
+      let registered = false;
 
-      tasks.set(taskId, task);
-      debouncedPersist();
+      if (autoRegister && this.componentManager) {
+        try {
+          // Use scoped id as registration key if available,
+          // otherwise fall back to componentName
+          const registrationKey = config.id || componentName;
+          this.componentManager.registerWidget(config, registrationKey);
+          registered = true;
+          console.log(
+            `[DynamicWidgetLoader] ✓ Registered ${registrationKey} with ComponentManager`,
+          );
+        } catch (regError) {
+          console.warn(
+            `[DynamicWidgetLoader] Failed to register with ComponentManager:`,
+            regError,
+          );
+        }
+      }
 
-      console.log(
-        `[schedulerController] Registered: ${taskId} (${task.scheduleType})`,
-      );
+      const result = { component, config, registered };
+      this.loadedWidgets.set(cacheKey, result);
 
-      return { success: true, taskId };
+      return result;
     } catch (error) {
-      console.error("[schedulerController] Error registering task:", error);
-      return { success: false, error: error.message };
+      console.error(
+        `[DynamicWidgetLoader] Error loading widget ${widgetName}:`,
+        error,
+      );
+      throw error;
     }
-  },
+  }
 
   /**
-   * Remove a single task.
-   * @param {string} taskId
-   * @returns {{ success: boolean }}
+   * Load and parse a .dash.js configuration file
+   * @param {string} configPath - Path to the .dash.js file
+   * @returns {Promise<Object>} Configuration object
    */
-  removeTask(taskId) {
-    const deleted = tasks.delete(taskId);
-    if (deleted) {
-      debouncedPersist();
-      console.log(`[schedulerController] Removed: ${taskId}`);
-    }
-    return { success: deleted };
-  },
+  async loadConfigFile(configPath) {
+    try {
+      const source = fs$1.readFileSync(configPath, "utf8");
 
-  /**
-   * Remove all tasks for a widget instance.
-   * @param {string} widgetId
-   * @returns {{ success: boolean, count: number }}
-   */
-  removeTasks(widgetId) {
-    let count = 0;
-    for (const [taskId, task] of tasks) {
-      if (task.widgetId === widgetId) {
-        tasks.delete(taskId);
-        count++;
+      let exportMatch = source.match(/export\s+default\s+({[\s\S]*});?\s*$/);
+
+      // Handle variable export pattern: const x = {...}; export default x;
+      if (!exportMatch) {
+        const varExportMatch = source.match(
+          /export\s+default\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*;?\s*$/,
+        );
+        if (varExportMatch) {
+          const varName = varExportMatch[1];
+          const varDeclMatch = source.match(
+            new RegExp(
+              `(?:const|let|var)\\s+${varName}\\s*=\\s*({[\\s\\S]*?});\\s*(?:export\\s+default)`,
+            ),
+          );
+          if (varDeclMatch) {
+            exportMatch = varDeclMatch;
+          }
+        }
       }
-    }
-    if (count > 0) {
-      debouncedPersist();
-      pendingResults.delete(widgetId);
-    }
-    console.log(
-      `[schedulerController] Removed ${count} tasks for widget ${widgetId}`,
-    );
-    return { success: true, count };
-  },
 
-  /**
-   * Get all tasks for a widget instance.
-   * @param {string} widgetId
-   * @returns {Object[]}
-   */
-  getTasks(widgetId) {
-    const result = [];
-    for (const [, task] of tasks) {
-      if (task.widgetId === widgetId) {
-        result.push({ ...task });
+      if (!exportMatch) {
+        throw new Error("Could not find default export in config file");
       }
+
+      // Sanitize component references so vm.runInContext doesn't fail
+      // on unresolvable imports — replace component: SomeName with component: "SomeName"
+      const exportedObjectStr = exportMatch[1].replace(
+        /component\s*:\s*([A-Z][a-zA-Z0-9_$]*)/g,
+        'component: "$1"',
+      );
+
+      const context = vm.createContext({ module: { exports: {} } });
+      vm.runInContext(`module.exports = ${exportedObjectStr}`, context);
+
+      return context.module.exports;
+    } catch (error) {
+      console.error(`[DynamicWidgetLoader] Error loading config:`, error);
+      throw error;
     }
-    return result;
-  },
+  }
 
   /**
-   * Update a task's schedule configuration.
-   * @param {string} taskId
-   * @param {Object} updates
-   * @returns {{ success: boolean }}
+   * Discover available widgets in a directory
+   * @param {string} widgetPath - Path to search for widgets
+   * @returns {Array} List of available widget names
    */
-  updateTask(taskId, updates) {
-    const task = tasks.get(taskId);
-    if (!task) {
-      return { success: false, error: "task_not_found" };
-    }
-
-    const allowedFields = [
-      "scheduleType",
-      "intervalMs",
-      "days",
-      "time",
-      "displayName",
-      "enabled",
-    ];
-    for (const key of allowedFields) {
-      if (updates[key] !== undefined) {
-        task[key] = updates[key];
+  discoverWidgets(widgetPath) {
+    try {
+      const widgetsDir = findWidgetsDir(widgetPath);
+      if (!widgetsDir) {
+        return [];
       }
-    }
 
-    // Recompute next fire
-    if (task.enabled) {
-      task.nextFireAt = computeNextFire(task, Date.now());
-    } else {
-      task.nextFireAt = 0;
-    }
+      const files = fs$1.readdirSync(widgetsDir);
+      const widgets = new Set();
 
-    debouncedPersist();
-    console.log(`[schedulerController] Updated: ${taskId}`);
-    return { success: true };
-  },
+      files.forEach((file) => {
+        if (file.endsWith(".dash.js")) {
+          const componentName = file.replace(".dash.js", "");
+          widgets.add(componentName);
+        }
+      });
 
-  /**
-   * Enable a task.
-   * @param {string} taskId
-   * @returns {{ success: boolean }}
-   */
-  enableTask(taskId) {
-    const task = tasks.get(taskId);
-    if (!task) return { success: false, error: "task_not_found" };
-    task.enabled = true;
-    task.nextFireAt = computeNextFire(task, Date.now());
-    debouncedPersist();
-    console.log(`[schedulerController] Enabled: ${taskId}`);
-    return { success: true };
-  },
+      return Array.from(widgets);
+    } catch (error) {
+      console.error(`[DynamicWidgetLoader] Error discovering widgets:`, error);
+      return [];
+    }
+  }
 
   /**
-   * Disable a task.
-   * @param {string} taskId
-   * @returns {{ success: boolean }}
+   * Clear cache
    */
-  disableTask(taskId) {
-    const task = tasks.get(taskId);
-    if (!task) return { success: false, error: "task_not_found" };
-    task.enabled = false;
-    task.nextFireAt = 0;
-    debouncedPersist();
-    console.log(`[schedulerController] Disabled: ${taskId}`);
-    return { success: true };
-  },
+  clearCache() {
+    this.loadedWidgets.clear();
+    this.moduleCache.clear();
+  }
+}
 
-  /**
-   * Drain pending fire results for a widget.
-   * @param {string} widgetId
-   * @returns {Object[]}
-   */
-  getPendingResults(widgetId) {
-    const queue = pendingResults.get(widgetId) || [];
-    pendingResults.delete(widgetId);
-    return queue;
-  },
-
-  /**
-   * Handle system suspend — stop tick loop.
-   */
-  handleSuspend() {
-    if (tickInterval) {
-      clearInterval(tickInterval);
-      tickInterval = null;
-      console.log("[schedulerController] Suspended (tick stopped)");
-    }
-  },
-
-  /**
-   * Handle system resume — fire missed tasks, restart tick.
-   */
-  handleResume() {
-    const now = Date.now();
-    for (const [, task] of tasks) {
-      if (task.enabled && task.nextFireAt && task.nextFireAt <= now) {
-        fireTask(task);
-        task.nextFireAt = computeNextFire(task, now);
-        task.lastFiredAt = now;
-        task.fireCount = (task.fireCount || 0) + 1;
-      }
-    }
-    debouncedPersist();
-    if (!tickInterval) {
-      tickInterval = setInterval(tick, 1000);
-      console.log("[schedulerController] Resumed (tick restarted)");
-    }
-  },
+const dynamicWidgetLoader$1 = new DynamicWidgetLoader();
 
-  /**
-   * Remove all tasks for a widget name (used on widget uninstall).
-   * @param {string} widgetName - component name
-   */
-  cleanupWidget(widgetName) {
-    let count = 0;
-    for (const [taskId, task] of tasks) {
-      if (task.widgetName === widgetName) {
-        tasks.delete(taskId);
-        pendingResults.delete(task.widgetId);
-        count++;
-      }
-    }
-    if (count > 0) {
-      debouncedPersist();
-      console.log(
-        `[schedulerController] Cleaned up ${count} tasks for widget "${widgetName}"`,
-      );
-    }
-  },
-};
+dynamicWidgetLoader$2.exports = DynamicWidgetLoader;
+dynamicWidgetLoader$2.exports.dynamicWidgetLoader = dynamicWidgetLoader$1;
 
-var schedulerController_1 = schedulerController$2;
+var dynamicWidgetLoaderExports = dynamicWidgetLoader$2.exports;
 
 /**
- * Widget Registry System
- *
- * Manages widget discovery, download, and dynamic loading
- * Widgets are expected to have:
- * - package.json (or dash.json) with metadata
- * - widgets/ folder containing [WidgetName].js and [WidgetName].dash.js
+ * schedulerController.js
  *
- * Files are stored in the Electron app's userData directory:
- * - macOS: ~/Library/Application Support/[appName]/
- * - Windows: %APPDATA%/[appName]/
- * - Linux: ~/.config/[appName]/
+ * Main process controller for widget scheduled tasks.
+ * Manages a tick loop (1s resolution), persistence (electron-store),
+ * and dispatching task-fired events to renderer windows.
  */
 
-(function (module) {
-	const fs = require$$0$3;
-	const path = require$$1$2;
-	const os = require$$2$4;
-	const AdmZip = require$$3$4;
-	const { fileURLToPath } = require$$4$1;
-	const { app, ipcMain, BrowserWindow } = require$$0$2;
-	const { dynamicWidgetLoader } = dynamicWidgetLoaderExports;
-	const { compileWidget, findWidgetsDir } = widgetCompiler$1;
+const Store$1 = require$$1$1;
+const { Cron } = require$$1$5;
 
-	let WIDGETS_CACHE_DIR = null;
-	let REGISTRY_CONFIG_FILE = null;
+const store$2 = new Store$1({ name: "dash-scheduler" });
 
-	/**
-	 * Validate ZIP entries to prevent path traversal attacks.
-	 * Rejects entries containing '..' segments or absolute paths that would
-	 * write outside the target extraction directory.
-	 * @param {AdmZip} zip - AdmZip instance
-	 * @param {string} targetDir - Intended extraction directory
-	 * @throws {Error} If any entry would escape the target directory
-	 */
-	function validateZipEntries(zip, targetDir) {
-	  const resolvedTarget = path.resolve(targetDir);
-	  for (const entry of zip.getEntries()) {
-	    const entryPath = entry.entryName;
-	    // Reject entries with '..' path segments
-	    if (
-	      entryPath.split("/").includes("..") ||
-	      entryPath.split("\\").includes("..")
-	    ) {
-	      throw new Error(
-	        `Malicious ZIP entry rejected (path traversal): ${entryPath}`,
-	      );
-	    }
-	    // Reject absolute paths
-	    if (path.isAbsolute(entryPath)) {
-	      throw new Error(
-	        `Malicious ZIP entry rejected (absolute path): ${entryPath}`,
-	      );
-	    }
-	    // Final check: resolved path must be within target directory
-	    const resolvedEntry = path.resolve(resolvedTarget, entryPath);
-	    if (
-	      !resolvedEntry.startsWith(resolvedTarget + path.sep) &&
-	      resolvedEntry !== resolvedTarget
-	    ) {
-	      throw new Error(
-	        `Malicious ZIP entry rejected (escapes target): ${entryPath}`,
-	      );
-	    }
-	  }
-	}
+// --- In-memory state ---
+const tasks = new Map(); // taskId -> task object
+const pendingResults = new Map(); // widgetId -> Array<{ taskId, taskKey, firedAt }>
 
-	/**
-	 * Initialize registry with custom path or default userData path
-	 * @param {string} customPath - Optional custom path for storing widgets
-	 */
-	function initializeRegistry(customPath = null) {
-	  if (customPath) {
-	    WIDGETS_CACHE_DIR = path.join(customPath, "widgets");
-	  } else {
-	    WIDGETS_CACHE_DIR = path.join(app.getPath("userData"), "widgets");
-	  }
-	  REGISTRY_CONFIG_FILE = path.join(WIDGETS_CACHE_DIR, "registry.json");
-	  console.log(`[WidgetRegistry] Using storage path: ${WIDGETS_CACHE_DIR}`);
-	}
+const MAX_TASKS_PER_WIDGET = 20;
+const MAX_PENDING_PER_WIDGET = 100;
+const PERSIST_DEBOUNCE_MS = 30_000;
 
-	class WidgetRegistry {
-	  constructor(componentManager = null, customPath = null) {
-	    if (!WIDGETS_CACHE_DIR) {
-	      initializeRegistry(customPath);
-	    }
+let tickInterval = null;
+let persistTimeout = null;
+let deps = {
+  getWindows: null,
+  notificationController: null,
+  getMainWindow: null,
+};
 
-	    this.widgets = new Map();
-	    this.componentManager = componentManager;
-	    this.ensureCacheDir();
-	    this.loadRegistry();
-	  }
+// --- Day name to cron day number ---
+const DAY_MAP = {
+  sun: 0,
+  mon: 1,
+  tue: 2,
+  wed: 3,
+  thu: 4,
+  fri: 5,
+  sat: 6,
+};
 
-	  /**
-	   * Static method to initialize registry with custom path
-	   * Call this early in your app startup (e.g., in main.js)
-	   * @param {string} customPath - Custom path for storing widgets/configs
-	   */
-	  static initialize(customPath = null) {
-	    initializeRegistry(customPath);
-	  }
+/**
+ * Build a cron expression from days + time for use with croner.
+ * @param {string[]} days - ["mon","wed","fri"] or ["every"]
+ * @param {string} time - "09:00" (HH:mm)
+ * @returns {string} cron expression
+ */
+function buildCronExpression(days, time) {
+  const [hours, minutes] = time.split(":").map(Number);
+  if (days.includes("every")) {
+    return `${minutes} ${hours} * * *`;
+  }
+  const dayNums = days.map((d) => DAY_MAP[d]).filter((n) => n !== undefined);
+  return `${minutes} ${hours} * * ${dayNums.join(",")}`;
+}
 
-	  /**
-	   * Set ComponentManager instance for automatic widget registration
-	   * @param {Object} manager - ComponentManager instance from @trops/dash-react
-	   */
-	  setComponentManager(manager) {
-	    this.componentManager = manager;
-	  }
+/**
+ * Compute the next fire timestamp for a task.
+ * @param {Object} task
+ * @param {number} now - current timestamp in ms
+ * @returns {number} next fire timestamp in ms
+ */
+function computeNextFire(task, now) {
+  if (task.scheduleType === "interval") {
+    return now + (task.intervalMs || 60000);
+  }
 
-	  /**
-	   * Ensure cache directory exists
-	   */
-	  ensureCacheDir() {
-	    if (!fs.existsSync(WIDGETS_CACHE_DIR)) {
-	      fs.mkdirSync(WIDGETS_CACHE_DIR, { recursive: true });
-	    }
-	  }
+  if (task.scheduleType === "dayTime" && task.days && task.time) {
+    try {
+      const cronExpr = buildCronExpression(task.days, task.time);
+      const job = new Cron(cronExpr);
+      const next = job.nextRun();
+      if (next) {
+        return next.getTime();
+      }
+    } catch (err) {
+      console.error(
+        `[schedulerController] Error computing next fire for ${task.taskId}:`,
+        err,
+      );
+    }
+    // Fallback: 1 hour from now
+    return now + 3600000;
+  }
 
-	  /**
-	   * Load registry from disk
-	   */
-	  loadRegistry() {
-	    try {
-	      if (fs.existsSync(REGISTRY_CONFIG_FILE)) {
-	        const data = fs.readFileSync(REGISTRY_CONFIG_FILE, "utf8");
-	        const registryData = JSON.parse(data);
-	        this.widgets = new Map(registryData.widgets || []);
-	        console.log(
-	          `[WidgetRegistry] Loaded ${this.widgets.size} widgets from cache`,
-	        );
-	      }
-	    } catch (error) {
-	      console.error("[WidgetRegistry] Error loading registry:", error);
-	    }
-	  }
-
-	  /**
-	   * Save registry to disk
-	   */
-	  saveRegistry() {
-	    try {
-	      const registryData = {
-	        lastUpdated: new Date().toISOString(),
-	        widgets: Array.from(this.widgets.entries()),
-	      };
-	      fs.writeFileSync(
-	        REGISTRY_CONFIG_FILE,
-	        JSON.stringify(registryData, null, 2),
-	      );
-	    } catch (error) {
-	      console.error("[WidgetRegistry] Error saving registry:", error);
-	    }
-	  }
-
-	  /**
-	   * Resolve download URL from partial template or full URL
-	   * Supports placeholders: {version}, {name}
-	   *
-	   * Examples:
-	   * - Full URL: "https://github.com/user/widget/releases/download/v1.0.0/widget.zip"
-	   * - Template: "https://github.com/user/weather-widget/releases/download/v{version}/weather-widget.zip"
-	   * - Partial: "https://github.com/user/weather-widget/releases/download/" (auto-generates v{version}/{name}.zip)
-	   *
-	   * @param {string} urlTemplate - URL template or partial URL
-	   * @param {string} version - Widget version (e.g., "1.0.0")
-	   * @param {string} name - Widget name (e.g., "weather-widget")
-	   * @returns {string} Resolved download URL
-	   */
-	  resolveDownloadUrl(urlTemplate, version, name) {
-	    if (!urlTemplate) return null;
-
-	    if (urlTemplate.endsWith("/")) {
-	      return `${urlTemplate}v${version}/${name}.zip`;
-	    }
-
-	    let url = urlTemplate;
-	    url = url.replace("{version}", version);
-	    url = url.replace("{name}", name);
-	    return url;
-	  }
-
-	  /**
-	   * Determine if the input points to a local path (file:// or filesystem path)
-	   * @param {string} input - URL or path
-	   * @returns {boolean}
-	   */
-	  isLocalSource(input) {
-	    if (!input) return false;
-	    if (input.startsWith("file://")) return true;
-	    if (input.startsWith("http://") || input.startsWith("https://"))
-	      return false;
-	    const resolvedPath = this.resolveLocalPath(input);
-	    return fs.existsSync(resolvedPath);
-	  }
-
-	  /**
-	   * Normalize a local path (supports file:// and ~)
-	   * @param {string} input - Local path or file:// URL
-	   * @returns {string}
-	   */
-	  resolveLocalPath(input) {
-	    if (input.startsWith("file://")) {
-	      return fileURLToPath(input);
-	    }
-	    if (input.startsWith("~")) {
-	      return path.join(os.homedir(), input.slice(1));
-	    }
-	    return path.resolve(input);
-	  }
+  // Unknown schedule type — default 1 hour
+  return now + 3600000;
+}
 
-	  /**
-	   * Install a widget from a local ZIP file or folder path
-	   * @param {string} widgetName - Name of the widget
-	   * @param {string} localPath - Path to ZIP file or widget folder
-	   * @param {boolean} autoRegister - Automatically register with ComponentManager
-	   * @param {string} dashConfigPath - Optional: path to dash.json metadata file
-	   * @returns {Promise<Object>} Widget configuration
-	   */
-	  async installFromLocalPath(
-	    widgetName,
-	    localPath,
-	    autoRegister = true,
-	    dashConfigPath = null,
-	  ) {
-	    try {
-	      const resolvedPath = this.resolveLocalPath(localPath);
+/**
+ * Fire a task: broadcast to renderer windows, queue pending, send notification if no windows.
+ */
+function fireTask(task) {
+  const payload = {
+    taskId: task.taskId,
+    widgetId: task.widgetId,
+    taskKey: task.taskKey,
+    handler: task.handler,
+    firedAt: Date.now(),
+  };
 
-	      if (!fs.existsSync(resolvedPath)) {
-	        throw new Error(`Local path not found: ${resolvedPath}`);
-	      }
+  console.log(
+    `[schedulerController] Fired: ${task.widgetName}.${task.taskKey} (${task.displayName})`,
+  );
 
-	      const widgetPath = path.join(WIDGETS_CACHE_DIR, widgetName);
+  // Add to pending results queue
+  let queue = pendingResults.get(task.widgetId) || [];
+  queue.push({
+    taskId: task.taskId,
+    taskKey: task.taskKey,
+    firedAt: payload.firedAt,
+  });
+  if (queue.length > MAX_PENDING_PER_WIDGET) {
+    queue = queue.slice(-MAX_PENDING_PER_WIDGET);
+  }
+  pendingResults.set(task.widgetId, queue);
 
-	      if (fs.existsSync(widgetPath)) {
-	        fs.rmSync(widgetPath, { recursive: true });
-	      }
+  // Broadcast to all windows
+  const windows = deps.getWindows ? deps.getWindows() : [];
+  if (windows.length > 0) {
+    for (const win of windows) {
+      if (!win.isDestroyed()) {
+        win.webContents.send("scheduler:task-fired", payload);
+      }
+    }
+  } else {
+    // No windows open — send native OS notification
+    if (deps.notificationController && deps.getMainWindow) {
+      deps.notificationController.send(deps.getMainWindow(), {
+        widgetName: task.widgetName,
+        widgetId: task.widgetId,
+        workspaceId: task.workspaceId || "",
+        type: "scheduled-task",
+        title: task.displayName || task.taskKey,
+        body: `Scheduled task "${task.displayName}" fired`,
+        silent: false,
+      });
+    }
+  }
+}
 
-	      const isDirectory = fs.statSync(resolvedPath).isDirectory();
-	      if (isDirectory) {
-	        fs.cpSync(resolvedPath, widgetPath, { recursive: true });
-	      } else if (resolvedPath.endsWith(".zip")) {
-	        const zip = new AdmZip(resolvedPath);
-	        validateZipEntries(zip, widgetPath);
-	        zip.extractAllTo(widgetPath, true);
-	      } else {
-	        throw new Error(`Unsupported local source type: ${resolvedPath}`);
-	      }
+/**
+ * Main tick — runs every 1s, checks all enabled tasks.
+ */
+function tick() {
+  const now = Date.now();
+  for (const [, task] of tasks) {
+    if (!task.enabled || !task.nextFireAt || task.nextFireAt > now) continue;
+    fireTask(task);
+    task.nextFireAt = computeNextFire(task, now);
+    task.lastFiredAt = now;
+    task.fireCount = (task.fireCount || 0) + 1;
+  }
+  debouncedPersist();
+}
 
-	      let config = await this.loadWidgetConfig(widgetName, widgetPath);
+/**
+ * Persist tasks to electron-store (debounced).
+ */
+function debouncedPersist() {
+  if (persistTimeout) return;
+  persistTimeout = setTimeout(() => {
+    persistTimeout = null;
+    persistNow();
+  }, PERSIST_DEBOUNCE_MS);
+}
 
-	      if (dashConfigPath) {
-	        const configPath = this.resolveLocalPath(dashConfigPath);
-	        if (fs.existsSync(configPath)) {
-	          const dashConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
-	          config = { ...config, ...dashConfig };
-	        }
-	      }
+function persistNow() {
+  try {
+    const data = {};
+    for (const [taskId, task] of tasks) {
+      data[taskId] = { ...task };
+    }
+    store$2.set("tasks", data);
+  } catch (err) {
+    console.error("[schedulerController] Error persisting tasks:", err);
+  }
+}
 
-	      this.registerWidget(widgetName, config, widgetPath, false);
+/**
+ * Load persisted tasks from electron-store.
+ */
+function loadFromStore() {
+  try {
+    const data = store$2.get("tasks", {});
+    const now = Date.now();
+    for (const [taskId, task] of Object.entries(data)) {
+      // Recompute nextFireAt if it's in the past
+      if (task.nextFireAt && task.nextFireAt <= now && task.enabled) {
+        task.nextFireAt = computeNextFire(task, now);
+      }
+      tasks.set(taskId, task);
+    }
+    console.log(`[schedulerController] Loaded ${tasks.size} tasks from store`);
+  } catch (err) {
+    console.error("[schedulerController] Error loading tasks:", err);
+  }
+}
 
-	      if (autoRegister) {
-	        await this.loadWidgetComponents(widgetName, widgetPath);
-	      }
+/**
+ * Count tasks for a given widget instance.
+ */
+function countTasksForWidget(widgetId) {
+  let count = 0;
+  for (const [, task] of tasks) {
+    if (task.widgetId === widgetId) count++;
+  }
+  return count;
+}
 
-	      return config;
-	    } catch (error) {
-	      console.error(
-	        `[WidgetRegistry] Error installing local widget ${widgetName}:`,
-	        error,
-	      );
-	      throw error;
-	    }
-	  }
+const schedulerController$2 = {
+  /**
+   * Wire dependencies from the Electron main process.
+   */
+  init({ getWindows, notificationController, getMainWindow }) {
+    deps.getWindows = getWindows;
+    deps.notificationController = notificationController;
+    deps.getMainWindow = getMainWindow;
+  },
 
-	  /**
-	   * Check if a directory looks like a valid widget folder.
-	   * A directory is a widget if it has:
-	   * - package.json or dash.json at its root, OR
-	   * - A widgets/ subdirectory containing at least one .dash.js file
-	   * @param {string} dirPath - Path to the directory
-	   * @returns {boolean}
-	   */
-	  isWidgetFolder(dirPath) {
-	    if (fs.existsSync(path.join(dirPath, "package.json"))) return true;
-	    if (fs.existsSync(path.join(dirPath, "dash.json"))) return true;
+  /**
+   * Start the tick loop and load persisted tasks.
+   */
+  start() {
+    loadFromStore();
+    if (!tickInterval) {
+      tickInterval = setInterval(tick, 1000);
+      console.log("[schedulerController] Tick loop started");
+    }
+  },
 
-	    const widgetsDir = path.join(dirPath, "widgets");
-	    if (fs.existsSync(widgetsDir) && fs.statSync(widgetsDir).isDirectory()) {
-	      const files = fs.readdirSync(widgetsDir);
-	      if (files.some((f) => f.endsWith(".dash.js"))) return true;
-	    }
+  /**
+   * Stop the tick loop and persist immediately.
+   */
+  stop() {
+    if (tickInterval) {
+      clearInterval(tickInterval);
+      tickInterval = null;
+    }
+    if (persistTimeout) {
+      clearTimeout(persistTimeout);
+      persistTimeout = null;
+    }
+    persistNow();
+    console.log("[schedulerController] Stopped");
+  },
 
-	    return false;
-	  }
+  /**
+   * Register or update a scheduled task.
+   *
+   * @param {Object} payload
+   * @param {string} payload.widgetId - widget instance UUID
+   * @param {string} payload.widgetName - component name
+   * @param {string} [payload.workspaceId]
+   * @param {string} payload.taskKey - key from .dash.js
+   * @param {string} payload.handler - handler function name
+   * @param {string} payload.displayName - human-readable name
+   * @param {string} payload.scheduleType - "interval" | "dayTime"
+   * @param {number} [payload.intervalMs] - for interval type
+   * @param {string[]} [payload.days] - for dayTime type
+   * @param {string} [payload.time] - for dayTime type (HH:mm)
+   * @param {boolean} [payload.enabled] - defaults to true
+   * @returns {{ success: boolean, taskId?: string, error?: string }}
+   */
+  registerTask(payload) {
+    try {
+      const {
+        widgetId,
+        widgetName,
+        workspaceId,
+        taskKey,
+        handler,
+        displayName,
+        scheduleType,
+        intervalMs,
+        days,
+        time,
+      } = payload;
 
-	  /**
-	   * Register all widgets found in a local folder.
-	   *
-	   * Smart detection:
-	   * 1. If the selected folder itself is a widget, install it directly.
-	   * 2. Otherwise iterate subdirectories, skipping non-widget dirs.
-	   *
-	   * @param {string} folderPath - Path containing widget folders (or a single widget folder)
-	   * @param {boolean} autoRegister - Automatically register with ComponentManager
-	   * @returns {Promise<Array>} Registered widgets (with optional `mode` and `skipped` metadata)
-	   */
-	  async registerWidgetsFromFolder(folderPath, autoRegister = true) {
-	    const SKIP_DIRS = new Set(["node_modules", "dist", "__MACOSX", ".git"]);
+      const taskId = `${widgetId}:${taskKey}`;
+      const existing = tasks.get(taskId);
 
-	    try {
-	      const resolvedPath = this.resolveLocalPath(folderPath);
-	      if (!fs.existsSync(resolvedPath)) {
-	        throw new Error(`Folder not found: ${resolvedPath}`);
-	      }
-	      if (!fs.statSync(resolvedPath).isDirectory()) {
-	        throw new Error(`Path is not a directory: ${resolvedPath}`);
-	      }
+      // Rate limit: max tasks per widget
+      if (!existing && countTasksForWidget(widgetId) >= MAX_TASKS_PER_WIDGET) {
+        return { success: false, error: "max_tasks_reached" };
+      }
 
-	      // 1. Check if the selected folder itself is a widget
-	      if (this.isWidgetFolder(resolvedPath)) {
-	        const widgetName = path.basename(resolvedPath);
-	        const config = await this.installFromLocalPath(
-	          widgetName,
-	          resolvedPath,
-	          autoRegister,
-	        );
-	        return [
-	          {
-	            name: widgetName,
-	            path: resolvedPath,
-	            ...config,
-	            mode: "single",
-	          },
-	        ];
-	      }
+      const now = Date.now();
+      const task = {
+        taskId,
+        widgetId,
+        widgetName: widgetName || existing?.widgetName || "",
+        workspaceId: workspaceId || existing?.workspaceId || "",
+        taskKey,
+        handler: handler || existing?.handler || taskKey,
+        displayName: displayName || existing?.displayName || taskKey,
+        scheduleType: scheduleType || existing?.scheduleType || "interval",
+        intervalMs:
+          intervalMs !== undefined ? intervalMs : existing?.intervalMs || null,
+        days: days !== undefined ? days : existing?.days || null,
+        time: time !== undefined ? time : existing?.time || null,
+        enabled:
+          payload.enabled !== undefined
+            ? payload.enabled
+            : existing?.enabled !== undefined
+              ? existing.enabled
+              : true,
+        nextFireAt: 0,
+        lastFiredAt: existing?.lastFiredAt || null,
+        fireCount: existing?.fireCount || 0,
+        createdAt: existing?.createdAt || new Date().toISOString(),
+      };
 
-	      // 2. Iterate subdirectories with filtering
-	      const entries = fs.readdirSync(resolvedPath, {
-	        withFileTypes: true,
-	      });
-	      const results = [];
-	      let skipped = 0;
+      // Compute next fire
+      task.nextFireAt = task.enabled ? computeNextFire(task, now) : 0;
 
-	      for (const entry of entries) {
-	        if (!entry.isDirectory()) continue;
+      tasks.set(taskId, task);
+      debouncedPersist();
 
-	        // Skip hidden dirs and known non-widget dirs
-	        if (entry.name.startsWith(".") || SKIP_DIRS.has(entry.name)) {
-	          skipped++;
-	          continue;
-	        }
+      console.log(
+        `[schedulerController] Registered: ${taskId} (${task.scheduleType})`,
+      );
 
-	        const widgetPath = path.join(resolvedPath, entry.name);
+      return { success: true, taskId };
+    } catch (error) {
+      console.error("[schedulerController] Error registering task:", error);
+      return { success: false, error: error.message };
+    }
+  },
 
-	        if (!this.isWidgetFolder(widgetPath)) {
-	          skipped++;
-	          continue;
-	        }
+  /**
+   * Remove a single task.
+   * @param {string} taskId
+   * @returns {{ success: boolean }}
+   */
+  removeTask(taskId) {
+    const deleted = tasks.delete(taskId);
+    if (deleted) {
+      debouncedPersist();
+      console.log(`[schedulerController] Removed: ${taskId}`);
+    }
+    return { success: deleted };
+  },
 
-	        const config = await this.loadWidgetConfig(entry.name, widgetPath);
-	        this.registerWidget(entry.name, config, widgetPath, false);
+  /**
+   * Remove all tasks for a widget instance.
+   * @param {string} widgetId
+   * @returns {{ success: boolean, count: number }}
+   */
+  removeTasks(widgetId) {
+    let count = 0;
+    for (const [taskId, task] of tasks) {
+      if (task.widgetId === widgetId) {
+        tasks.delete(taskId);
+        count++;
+      }
+    }
+    if (count > 0) {
+      debouncedPersist();
+      pendingResults.delete(widgetId);
+    }
+    console.log(
+      `[schedulerController] Removed ${count} tasks for widget ${widgetId}`,
+    );
+    return { success: true, count };
+  },
 
-	        if (autoRegister) {
-	          await this.loadWidgetComponents(entry.name, widgetPath);
-	        }
+  /**
+   * Get all tasks for a widget instance.
+   * @param {string} widgetId
+   * @returns {Object[]}
+   */
+  getTasks(widgetId) {
+    const result = [];
+    for (const [, task] of tasks) {
+      if (task.widgetId === widgetId) {
+        result.push({ ...task });
+      }
+    }
+    return result;
+  },
 
-	        results.push({
-	          name: entry.name,
-	          path: widgetPath,
-	          ...config,
-	        });
-	      }
+  /**
+   * Update a task's schedule configuration.
+   * @param {string} taskId
+   * @param {Object} updates
+   * @returns {{ success: boolean }}
+   */
+  updateTask(taskId, updates) {
+    const task = tasks.get(taskId);
+    if (!task) {
+      return { success: false, error: "task_not_found" };
+    }
 
-	      // Attach skipped count as metadata on the array
-	      results.skipped = skipped;
-	      return results;
-	    } catch (error) {
-	      console.error(
-	        "[WidgetRegistry] Error registering widgets from folder:",
-	        error,
-	      );
-	      throw error;
-	    }
-	  }
+    const allowedFields = [
+      "scheduleType",
+      "intervalMs",
+      "days",
+      "time",
+      "displayName",
+      "enabled",
+    ];
+    for (const key of allowedFields) {
+      if (updates[key] !== undefined) {
+        task[key] = updates[key];
+      }
+    }
 
-	  /**
-	   * Download widget from URL (ZIP file)
-	   * @param {string} widgetName - Name of the widget
-	   * @param {string} downloadUrl - URL to download ZIP file from (supports templates and partial URLs)
-	   * @param {string} dashConfigUrl - Optional: URL to dash.json metadata file
-	   * @param {boolean} autoRegister - Automatically register with ComponentManager
-	   * @returns {Promise<Object>} Widget configuration
-	   */
-	  async downloadWidget(
-	    widgetName,
-	    downloadUrl,
-	    dashConfigUrl = null,
-	    autoRegister = true,
-	  ) {
-	    try {
-	      if (this.isLocalSource(downloadUrl)) {
-	        return this.installFromLocalPath(
-	          widgetName,
-	          downloadUrl,
-	          autoRegister,
-	          dashConfigUrl,
-	        );
-	      }
-	      // Enforce HTTPS to prevent MITM attacks on widget downloads
-	      const parsedUrl = new URL(downloadUrl);
-	      if (parsedUrl.protocol !== "https:") {
-	        throw new Error(
-	          `Widget downloads must use HTTPS. Refusing to fetch: ${downloadUrl}`,
-	        );
-	      }
+    // Recompute next fire
+    if (task.enabled) {
+      task.nextFireAt = computeNextFire(task, Date.now());
+    } else {
+      task.nextFireAt = 0;
+    }
 
-	      console.log(
-	        `[WidgetRegistry] Downloading widget: ${widgetName} from ${downloadUrl}`,
-	      );
+    debouncedPersist();
+    console.log(`[schedulerController] Updated: ${taskId}`);
+    return { success: true };
+  },
 
-	      const response = await fetch(downloadUrl);
-	      if (!response.ok)
-	        throw new Error(`Failed to fetch: ${response.statusText}`);
+  /**
+   * Enable a task.
+   * @param {string} taskId
+   * @returns {{ success: boolean }}
+   */
+  enableTask(taskId) {
+    const task = tasks.get(taskId);
+    if (!task) return { success: false, error: "task_not_found" };
+    task.enabled = true;
+    task.nextFireAt = computeNextFire(task, Date.now());
+    debouncedPersist();
+    console.log(`[schedulerController] Enabled: ${taskId}`);
+    return { success: true };
+  },
 
-	      const buffer = await response.arrayBuffer();
-	      const zip = new AdmZip(Buffer.from(buffer));
+  /**
+   * Disable a task.
+   * @param {string} taskId
+   * @returns {{ success: boolean }}
+   */
+  disableTask(taskId) {
+    const task = tasks.get(taskId);
+    if (!task) return { success: false, error: "task_not_found" };
+    task.enabled = false;
+    task.nextFireAt = 0;
+    debouncedPersist();
+    console.log(`[schedulerController] Disabled: ${taskId}`);
+    return { success: true };
+  },
 
-	      const widgetPath = path.join(WIDGETS_CACHE_DIR, widgetName);
+  /**
+   * Drain pending fire results for a widget.
+   * @param {string} widgetId
+   * @returns {Object[]}
+   */
+  getPendingResults(widgetId) {
+    const queue = pendingResults.get(widgetId) || [];
+    pendingResults.delete(widgetId);
+    return queue;
+  },
 
-	      if (fs.existsSync(widgetPath)) {
-	        fs.rmSync(widgetPath, { recursive: true });
-	      }
+  /**
+   * Handle system suspend — stop tick loop.
+   */
+  handleSuspend() {
+    if (tickInterval) {
+      clearInterval(tickInterval);
+      tickInterval = null;
+      console.log("[schedulerController] Suspended (tick stopped)");
+    }
+  },
 
-	      validateZipEntries(zip, widgetPath);
-	      zip.extractAllTo(widgetPath, true);
-	      console.log(`[WidgetRegistry] Extracted widget to: ${widgetPath}`);
+  /**
+   * Handle system resume — fire missed tasks, restart tick.
+   */
+  handleResume() {
+    const now = Date.now();
+    for (const [, task] of tasks) {
+      if (task.enabled && task.nextFireAt && task.nextFireAt <= now) {
+        fireTask(task);
+        task.nextFireAt = computeNextFire(task, now);
+        task.lastFiredAt = now;
+        task.fireCount = (task.fireCount || 0) + 1;
+      }
+    }
+    debouncedPersist();
+    if (!tickInterval) {
+      tickInterval = setInterval(tick, 1000);
+      console.log("[schedulerController] Resumed (tick restarted)");
+    }
+  },
+
+  /**
+   * Remove all tasks for a widget name (used on widget uninstall).
+   * @param {string} widgetName - component name
+   */
+  cleanupWidget(widgetName) {
+    let count = 0;
+    for (const [taskId, task] of tasks) {
+      if (task.widgetName === widgetName) {
+        tasks.delete(taskId);
+        pendingResults.delete(task.widgetId);
+        count++;
+      }
+    }
+    if (count > 0) {
+      debouncedPersist();
+      console.log(
+        `[schedulerController] Cleaned up ${count} tasks for widget "${widgetName}"`,
+      );
+    }
+  },
+};
 
-	      let config = await this.loadWidgetConfig(widgetName, widgetPath);
+var schedulerController_1 = schedulerController$2;
 
-	      if (dashConfigUrl) {
-	        const dashConfig = await this.fetchJSON(dashConfigUrl);
-	        config = { ...config, ...dashConfig };
-	      }
+/**
+ * Widget Registry System
+ *
+ * Manages widget discovery, download, and dynamic loading
+ * Widgets are expected to have:
+ * - package.json (or dash.json) with metadata
+ * - widgets/ folder containing [WidgetName].js and [WidgetName].dash.js
+ *
+ * Files are stored in the Electron app's userData directory:
+ * - macOS: ~/Library/Application Support/[appName]/
+ * - Windows: %APPDATA%/[appName]/
+ * - Linux: ~/.config/[appName]/
+ */
 
-	      this.registerWidget(widgetName, config, widgetPath, false);
+(function (module) {
+	const fs = require$$0$3;
+	const path = require$$1$2;
+	const os = require$$2$4;
+	const AdmZip = require$$3$4;
+	const { fileURLToPath } = require$$4$1;
+	const { app, ipcMain, BrowserWindow } = require$$0$2;
+	const { dynamicWidgetLoader } = dynamicWidgetLoaderExports;
+	const { compileWidget, findWidgetsDir } = widgetCompiler$1;
 
-	      if (autoRegister) {
-	        await this.loadWidgetComponents(widgetName, widgetPath);
-	      }
+	let WIDGETS_CACHE_DIR = null;
+	let REGISTRY_CONFIG_FILE = null;
 
-	      return config;
-	    } catch (error) {
-	      console.error(
-	        `[WidgetRegistry] Error downloading widget ${widgetName}:`,
-	        error,
+	/**
+	 * Validate ZIP entries to prevent path traversal attacks.
+	 * Rejects entries containing '..' segments or absolute paths that would
+	 * write outside the target extraction directory.
+	 * @param {AdmZip} zip - AdmZip instance
+	 * @param {string} targetDir - Intended extraction directory
+	 * @throws {Error} If any entry would escape the target directory
+	 */
+	function validateZipEntries(zip, targetDir) {
+	  const resolvedTarget = path.resolve(targetDir);
+	  for (const entry of zip.getEntries()) {
+	    const entryPath = entry.entryName;
+	    // Reject entries with '..' path segments
+	    if (
+	      entryPath.split("/").includes("..") ||
+	      entryPath.split("\\").includes("..")
+	    ) {
+	      throw new Error(
+	        `Malicious ZIP entry rejected (path traversal): ${entryPath}`,
+	      );
+	    }
+	    // Reject absolute paths
+	    if (path.isAbsolute(entryPath)) {
+	      throw new Error(
+	        `Malicious ZIP entry rejected (absolute path): ${entryPath}`,
+	      );
+	    }
+	    // Final check: resolved path must be within target directory
+	    const resolvedEntry = path.resolve(resolvedTarget, entryPath);
+	    if (
+	      !resolvedEntry.startsWith(resolvedTarget + path.sep) &&
+	      resolvedEntry !== resolvedTarget
+	    ) {
+	      throw new Error(
+	        `Malicious ZIP entry rejected (escapes target): ${entryPath}`,
 	      );
-	      throw error;
 	    }
 	  }
+	}
 
-	  /**
-	   * Load widget configuration from local path
-	   * @param {string} widgetName - Name of the widget
-	   * @param {string} widgetPath - Path to widget directory
-	   * @returns {Promise<Object>} Widget configuration
-	   */
-	  async loadWidgetConfig(widgetName, widgetPath) {
-	    try {
-	      const dashJsonPath = path.join(widgetPath, "dash.json");
-	      if (fs.existsSync(dashJsonPath)) {
-	        const data = fs.readFileSync(dashJsonPath, "utf8");
-	        return JSON.parse(data);
-	      }
-
-	      const packageJsonPath = path.join(widgetPath, "package.json");
-	      if (fs.existsSync(packageJsonPath)) {
-	        const packageJson = JSON.parse(
-	          fs.readFileSync(packageJsonPath, "utf8"),
-	        );
-	        return {
-	          name: packageJson.name || widgetName,
-	          version: packageJson.version,
-	          description: packageJson.description,
-	          author: packageJson.author,
-	          repository: packageJson.repository,
-	        };
-	      }
+	/**
+	 * Initialize registry with custom path or default userData path
+	 * @param {string} customPath - Optional custom path for storing widgets
+	 */
+	function initializeRegistry(customPath = null) {
+	  if (customPath) {
+	    WIDGETS_CACHE_DIR = path.join(customPath, "widgets");
+	  } else {
+	    WIDGETS_CACHE_DIR = path.join(app.getPath("userData"), "widgets");
+	  }
+	  REGISTRY_CONFIG_FILE = path.join(WIDGETS_CACHE_DIR, "registry.json");
+	  console.log(`[WidgetRegistry] Using storage path: ${WIDGETS_CACHE_DIR}`);
+	}
 
-	      return {
-	        name: widgetName,
-	        version: "1.0.0",
-	      };
-	    } catch (error) {
-	      console.error(
-	        `[WidgetRegistry] Error loading config for ${widgetName}:`,
-	        error,
-	      );
-	      return { name: widgetName };
+	class WidgetRegistry {
+	  constructor(componentManager = null, customPath = null) {
+	    if (!WIDGETS_CACHE_DIR) {
+	      initializeRegistry(customPath);
 	    }
+
+	    this.widgets = new Map();
+	    this.componentManager = componentManager;
+	    this.ensureCacheDir();
+	    this.loadRegistry();
 	  }
 
 	  /**
-	   * Register a widget in the registry
-	   * @param {string} widgetName - Name of the widget
-	   * @param {Object} config - Widget configuration
-	   * @param {string} widgetPath - Path to widget directory
-	   * @param {boolean} autoRegister - Automatically register with ComponentManager
+	   * Static method to initialize registry with custom path
+	   * Call this early in your app startup (e.g., in main.js)
+	   * @param {string} customPath - Custom path for storing widgets/configs
 	   */
-	  registerWidget(widgetName, config, widgetPath, autoRegister = true) {
-	    const widgetEntry = {
-	      name: widgetName,
-	      path: widgetPath,
-	      ...config,
-	      registeredAt: new Date().toISOString(),
-	    };
-
-	    this.widgets.set(widgetName, widgetEntry);
-	    this.saveRegistry();
-	    console.log(`[WidgetRegistry] Registered widget: ${widgetName}`);
+	  static initialize(customPath = null) {
+	    initializeRegistry(customPath);
 	  }
 
 	  /**
-	   * Load all components for a widget and register them with ComponentManager
-	   * @param {string} widgetName - Name of the widget
-	   * @param {string} widgetPath - Path to widget directory
+	   * Set ComponentManager instance for automatic widget registration
+	   * @param {Object} manager - ComponentManager instance from @trops/dash-react
 	   */
-	  async loadWidgetComponents(widgetName, widgetPath) {
-	    try {
-	      // Auto-compile widget source to CJS bundle if none exists
-	      if (!findBundlePath(widgetPath)) {
-	        try {
-	          await compileWidget(widgetPath);
-	          console.log(`[WidgetRegistry] Auto-compiled ${widgetName}`);
-	        } catch (compileError) {
-	          console.warn(
-	            `[WidgetRegistry] Could not compile ${widgetName}:`,
-	            compileError,
-	          );
-	        }
-	      }
-
-	      if (this.componentManager) {
-	        dynamicWidgetLoader.setComponentManager(this.componentManager);
-	      }
-
-	      const components = dynamicWidgetLoader.discoverWidgets(widgetPath);
-	      console.log(
-	        `[WidgetRegistry] Found ${components.length} components in ${widgetName}`,
-	      );
-
-	      const existingEntry = this.widgets.get(widgetName);
-	      let registryUpdated = false;
-
-	      // Store component names as displayName on the registry entry
-	      // so settings UI shows "WeatherWidget" instead of "weather-widget"
-	      if (components.length > 0 && existingEntry) {
-	        existingEntry.displayName = components.join(", ");
-	        existingEntry.componentNames = components;
-	        registryUpdated = true;
-	      }
-
-	      for (const componentName of components) {
-	        try {
-	          const result = await dynamicWidgetLoader.loadWidget(
-	            widgetName,
-	            widgetPath,
-	            componentName,
-	            true,
-	          );
-	          console.log(`[WidgetRegistry] ✓ Loaded ${componentName}`);
+	  setComponentManager(manager) {
+	    this.componentManager = manager;
+	  }
 
-	          // Enrich registry entry with .dash.js config fields
-	          // (icon, providers, workspace, etc.) so the settings UI
-	          // has full display data without needing ComponentManager.
-	          if (result?.config && existingEntry) {
-	            const cfg = result.config;
-	            if (cfg.icon && !existingEntry.icon) existingEntry.icon = cfg.icon;
-	            if (cfg.providers?.length && !existingEntry.providers?.length)
-	              existingEntry.providers = cfg.providers;
-	            if (cfg.workspace && !existingEntry.workspace)
-	              existingEntry.workspace = cfg.workspace;
-	            if (cfg.events?.length && !existingEntry.events?.length)
-	              existingEntry.events = cfg.events;
-	            if (
-	              cfg.eventHandlers?.length &&
-	              !existingEntry.eventHandlers?.length
-	            )
-	              existingEntry.eventHandlers = cfg.eventHandlers;
-	            registryUpdated = true;
-	          }
-	        } catch (error) {
-	          console.error(
-	            `[WidgetRegistry] Error loading component ${componentName}:`,
-	            error,
-	          );
-	        }
-	      }
+	  /**
+	   * Ensure cache directory exists
+	   */
+	  ensureCacheDir() {
+	    if (!fs.existsSync(WIDGETS_CACHE_DIR)) {
+	      fs.mkdirSync(WIDGETS_CACHE_DIR, { recursive: true });
+	    }
+	  }
 
-	      if (registryUpdated && existingEntry) {
-	        this.widgets.set(widgetName, existingEntry);
-	        this.saveRegistry();
+	  /**
+	   * Load registry from disk
+	   */
+	  loadRegistry() {
+	    try {
+	      if (fs.existsSync(REGISTRY_CONFIG_FILE)) {
+	        const data = fs.readFileSync(REGISTRY_CONFIG_FILE, "utf8");
+	        const registryData = JSON.parse(data);
+	        this.widgets = new Map(registryData.widgets || []);
+	        console.log(
+	          `[WidgetRegistry] Loaded ${this.widgets.size} widgets from cache`,
+	        );
 	      }
 	    } catch (error) {
-	      console.error("[WidgetRegistry] Error loading widget components:", error);
+	      console.error("[WidgetRegistry] Error loading registry:", error);
 	    }
 	  }
 
 	  /**
-	   * Get all registered widgets
-	   * @returns {Array} List of widget configurations
+	   * Save registry to disk
 	   */
-	  getWidgets() {
-	    return Array.from(this.widgets.values());
+	  saveRegistry() {
+	    try {
+	      const registryData = {
+	        lastUpdated: new Date().toISOString(),
+	        widgets: Array.from(this.widgets.entries()),
+	      };
+	      fs.writeFileSync(
+	        REGISTRY_CONFIG_FILE,
+	        JSON.stringify(registryData, null, 2),
+	      );
+	    } catch (error) {
+	      console.error("[WidgetRegistry] Error saving registry:", error);
+	    }
 	  }
 
 	  /**
-	   * Get widget by name
-	   * @param {string} widgetName - Name of the widget
-	   * @returns {Object|null} Widget configuration or null
+	   * Resolve download URL from partial template or full URL
+	   * Supports placeholders: {version}, {name}
+	   *
+	   * Examples:
+	   * - Full URL: "https://github.com/user/widget/releases/download/v1.0.0/widget.zip"
+	   * - Template: "https://github.com/user/weather-widget/releases/download/v{version}/weather-widget.zip"
+	   * - Partial: "https://github.com/user/weather-widget/releases/download/" (auto-generates v{version}/{name}.zip)
+	   *
+	   * @param {string} urlTemplate - URL template or partial URL
+	   * @param {string} version - Widget version (e.g., "1.0.0")
+	   * @param {string} name - Widget name (e.g., "weather-widget")
+	   * @returns {string} Resolved download URL
 	   */
-	  getWidget(widgetName) {
-	    return this.widgets.get(widgetName) || null;
+	  resolveDownloadUrl(urlTemplate, version, name) {
+	    if (!urlTemplate) return null;
+
+	    if (urlTemplate.endsWith("/")) {
+	      return `${urlTemplate}v${version}/${name}.zip`;
+	    }
+
+	    let url = urlTemplate;
+	    url = url.replace("{version}", version);
+	    url = url.replace("{name}", name);
+	    return url;
 	  }
 
 	  /**
-	   * Uninstall a widget
-	   * @param {string} widgetName - Name of the widget to remove
+	   * Determine if the input points to a local path (file:// or filesystem path)
+	   * @param {string} input - URL or path
+	   * @returns {boolean}
 	   */
-	  uninstallWidget(widgetName) {
-	    const widget = this.widgets.get(widgetName);
-	    if (!widget) {
-	      console.warn(`[WidgetRegistry] Widget not found: ${widgetName}`);
+	  isLocalSource(input) {
+	    if (!input) return false;
+	    if (input.startsWith("file://")) return true;
+	    if (input.startsWith("http://") || input.startsWith("https://"))
 	      return false;
+	    const resolvedPath = this.resolveLocalPath(input);
+	    return fs.existsSync(resolvedPath);
+	  }
+
+	  /**
+	   * Normalize a local path (supports file:// and ~)
+	   * @param {string} input - Local path or file:// URL
+	   * @returns {string}
+	   */
+	  resolveLocalPath(input) {
+	    if (input.startsWith("file://")) {
+	      return fileURLToPath(input);
+	    }
+	    if (input.startsWith("~")) {
+	      return path.join(os.homedir(), input.slice(1));
 	    }
+	    return path.resolve(input);
+	  }
 
+	  /**
+	   * Install a widget from a local ZIP file or folder path
+	   * @param {string} widgetName - Name of the widget
+	   * @param {string} localPath - Path to ZIP file or widget folder
+	   * @param {boolean} autoRegister - Automatically register with ComponentManager
+	   * @param {string} dashConfigPath - Optional: path to dash.json metadata file
+	   * @returns {Promise<Object>} Widget configuration
+	   */
+	  async installFromLocalPath(
+	    widgetName,
+	    localPath,
+	    autoRegister = true,
+	    dashConfigPath = null,
+	  ) {
 	    try {
-	      if (fs.existsSync(widget.path)) {
-	        fs.rmSync(widget.path, { recursive: true });
+	      const resolvedPath = this.resolveLocalPath(localPath);
+
+	      if (!fs.existsSync(resolvedPath)) {
+	        throw new Error(`Local path not found: ${resolvedPath}`);
 	      }
-	      this.widgets.delete(widgetName);
-	      this.saveRegistry();
-	      console.log(`[WidgetRegistry] Uninstalled widget: ${widgetName}`);
-	      return true;
+
+	      const widgetPath = path.join(WIDGETS_CACHE_DIR, widgetName);
+
+	      if (fs.existsSync(widgetPath)) {
+	        fs.rmSync(widgetPath, { recursive: true });
+	      }
+
+	      const isDirectory = fs.statSync(resolvedPath).isDirectory();
+	      if (isDirectory) {
+	        fs.cpSync(resolvedPath, widgetPath, { recursive: true });
+	      } else if (resolvedPath.endsWith(".zip")) {
+	        const zip = new AdmZip(resolvedPath);
+	        validateZipEntries(zip, widgetPath);
+	        zip.extractAllTo(widgetPath, true);
+	      } else {
+	        throw new Error(`Unsupported local source type: ${resolvedPath}`);
+	      }
+
+	      let config = await this.loadWidgetConfig(widgetName, widgetPath);
+
+	      if (dashConfigPath) {
+	        const configPath = this.resolveLocalPath(dashConfigPath);
+	        if (fs.existsSync(configPath)) {
+	          const dashConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+	          config = { ...config, ...dashConfig };
+	        }
+	      }
+
+	      this.registerWidget(widgetName, config, widgetPath, false);
+
+	      if (autoRegister) {
+	        await this.loadWidgetComponents(widgetName, widgetPath);
+	      }
+
+	      return config;
 	    } catch (error) {
 	      console.error(
-	        `[WidgetRegistry] Error uninstalling ${widgetName}:`,
+	        `[WidgetRegistry] Error installing local widget ${widgetName}:`,
 	        error,
 	      );
-	      return false;
+	      throw error;
 	    }
 	  }
 
 	  /**
-	   * Helper: Fetch JSON from URL
+	   * Check if a directory looks like a valid widget folder.
+	   * A directory is a widget if it has:
+	   * - package.json or dash.json at its root, OR
+	   * - A widgets/ subdirectory containing at least one .dash.js file
+	   * @param {string} dirPath - Path to the directory
+	   * @returns {boolean}
 	   */
-	  async fetchJSON(url) {
-	    const response = await fetch(url);
-	    if (!response.ok)
-	      throw new Error(`Failed to fetch: ${response.statusText}`);
-	    return response.json();
-	  }
+	  isWidgetFolder(dirPath) {
+	    if (fs.existsSync(path.join(dirPath, "package.json"))) return true;
+	    if (fs.existsSync(path.join(dirPath, "dash.json"))) return true;
 
-	  /**
-	   * Get cache directory path
-	   */
-	  getCachePath() {
-	    return WIDGETS_CACHE_DIR;
+	    const widgetsDir = path.join(dirPath, "widgets");
+	    if (fs.existsSync(widgetsDir) && fs.statSync(widgetsDir).isDirectory()) {
+	      const files = fs.readdirSync(widgetsDir);
+	      if (files.some((f) => f.endsWith(".dash.js"))) return true;
+	    }
+
+	    return false;
 	  }
 
 	  /**
-	   * Get the storage directory (parent of widgets directory)
-	   * @returns {string} Full path to storage directory
+	   * Register all widgets found in a local folder.
+	   *
+	   * Smart detection:
+	   * 1. If the selected folder itself is a widget, install it directly.
+	   * 2. Otherwise iterate subdirectories, skipping non-widget dirs.
+	   *
+	   * @param {string} folderPath - Path containing widget folders (or a single widget folder)
+	   * @param {boolean} autoRegister - Automatically register with ComponentManager
+	   * @returns {Promise<Array>} Registered widgets (with optional `mode` and `skipped` metadata)
 	   */
-	  getStoragePath() {
-	    return path.dirname(WIDGETS_CACHE_DIR);
-	  }
-	}
+	  async registerWidgetsFromFolder(folderPath, autoRegister = true) {
+	    const SKIP_DIRS = new Set(["node_modules", "dist", "__MACOSX", ".git"]);
 
-	// Lazy initialization to avoid accessing app.getPath before app is ready
-	let widgetRegistry = null;
+	    try {
+	      const resolvedPath = this.resolveLocalPath(folderPath);
+	      if (!fs.existsSync(resolvedPath)) {
+	        throw new Error(`Folder not found: ${resolvedPath}`);
+	      }
+	      if (!fs.statSync(resolvedPath).isDirectory()) {
+	        throw new Error(`Path is not a directory: ${resolvedPath}`);
+	      }
 
-	function getWidgetRegistry() {
-	  if (!widgetRegistry) {
-	    widgetRegistry = new WidgetRegistry();
-	  }
-	  return widgetRegistry;
-	}
+	      // 1. Check if the selected folder itself is a widget
+	      if (this.isWidgetFolder(resolvedPath)) {
+	        const widgetName = path.basename(resolvedPath);
+	        const config = await this.installFromLocalPath(
+	          widgetName,
+	          resolvedPath,
+	          autoRegister,
+	        );
+	        return [
+	          {
+	            name: widgetName,
+	            path: resolvedPath,
+	            ...config,
+	            mode: "single",
+	          },
+	        ];
+	      }
 
-	/**
-	 * Look for a CJS bundle file in a widget directory.
-	 * Checks multiple candidate paths in priority order because
-	 * packageZip.js may extract dist/ contents to the widget root.
-	 *
-	 * @param {string} widgetPath - Path to the widget directory
-	 * @returns {string|null} Absolute path to the bundle, or null if not found
-	 */
-	function findBundlePath(widgetPath) {
-	  const candidates = [
-	    path.join(widgetPath, "dist", "index.cjs.js"),
-	    path.join(widgetPath, "index.cjs.js"),
-	    path.join(widgetPath, "dist", "index.js"),
-	    path.join(widgetPath, "index.js"),
-	  ];
+	      // 2. Iterate subdirectories with filtering
+	      const entries = fs.readdirSync(resolvedPath, {
+	        withFileTypes: true,
+	      });
+	      const results = [];
+	      let skipped = 0;
 
-	  for (const candidate of candidates) {
-	    if (fs.existsSync(candidate)) {
-	      // Skip ESM files — the eval pipeline requires CJS
-	      if (candidate.endsWith(".js") && !candidate.endsWith(".cjs.js")) {
-	        try {
-	          const head = fs.readFileSync(candidate, "utf8").slice(0, 256);
-	          if (/^\s*(import\s|export\s)/m.test(head)) {
-	            console.log(`[WidgetRegistry] Skipping ESM bundle: ${candidate}`);
-	            continue;
-	          }
-	        } catch (_) {
-	          // Non-fatal — allow fallthrough
+	      for (const entry of entries) {
+	        if (!entry.isDirectory()) continue;
+
+	        // Skip hidden dirs and known non-widget dirs
+	        if (entry.name.startsWith(".") || SKIP_DIRS.has(entry.name)) {
+	          skipped++;
+	          continue;
 	        }
-	      }
-	      return candidate;
-	    }
-	  }
 
-	  return null;
-	}
+	        const widgetPath = path.join(resolvedPath, entry.name);
 
-	/**
-	 * Setup IPC handlers for widget management (use in main.js)
-	 */
-	function setupWidgetRegistryHandlers() {
-	  ipcMain.handle("widget:list", () => getWidgetRegistry().getWidgets());
+	        if (!this.isWidgetFolder(widgetPath)) {
+	          skipped++;
+	          continue;
+	        }
 
-	  ipcMain.handle("widget:get", (event, widgetName) => {
-	    return getWidgetRegistry().getWidget(widgetName);
-	  });
+	        const config = await this.loadWidgetConfig(entry.name, widgetPath);
+	        this.registerWidget(entry.name, config, widgetPath, false);
 
-	  ipcMain.handle(
-	    "widget:install",
-	    async (event, widgetName, downloadUrl, dashConfigUrl) => {
-	      const config = await getWidgetRegistry().downloadWidget(
-	        widgetName,
-	        downloadUrl,
-	        dashConfigUrl,
-	      );
+	        if (autoRegister) {
+	          await this.loadWidgetComponents(entry.name, widgetPath);
+	        }
 
-	      BrowserWindow.getAllWindows().forEach((win) => {
-	        win.webContents.send("widget:installed", {
-	          widgetName,
-	          config,
+	        results.push({
+	          name: entry.name,
+	          path: widgetPath,
+	          ...config,
 	        });
-	      });
-
-	      return config;
-	    },
-	  );
+	      }
 
-	  ipcMain.handle(
-	    "widget:install-local",
-	    async (event, widgetName, localPath, dashConfigPath) => {
-	      const config = await getWidgetRegistry().installFromLocalPath(
-	        widgetName,
-	        localPath,
-	        true,
-	        dashConfigPath,
+	      // Attach skipped count as metadata on the array
+	      results.skipped = skipped;
+	      return results;
+	    } catch (error) {
+	      console.error(
+	        "[WidgetRegistry] Error registering widgets from folder:",
+	        error,
 	      );
+	      throw error;
+	    }
+	  }
 
-	      BrowserWindow.getAllWindows().forEach((win) => {
-	        win.webContents.send("widget:installed", {
+	  /**
+	   * Download widget from URL (ZIP file)
+	   * @param {string} widgetName - Name of the widget
+	   * @param {string} downloadUrl - URL to download ZIP file from (supports templates and partial URLs)
+	   * @param {string} dashConfigUrl - Optional: URL to dash.json metadata file
+	   * @param {boolean} autoRegister - Automatically register with ComponentManager
+	   * @returns {Promise<Object>} Widget configuration
+	   */
+	  async downloadWidget(
+	    widgetName,
+	    downloadUrl,
+	    dashConfigUrl = null,
+	    autoRegister = true,
+	  ) {
+	    try {
+	      if (this.isLocalSource(downloadUrl)) {
+	        return this.installFromLocalPath(
 	          widgetName,
-	          config,
-	        });
-	      });
+	          downloadUrl,
+	          autoRegister,
+	          dashConfigUrl,
+	        );
+	      }
+	      // Enforce HTTPS to prevent MITM attacks on widget downloads
+	      const parsedUrl = new URL(downloadUrl);
+	      if (parsedUrl.protocol !== "https:") {
+	        throw new Error(
+	          `Widget downloads must use HTTPS. Refusing to fetch: ${downloadUrl}`,
+	        );
+	      }
 
-	      return config;
-	    },
-	  );
+	      console.log(
+	        `[WidgetRegistry] Downloading widget: ${widgetName} from ${downloadUrl}`,
+	      );
 
-	  ipcMain.handle("widget:load-folder", async (event, folderPath) => {
-	    const results = await getWidgetRegistry().registerWidgetsFromFolder(
-	      folderPath,
-	      true,
-	    );
+	      const response = await fetch(downloadUrl);
+	      if (!response.ok)
+	        throw new Error(`Failed to fetch: ${response.statusText}`);
 
-	    BrowserWindow.getAllWindows().forEach((win) => {
-	      win.webContents.send("widgets:loaded", {
-	        count: results.length,
-	        widgets: results,
-	      });
-	    });
+	      const buffer = await response.arrayBuffer();
+	      const zip = new AdmZip(Buffer.from(buffer));
 
-	    return results;
-	  });
+	      const widgetPath = path.join(WIDGETS_CACHE_DIR, widgetName);
 
-	  ipcMain.handle("widget:uninstall", (event, widgetName) => {
-	    const schedulerController = schedulerController_1;
-	    schedulerController.cleanupWidget(widgetName);
-	    return getWidgetRegistry().uninstallWidget(widgetName);
-	  });
+	      if (fs.existsSync(widgetPath)) {
+	        fs.rmSync(widgetPath, { recursive: true });
+	      }
 
-	  ipcMain.handle("widget:cache-path", () => getWidgetRegistry().getCachePath());
+	      validateZipEntries(zip, widgetPath);
+	      zip.extractAllTo(widgetPath, true);
+	      console.log(`[WidgetRegistry] Extracted widget to: ${widgetPath}`);
 
-	  ipcMain.handle("widget:storage-path", () =>
-	    getWidgetRegistry().getStoragePath(),
-	  );
+	      let config = await this.loadWidgetConfig(widgetName, widgetPath);
 
-	  ipcMain.handle("widget:get-component-configs", async () => {
-	    try {
-	      const registry = getWidgetRegistry();
-	      const installedWidgets = registry.getWidgets();
-	      const configs = [];
+	      if (dashConfigUrl) {
+	        const dashConfig = await this.fetchJSON(dashConfigUrl);
+	        config = { ...config, ...dashConfig };
+	      }
 
-	      for (const widget of installedWidgets) {
-	        const widgetPath = widget.path;
-	        if (!widgetPath || !fs.existsSync(widgetPath)) continue;
+	      this.registerWidget(widgetName, config, widgetPath, false);
 
-	        const componentNames = dynamicWidgetLoader.discoverWidgets(widgetPath);
-	        const widgetsDir = findWidgetsDir(widgetPath);
-	        for (const componentName of componentNames) {
-	          try {
-	            const configPath = path.join(
-	              widgetsDir || path.join(widgetPath, "widgets"),
-	              `${componentName}.dash.js`,
-	            );
-	            const config = await dynamicWidgetLoader.loadConfigFile(configPath);
-	            configs.push({
-	              componentName,
-	              widgetPackage: widget.name,
-	              // Include scoped id if present in the config
-	              id: config.id || null,
-	              config,
-	            });
-	          } catch (err) {
-	            console.error(
-	              `[WidgetRegistry] Error loading config for ${componentName}:`,
-	              err,
-	            );
-	          }
-	        }
+	      if (autoRegister) {
+	        await this.loadWidgetComponents(widgetName, widgetPath);
 	      }
 
-	      return configs;
+	      return config;
 	    } catch (error) {
-	      console.error("[WidgetRegistry] Error getting component configs:", error);
-	      return [];
+	      console.error(
+	        `[WidgetRegistry] Error downloading widget ${widgetName}:`,
+	        error,
+	      );
+	      throw error;
 	    }
-	  });
+	  }
 
-	  ipcMain.handle("widget:read-bundle", async (event, widgetName) => {
+	  /**
+	   * Load widget configuration from local path
+	   * @param {string} widgetName - Name of the widget
+	   * @param {string} widgetPath - Path to widget directory
+	   * @returns {Promise<Object>} Widget configuration
+	   */
+	  async loadWidgetConfig(widgetName, widgetPath) {
 	    try {
-	      const registry = getWidgetRegistry();
-	      const widget = registry.getWidget(widgetName);
-	      if (!widget || !widget.path) {
+	      const dashJsonPath = path.join(widgetPath, "dash.json");
+	      if (fs.existsSync(dashJsonPath)) {
+	        const data = fs.readFileSync(dashJsonPath, "utf8");
+	        return JSON.parse(data);
+	      }
+
+	      const packageJsonPath = path.join(widgetPath, "package.json");
+	      if (fs.existsSync(packageJsonPath)) {
+	        const packageJson = JSON.parse(
+	          fs.readFileSync(packageJsonPath, "utf8"),
+	        );
 	        return {
-	          success: false,
-	          error: `Widget not found: ${widgetName}`,
+	          name: packageJson.name || widgetName,
+	          version: packageJson.version,
+	          description: packageJson.description,
+	          author: packageJson.author,
+	          repository: packageJson.repository,
 	        };
 	      }
 
-	      let bundlePath = findBundlePath(widget.path);
+	      return {
+	        name: widgetName,
+	        version: "1.0.0",
+	      };
+	    } catch (error) {
+	      console.error(
+	        `[WidgetRegistry] Error loading config for ${widgetName}:`,
+	        error,
+	      );
+	      return { name: widgetName };
+	    }
+	  }
+
+	  /**
+	   * Register a widget in the registry
+	   * @param {string} widgetName - Name of the widget
+	   * @param {Object} config - Widget configuration
+	   * @param {string} widgetPath - Path to widget directory
+	   * @param {boolean} autoRegister - Automatically register with ComponentManager
+	   */
+	  registerWidget(widgetName, config, widgetPath, autoRegister = true) {
+	    const widgetEntry = {
+	      name: widgetName,
+	      path: widgetPath,
+	      ...config,
+	      registeredAt: new Date().toISOString(),
+	    };
+
+	    this.widgets.set(widgetName, widgetEntry);
+	    this.saveRegistry();
+	    console.log(`[WidgetRegistry] Registered widget: ${widgetName}`);
+	  }
 
-	      // Auto-compile if no bundle exists (same as read-all-bundles)
-	      if (!bundlePath) {
+	  /**
+	   * Load all components for a widget and register them with ComponentManager
+	   * @param {string} widgetName - Name of the widget
+	   * @param {string} widgetPath - Path to widget directory
+	   */
+	  async loadWidgetComponents(widgetName, widgetPath) {
+	    try {
+	      // Auto-compile widget source to CJS bundle if none exists
+	      if (!findBundlePath(widgetPath)) {
 	        try {
-	          const compiled = await compileWidget(widget.path);
-	          if (compiled) {
-	            bundlePath = compiled;
-	          }
+	          await compileWidget(widgetPath);
+	          console.log(`[WidgetRegistry] Auto-compiled ${widgetName}`);
 	        } catch (compileError) {
 	          console.warn(
 	            `[WidgetRegistry] Could not compile ${widgetName}:`,
@@ -31372,430 +31367,435 @@ var schedulerController_1 = schedulerController$2;
 	        }
 	      }
 
-	      if (!bundlePath) {
-	        return {
-	          success: false,
-	          error: `No bundle found in: ${widget.path}`,
-	        };
+	      if (this.componentManager) {
+	        dynamicWidgetLoader.setComponentManager(this.componentManager);
 	      }
 
-	      const source = fs.readFileSync(bundlePath, "utf8");
-	      return { success: true, source, widgetName };
-	    } catch (error) {
-	      console.error(
-	        `[WidgetRegistry] Error reading bundle for ${widgetName}:`,
-	        error,
+	      const components = dynamicWidgetLoader.discoverWidgets(widgetPath);
+	      console.log(
+	        `[WidgetRegistry] Found ${components.length} components in ${widgetName}`,
 	      );
-	      return { success: false, error: error.message };
-	    }
-	  });
-
-	  ipcMain.handle("widget:read-all-bundles", async () => {
-	    try {
-	      const registry = getWidgetRegistry();
-	      const installedWidgets = registry.getWidgets();
-	      const results = [];
-
-	      for (const widget of installedWidgets) {
-	        const widgetPath = widget.path;
-	        if (!widgetPath || !fs.existsSync(widgetPath)) continue;
 
-	        let bundlePath = findBundlePath(widgetPath);
+	      const existingEntry = this.widgets.get(widgetName);
+	      let registryUpdated = false;
 
-	        // Auto-compile if no bundle exists
-	        if (!bundlePath) {
-	          try {
-	            const compiled = await compileWidget(widgetPath);
-	            if (compiled) {
-	              bundlePath = compiled;
-	            }
-	          } catch (compileError) {
-	            console.warn(
-	              `[WidgetRegistry] Could not compile ${widget.name}:`,
-	              compileError,
-	            );
-	          }
-	        }
+	      // Store component names as displayName on the registry entry
+	      // so settings UI shows "WeatherWidget" instead of "weather-widget"
+	      if (components.length > 0 && existingEntry) {
+	        existingEntry.displayName = components.join(", ");
+	        existingEntry.componentNames = components;
+	        registryUpdated = true;
+	      }
 
-	        if (!bundlePath) {
-	          console.log(
-	            `[WidgetRegistry] No CJS bundle for ${widget.name}, skipping (will use config fallback)`,
+	      for (const componentName of components) {
+	        try {
+	          const result = await dynamicWidgetLoader.loadWidget(
+	            widgetName,
+	            widgetPath,
+	            componentName,
+	            true,
 	          );
-	          continue;
-	        }
+	          console.log(`[WidgetRegistry] ✓ Loaded ${componentName}`);
 
-	        try {
-	          const source = fs.readFileSync(bundlePath, "utf8");
-	          results.push({
-	            widgetName: widget.name,
-	            source,
-	          });
-	        } catch (readError) {
+	          // Enrich registry entry with .dash.js config fields
+	          // (icon, providers, workspace, etc.) so the settings UI
+	          // has full display data without needing ComponentManager.
+	          if (result?.config && existingEntry) {
+	            const cfg = result.config;
+	            if (cfg.icon && !existingEntry.icon) existingEntry.icon = cfg.icon;
+	            if (cfg.providers?.length && !existingEntry.providers?.length)
+	              existingEntry.providers = cfg.providers;
+	            if (cfg.workspace && !existingEntry.workspace)
+	              existingEntry.workspace = cfg.workspace;
+	            if (cfg.events?.length && !existingEntry.events?.length)
+	              existingEntry.events = cfg.events;
+	            if (
+	              cfg.eventHandlers?.length &&
+	              !existingEntry.eventHandlers?.length
+	            )
+	              existingEntry.eventHandlers = cfg.eventHandlers;
+	            registryUpdated = true;
+	          }
+	        } catch (error) {
 	          console.error(
-	            `[WidgetRegistry] Error reading bundle for ${widget.name}:`,
-	            readError,
+	            `[WidgetRegistry] Error loading component ${componentName}:`,
+	            error,
 	          );
 	        }
 	      }
 
-	      return results;
+	      if (registryUpdated && existingEntry) {
+	        this.widgets.set(widgetName, existingEntry);
+	        this.saveRegistry();
+	      }
 	    } catch (error) {
-	      console.error("[WidgetRegistry] Error reading all bundles:", error);
-	      return [];
+	      console.error("[WidgetRegistry] Error loading widget components:", error);
 	    }
-	  });
+	  }
 
-	  ipcMain.handle("widget:set-storage-path", (event, customPath) => {
-	    try {
-	      WidgetRegistry.initialize(customPath);
-	      console.log(`[WidgetRegistry] Storage path changed to: ${customPath}`);
-	      return { success: true, path: customPath };
-	    } catch (error) {
-	      console.error("[WidgetRegistry] Error setting storage path:", error);
-	      return { success: false, error: error.message };
-	    }
-	  });
-	}
+	  /**
+	   * Get all registered widgets
+	   * @returns {Array} List of widget configurations
+	   */
+	  getWidgets() {
+	    return Array.from(this.widgets.values());
+	  }
 
-	module.exports = WidgetRegistry;
-	module.exports.getWidgetRegistry = getWidgetRegistry;
-	// For backward compatibility, provide widgetRegistry as a getter
-	Object.defineProperty(module.exports, "widgetRegistry", {
-	  get: getWidgetRegistry,
-	});
-	module.exports.setupWidgetRegistryHandlers = setupWidgetRegistryHandlers;
-	module.exports.validateZipEntries = validateZipEntries; 
-} (widgetRegistry$1));
+	  /**
+	   * Get widget by name
+	   * @param {string} widgetName - Name of the widget
+	   * @returns {Object|null} Widget configuration or null
+	   */
+	  getWidget(widgetName) {
+	    return this.widgets.get(widgetName) || null;
+	  }
 
-var widgetRegistryExports = widgetRegistry$1.exports;
+	  /**
+	   * Uninstall a widget
+	   * @param {string} widgetName - Name of the widget to remove
+	   */
+	  uninstallWidget(widgetName) {
+	    const widget = this.widgets.get(widgetName);
+	    if (!widget) {
+	      console.warn(`[WidgetRegistry] Widget not found: ${widgetName}`);
+	      return false;
+	    }
 
-/**
- * registryAuthController.js
- *
- * Manages authentication with the Dash registry service.
- * Uses OAuth device code flow for desktop app authentication.
- *
- * Flow:
- * 1. App calls initiateDeviceFlow() — gets device code + verification URL
- * 2. User opens verification URL in browser, signs in, enters code
- * 3. App polls pollForToken() until authorized
- * 4. Token stored securely via electron-store (encrypted)
- */
+	    try {
+	      if (fs.existsSync(widget.path)) {
+	        fs.rmSync(widget.path, { recursive: true });
+	      }
+	      this.widgets.delete(widgetName);
+	      this.saveRegistry();
+	      console.log(`[WidgetRegistry] Uninstalled widget: ${widgetName}`);
+	      return true;
+	    } catch (error) {
+	      console.error(
+	        `[WidgetRegistry] Error uninstalling ${widgetName}:`,
+	        error,
+	      );
+	      return false;
+	    }
+	  }
 
-const REGISTRY_BASE_URL$1 =
-  process.env.DASH_REGISTRY_API_URL ||
-  "https://main.d919rwhuzp7rj.amplifyapp.com";
+	  /**
+	   * Helper: Fetch JSON from URL
+	   */
+	  async fetchJSON(url) {
+	    const response = await fetch(url);
+	    if (!response.ok)
+	      throw new Error(`Failed to fetch: ${response.statusText}`);
+	    return response.json();
+	  }
 
-// Lazy-load electron-store to avoid issues when not installed
-let store$2 = null;
-function getStore$1() {
-  if (!store$2) {
-    const Store = require$$1$1;
-    store$2 = new Store({
-      name: "dash-registry-auth",
-      encryptionKey: "dash-registry-v1",
-    });
-  }
-  return store$2;
-}
+	  /**
+	   * Get cache directory path
+	   */
+	  getCachePath() {
+	    return WIDGETS_CACHE_DIR;
+	  }
 
-/**
- * Initiate the OAuth device code flow.
- * Returns the device code, user code, and verification URL.
- *
- * @returns {Promise<Object>} { deviceCode, userCode, verificationUrl, verificationUrlComplete, expiresIn, interval }
- */
-async function initiateDeviceFlow$1() {
-  const response = await fetch(`${REGISTRY_BASE_URL$1}/api/auth/device`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-  });
+	  /**
+	   * Get the storage directory (parent of widgets directory)
+	   * @returns {string} Full path to storage directory
+	   */
+	  getStoragePath() {
+	    return path.dirname(WIDGETS_CACHE_DIR);
+	  }
+	}
 
-  if (!response.ok) {
-    throw new Error(`Device flow initiation failed: ${response.status}`);
-  }
+	// Lazy initialization to avoid accessing app.getPath before app is ready
+	let widgetRegistry = null;
 
-  const data = await response.json();
+	function getWidgetRegistry() {
+	  if (!widgetRegistry) {
+	    widgetRegistry = new WidgetRegistry();
+	  }
+	  return widgetRegistry;
+	}
 
-  return {
-    deviceCode: data.device_code,
-    userCode: data.user_code,
-    verificationUrl: data.verification_uri,
-    verificationUrlComplete: data.verification_uri_complete,
-    expiresIn: data.expires_in,
-    interval: data.interval,
-  };
-}
+	/**
+	 * Look for a CJS bundle file in a widget directory.
+	 * Checks multiple candidate paths in priority order because
+	 * packageZip.js may extract dist/ contents to the widget root.
+	 *
+	 * @param {string} widgetPath - Path to the widget directory
+	 * @returns {string|null} Absolute path to the bundle, or null if not found
+	 */
+	function findBundlePath(widgetPath) {
+	  const candidates = [
+	    path.join(widgetPath, "dist", "index.cjs.js"),
+	    path.join(widgetPath, "index.cjs.js"),
+	    path.join(widgetPath, "dist", "index.js"),
+	    path.join(widgetPath, "index.js"),
+	  ];
 
-/**
- * Poll the registry for token after user completes browser auth.
- *
- * @param {string} deviceCode - The device code from initiateDeviceFlow()
- * @returns {Promise<Object>} { status: 'pending' | 'authorized' | 'expired', token?, userId? }
- */
-async function pollForToken$1(deviceCode) {
-  const response = await fetch(
-    `${REGISTRY_BASE_URL$1}/api/auth/device?device_code=${encodeURIComponent(deviceCode)}`,
-  );
+	  for (const candidate of candidates) {
+	    if (fs.existsSync(candidate)) {
+	      // Skip ESM files — the eval pipeline requires CJS
+	      if (candidate.endsWith(".js") && !candidate.endsWith(".cjs.js")) {
+	        try {
+	          const head = fs.readFileSync(candidate, "utf8").slice(0, 256);
+	          if (/^\s*(import\s|export\s)/m.test(head)) {
+	            console.log(`[WidgetRegistry] Skipping ESM bundle: ${candidate}`);
+	            continue;
+	          }
+	        } catch (_) {
+	          // Non-fatal — allow fallthrough
+	        }
+	      }
+	      return candidate;
+	    }
+	  }
 
-  if (response.status === 428) {
-    return { status: "pending" };
-  }
+	  return null;
+	}
 
-  if (response.status === 400) {
-    const data = await response.json();
-    if (data.error === "expired_token") {
-      return { status: "expired" };
-    }
-    return { status: "pending" };
-  }
+	/**
+	 * Setup IPC handlers for widget management (use in main.js)
+	 */
+	function setupWidgetRegistryHandlers() {
+	  ipcMain.handle("widget:list", () => getWidgetRegistry().getWidgets());
 
-  if (response.ok) {
-    const data = await response.json();
+	  ipcMain.handle("widget:get", (event, widgetName) => {
+	    return getWidgetRegistry().getWidget(widgetName);
+	  });
 
-    // Store the token securely
-    const s = getStore$1();
-    s.set("accessToken", data.access_token);
-    s.set("userId", data.user_id);
-    s.set("tokenType", data.token_type);
-    s.set("authenticatedAt", new Date().toISOString());
+	  ipcMain.handle(
+	    "widget:install",
+	    async (event, widgetName, downloadUrl, dashConfigUrl) => {
+	      const config = await getWidgetRegistry().downloadWidget(
+	        widgetName,
+	        downloadUrl,
+	        dashConfigUrl,
+	      );
 
-    return {
-      status: "authorized",
-      token: data.access_token,
-      userId: data.user_id,
-    };
-  }
+	      BrowserWindow.getAllWindows().forEach((win) => {
+	        win.webContents.send("widget:installed", {
+	          widgetName,
+	          config,
+	        });
+	      });
 
-  throw new Error(`Unexpected response: ${response.status}`);
-}
+	      return config;
+	    },
+	  );
 
-/**
- * Get the stored auth token.
- *
- * @returns {Object|null} { token, userId, authenticatedAt } or null if not authenticated
- */
-function getStoredToken$2() {
-  try {
-    const s = getStore$1();
-    const token = s.get("accessToken");
-    if (!token) return null;
+	  ipcMain.handle(
+	    "widget:install-local",
+	    async (event, widgetName, localPath, dashConfigPath) => {
+	      const config = await getWidgetRegistry().installFromLocalPath(
+	        widgetName,
+	        localPath,
+	        true,
+	        dashConfigPath,
+	      );
 
-    return {
-      token,
-      userId: s.get("userId"),
-      authenticatedAt: s.get("authenticatedAt"),
-    };
-  } catch {
-    return null;
-  }
-}
+	      BrowserWindow.getAllWindows().forEach((win) => {
+	        win.webContents.send("widget:installed", {
+	          widgetName,
+	          config,
+	        });
+	      });
 
-/**
- * Check if the user is authenticated with the registry.
- *
- * @returns {Object} { authenticated: boolean, userId?: string }
- */
-function getAuthStatus$1() {
-  const stored = getStoredToken$2();
-  if (!stored) {
-    return { authenticated: false };
-  }
+	      return config;
+	    },
+	  );
 
-  return {
-    authenticated: true,
-    userId: stored.userId,
-    authenticatedAt: stored.authenticatedAt,
-  };
-}
+	  ipcMain.handle("widget:load-folder", async (event, folderPath) => {
+	    const results = await getWidgetRegistry().registerWidgetsFromFolder(
+	      folderPath,
+	      true,
+	    );
 
-/**
- * Get the user's registry profile.
- *
- * @returns {Promise<Object|null>} User profile or null
- */
-async function getRegistryProfile$2() {
-  const stored = getStoredToken$2();
-  if (!stored) return null;
+	    BrowserWindow.getAllWindows().forEach((win) => {
+	      win.webContents.send("widgets:loaded", {
+	        count: results.length,
+	        widgets: results,
+	      });
+	    });
 
-  try {
-    const response = await fetch(`${REGISTRY_BASE_URL$1}/api/auth/me`, {
-      headers: {
-        Authorization: `Bearer ${stored.token}`,
-      },
-    });
+	    return results;
+	  });
 
-    if (response.status === 401) {
-      // Token expired or invalid — clear stored credentials
-      clearToken();
-      return null;
-    }
-    if (!response.ok) return null;
+	  ipcMain.handle("widget:uninstall", (event, widgetName) => {
+	    const schedulerController = schedulerController_1;
+	    schedulerController.cleanupWidget(widgetName);
+	    return getWidgetRegistry().uninstallWidget(widgetName);
+	  });
 
-    const data = await response.json();
-    return data.user || null;
-  } catch {
-    return null;
-  }
-}
+	  ipcMain.handle("widget:cache-path", () => getWidgetRegistry().getCachePath());
 
-/**
- * Clear stored auth token (logout).
- */
-function clearToken() {
-  try {
-    const s = getStore$1();
-    s.clear();
-    console.log("[RegistryAuthController] Token cleared");
-  } catch (err) {
-    console.error("[RegistryAuthController] Error clearing token:", err);
-  }
-}
+	  ipcMain.handle("widget:storage-path", () =>
+	    getWidgetRegistry().getStoragePath(),
+	  );
 
-/**
- * Update the authenticated user's registry profile.
- *
- * @param {Object} updates - Fields to update (e.g. { displayName })
- * @returns {Promise<Object|null>} Updated user or null on 401
- */
-async function updateRegistryProfile$1(updates) {
-  const stored = getStoredToken$2();
-  if (!stored) return null;
+	  ipcMain.handle("widget:get-component-configs", async () => {
+	    try {
+	      const registry = getWidgetRegistry();
+	      const installedWidgets = registry.getWidgets();
+	      const configs = [];
+
+	      for (const widget of installedWidgets) {
+	        const widgetPath = widget.path;
+	        if (!widgetPath || !fs.existsSync(widgetPath)) continue;
+
+	        const componentNames = dynamicWidgetLoader.discoverWidgets(widgetPath);
+	        const widgetsDir = findWidgetsDir(widgetPath);
+	        for (const componentName of componentNames) {
+	          try {
+	            const configPath = path.join(
+	              widgetsDir || path.join(widgetPath, "widgets"),
+	              `${componentName}.dash.js`,
+	            );
+	            const config = await dynamicWidgetLoader.loadConfigFile(configPath);
+	            configs.push({
+	              componentName,
+	              widgetPackage: widget.name,
+	              // Include scoped id if present in the config
+	              id: config.id || null,
+	              config,
+	            });
+	          } catch (err) {
+	            console.error(
+	              `[WidgetRegistry] Error loading config for ${componentName}:`,
+	              err,
+	            );
+	          }
+	        }
+	      }
 
-  try {
-    const response = await fetch(`${REGISTRY_BASE_URL$1}/api/auth/me`, {
-      method: "PATCH",
-      headers: {
-        Authorization: `Bearer ${stored.token}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(updates),
-    });
+	      return configs;
+	    } catch (error) {
+	      console.error("[WidgetRegistry] Error getting component configs:", error);
+	      return [];
+	    }
+	  });
 
-    if (response.status === 401) {
-      clearToken();
-      return null;
-    }
-    if (!response.ok) return null;
+	  ipcMain.handle("widget:read-bundle", async (event, widgetName) => {
+	    try {
+	      const registry = getWidgetRegistry();
+	      const widget = registry.getWidget(widgetName);
+	      if (!widget || !widget.path) {
+	        return {
+	          success: false,
+	          error: `Widget not found: ${widgetName}`,
+	        };
+	      }
 
-    const data = await response.json();
-    return data.user || null;
-  } catch {
-    return null;
-  }
-}
+	      let bundlePath = findBundlePath(widget.path);
 
-/**
- * Get the authenticated user's published packages.
- *
- * @returns {Promise<Object|null>} { packages: [...] } or null
- */
-async function getRegistryPackages$1() {
-  const stored = getStoredToken$2();
-  if (!stored) return null;
+	      // Auto-compile if no bundle exists (same as read-all-bundles)
+	      if (!bundlePath) {
+	        try {
+	          const compiled = await compileWidget(widget.path);
+	          if (compiled) {
+	            bundlePath = compiled;
+	          }
+	        } catch (compileError) {
+	          console.warn(
+	            `[WidgetRegistry] Could not compile ${widgetName}:`,
+	            compileError,
+	          );
+	        }
+	      }
 
-  try {
-    const response = await fetch(`${REGISTRY_BASE_URL$1}/api/auth/me/packages`, {
-      headers: {
-        Authorization: `Bearer ${stored.token}`,
-      },
-    });
+	      if (!bundlePath) {
+	        return {
+	          success: false,
+	          error: `No bundle found in: ${widget.path}`,
+	        };
+	      }
 
-    if (response.status === 401) {
-      clearToken();
-      return null;
-    }
-    if (!response.ok) return null;
+	      const source = fs.readFileSync(bundlePath, "utf8");
+	      return { success: true, source, widgetName };
+	    } catch (error) {
+	      console.error(
+	        `[WidgetRegistry] Error reading bundle for ${widgetName}:`,
+	        error,
+	      );
+	      return { success: false, error: error.message };
+	    }
+	  });
 
-    return await response.json();
-  } catch {
-    return null;
-  }
-}
+	  ipcMain.handle("widget:read-all-bundles", async () => {
+	    try {
+	      const registry = getWidgetRegistry();
+	      const installedWidgets = registry.getWidgets();
+	      const results = [];
 
-/**
- * Update a published package's metadata.
- *
- * @param {string} scope - Package scope (e.g. "@trops")
- * @param {string} name - Package name
- * @param {Object} updates - Fields to update (displayName, description, category, tags, visibility)
- * @returns {Promise<Object|null>} Updated package or null
- */
-async function updateRegistryPackage$1(scope, name, updates) {
-  const stored = getStoredToken$2();
-  if (!stored) return null;
+	      for (const widget of installedWidgets) {
+	        const widgetPath = widget.path;
+	        if (!widgetPath || !fs.existsSync(widgetPath)) continue;
 
-  try {
-    const response = await fetch(
-      `${REGISTRY_BASE_URL$1}/api/packages/${encodeURIComponent(scope)}/${encodeURIComponent(name)}`,
-      {
-        method: "PATCH",
-        headers: {
-          Authorization: `Bearer ${stored.token}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify(updates),
-      },
-    );
+	        let bundlePath = findBundlePath(widgetPath);
 
-    if (response.status === 401) {
-      clearToken();
-      return null;
-    }
-    if (!response.ok) return null;
+	        // Auto-compile if no bundle exists
+	        if (!bundlePath) {
+	          try {
+	            const compiled = await compileWidget(widgetPath);
+	            if (compiled) {
+	              bundlePath = compiled;
+	            }
+	          } catch (compileError) {
+	            console.warn(
+	              `[WidgetRegistry] Could not compile ${widget.name}:`,
+	              compileError,
+	            );
+	          }
+	        }
 
-    return await response.json();
-  } catch {
-    return null;
-  }
-}
+	        if (!bundlePath) {
+	          console.log(
+	            `[WidgetRegistry] No CJS bundle for ${widget.name}, skipping (will use config fallback)`,
+	          );
+	          continue;
+	        }
 
-/**
- * Delete a published package from the registry.
- *
- * @param {string} scope - Package scope (e.g. "@trops")
- * @param {string} name - Package name
- * @returns {Promise<Object|null>} Response or null
- */
-async function deleteRegistryPackage(scope, name) {
-  const stored = getStoredToken$2();
-  if (!stored) return null;
+	        try {
+	          const source = fs.readFileSync(bundlePath, "utf8");
+	          results.push({
+	            widgetName: widget.name,
+	            source,
+	          });
+	        } catch (readError) {
+	          console.error(
+	            `[WidgetRegistry] Error reading bundle for ${widget.name}:`,
+	            readError,
+	          );
+	        }
+	      }
 
-  try {
-    const response = await fetch(
-      `${REGISTRY_BASE_URL$1}/api/packages/${encodeURIComponent(scope)}/${encodeURIComponent(name)}`,
-      {
-        method: "DELETE",
-        headers: {
-          Authorization: `Bearer ${stored.token}`,
-        },
-      },
-    );
+	      return results;
+	    } catch (error) {
+	      console.error("[WidgetRegistry] Error reading all bundles:", error);
+	      return [];
+	    }
+	  });
 
-    if (response.status === 401) {
-      clearToken();
-      return null;
-    }
-    if (!response.ok) return null;
+	  ipcMain.handle("widget:set-storage-path", (event, customPath) => {
+	    try {
+	      WidgetRegistry.initialize(customPath);
+	      console.log(`[WidgetRegistry] Storage path changed to: ${customPath}`);
+	      return { success: true, path: customPath };
+	    } catch (error) {
+	      console.error("[WidgetRegistry] Error setting storage path:", error);
+	      return { success: false, error: error.message };
+	    }
+	  });
+	}
 
-    return await response.json();
-  } catch {
-    return null;
-  }
-}
+	module.exports = WidgetRegistry;
+	module.exports.getWidgetRegistry = getWidgetRegistry;
+	// For backward compatibility, provide widgetRegistry as a getter
+	Object.defineProperty(module.exports, "widgetRegistry", {
+	  get: getWidgetRegistry,
+	});
+	module.exports.setupWidgetRegistryHandlers = setupWidgetRegistryHandlers;
+	module.exports.validateZipEntries = validateZipEntries; 
+} (widgetRegistry$1));
 
-var registryAuthController$1 = {
-  initiateDeviceFlow: initiateDeviceFlow$1,
-  pollForToken: pollForToken$1,
-  getStoredToken: getStoredToken$2,
-  getAuthStatus: getAuthStatus$1,
-  getRegistryProfile: getRegistryProfile$2,
-  updateRegistryProfile: updateRegistryProfile$1,
-  getRegistryPackages: getRegistryPackages$1,
-  updateRegistryPackage: updateRegistryPackage$1,
-  deleteRegistryPackage,
-  clearToken,
-};
+var widgetRegistryExports = widgetRegistry$1.exports;
 
 /**
  * registryApiController.js
@@ -31806,7 +31806,7 @@ var registryAuthController$1 = {
 
 const fs = require$$0$3;
 const path$3 = require$$1$2;
-const { getStoredToken: getStoredToken$1 } = registryAuthController$1;
+const { getStoredToken: getStoredToken$2 } = registryAuthController$1;
 
 const REGISTRY_BASE_URL =
   process.env.DASH_REGISTRY_API_URL ||
@@ -31820,7 +31820,7 @@ const REGISTRY_BASE_URL =
  * @returns {Promise<Object>} { success, registryUrl, packageId, version, error? }
  */
 async function publishToRegistry$1(zipPath, manifest) {
-  const auth = getStoredToken$1();
+  const auth = getStoredToken$2();
   if (!auth) {
     return {
       success: false,
@@ -31912,7 +31912,7 @@ const registryApiController$1 = registryApiController$2;
 const {
   getAuthStatus,
   getRegistryProfile: getRegistryProfile$1,
-  getStoredToken,
+  getStoredToken: getStoredToken$1,
 } = registryAuthController$1;
 
 /**
@@ -32159,7 +32159,7 @@ async function installThemeFromRegistry$1(win, appId, packageName) {
 
     // Download the ZIP (with auth header)
     const headers = {};
-    const auth = getStoredToken();
+    const auth = getStoredToken$1();
     if (auth?.token) {
       headers["Authorization"] = `Bearer ${auth.token}`;
     }
@@ -32324,6 +32324,7 @@ const {
   applyEventWiringToLayout,
 } = dashboardConfigUtils$1;
 const { searchRegistry, getPackage } = registryController$3;
+const { getStoredToken } = registryAuthController$1;
 const themeController$3 = themeController_1;
 
 const configFilename = "workspaces.json";
@@ -32947,7 +32948,13 @@ async function installDashboardFromRegistry$1(
       `[DashboardConfigController] Fetching dashboard from: ${downloadUrl}`,
     );
 
-    const response = await fetch(downloadUrl);
+    // Download the ZIP (with auth header)
+    const headers = {};
+    const auth = getStoredToken();
+    if (auth?.token) {
+      headers["Authorization"] = `Bearer ${auth.token}`;
+    }
+    const response = await fetch(downloadUrl, { headers });
     if (!response.ok) {
       return {
         success: false,