@trops/dash-core 0.1.20 → 0.1.22

package/dist/electron/index.js

@@ -513,6 +513,24 @@ var openaiEvents$1 = {
   OPENAI_DESCRIBE_IMAGE_ERROR,
 };
 
+/**
+ * Event Constants File - Client Cache Events
+ *
+ * This file contains event constants for client cache management IPC communication.
+ */
+
+const CLIENT_CACHE_INVALIDATE$1 = "client-cache-invalidate";
+const CLIENT_CACHE_INVALIDATE_ALL$1 = "client-cache-invalidate-all";
+const RESPONSE_CACHE_CLEAR$1 = "response-cache-clear";
+const RESPONSE_CACHE_STATS$1 = "response-cache-stats";
+
+var clientCacheEvents$1 = {
+  CLIENT_CACHE_INVALIDATE: CLIENT_CACHE_INVALIDATE$1,
+  CLIENT_CACHE_INVALIDATE_ALL: CLIENT_CACHE_INVALIDATE_ALL$1,
+  RESPONSE_CACHE_CLEAR: RESPONSE_CACHE_CLEAR$1,
+  RESPONSE_CACHE_STATS: RESPONSE_CACHE_STATS$1,
+};
+
 /**
  * Events
  *
@@ -532,6 +550,7 @@ const registryEvents = registryEvents$1;
 const algoliaEvents = algoliaEvents$1;
 const menuItemEvents = menuItemEvents$1;
 const openaiEvents = openaiEvents$1;
+const clientCacheEvents = clientCacheEvents$1;
 
 const publicEvents = {
   ...dataEvents,
@@ -552,6 +571,7 @@ var events$8 = {
   ...algoliaEvents,
   ...menuItemEvents,
   ...openaiEvents,
+  ...clientCacheEvents,
 };
 
 /**
@@ -585,7 +605,7 @@ var dialogController$1 = {
  * secureStore
  */
 
-const { safeStorage: safeStorage$1 } = require$$0;
+const { safeStorage } = require$$0;
 const Store = require$$1;
 const events$6 = events$8;
 
@@ -599,17 +619,17 @@ const schema = {
 };
 
 const isEncryptionAvailable$1 = (win) => {
-  const result = safeStorage$1.isEncryptionAvailable();
+  const result = safeStorage.isEncryptionAvailable();
   win.webContents.send(events$6.SECURE_STORE_ENCRYPTION_CHECK_COMPLETE, result);
 };
 
 const encryptString = (win, str) => {
-  const result = safeStorage$1.encryptString(str);
+  const result = safeStorage.encryptString(str);
   win.webContents.send("secure-storage-encrypt-string-complete", result);
 };
 
 const decryptString = (win, str) => {
-  const result = safeStorage$1.decryptString(str);
+  const result = safeStorage.decryptString(str);
   win.webContents.send("secure-storage-decrypt-string-complete", result);
 };
 
@@ -645,10 +665,10 @@ var secureStoreController$1 = {
   getData: getData$1,
 };
 
-const path$e = require$$1$1;
+const path$d = require$$1$1;
 const {
   readFileSync,
-  writeFileSync: writeFileSync$5,
+  writeFileSync: writeFileSync$4,
   existsSync,
   mkdirSync,
   openSync,
@@ -660,10 +680,10 @@ const {
   lstatSync,
 } = require$$2;
 
-function ensureDirectoryExistence$3(filePath) {
+function ensureDirectoryExistence$2(filePath) {
   try {
     // isDirectory
-    var dirname = path$e.dirname(filePath);
+    var dirname = path$d.dirname(filePath);
     // check if the directory exists...return true
     // if not, we can pass in the dirname as the filepath
     // and check each directory recursively.
@@ -671,7 +691,7 @@ function ensureDirectoryExistence$3(filePath) {
       return true;
     }
     // recursion...
-    ensureDirectoryExistence$3(dirname);
+    ensureDirectoryExistence$2(dirname);
     mkdirSync(dirname);
   } catch (e) {
     console.log("ensure directory " + e.message);
@@ -714,10 +734,10 @@ function checkDirectory$1(dir) {
  * @param {string} filepath path to the file
  * @returns
  */
-function getFileContents$7(filepath, defaultReturn = []) {
+function getFileContents$6(filepath, defaultReturn = []) {
   try {
     // lets first make sure all is there...
-    ensureDirectoryExistence$3(filepath);
+    ensureDirectoryExistence$2(filepath);
 
     // and now lets read the file...
     let fileContents = JSON.stringify(defaultReturn);
@@ -739,13 +759,13 @@ function getFileContents$7(filepath, defaultReturn = []) {
 
         // Reinitialize with default content
         fileContentsArray = defaultReturn;
-        writeFileSync$5(filepath, JSON.stringify(defaultReturn, null, 2));
+        writeFileSync$4(filepath, JSON.stringify(defaultReturn, null, 2));
         console.log(`[File] Successfully reinitialized: ${filepath}`);
       }
     } else {
       // we should make the file with default content
       closeSync(openSync(filepath, "w"));
-      writeFileSync$5(filepath, JSON.stringify(defaultReturn, null, 2));
+      writeFileSync$4(filepath, JSON.stringify(defaultReturn, null, 2));
     }
 
     return fileContentsArray;
@@ -755,10 +775,10 @@ function getFileContents$7(filepath, defaultReturn = []) {
   }
 }
 
-function writeToFile$3(filename, data) {
+function writeToFile$2(filename, data) {
   try {
     // write the new pages configuration back to the file
-    return writeFileSync$5(filename, data);
+    return writeFileSync$4(filename, data);
   } catch (e) {
     return false;
   }
@@ -778,7 +798,7 @@ function removeFilesFromDirectory(directory, excludeFiles = []) {
 
       for (const file of files) {
         if (!excludeFiles.includes(file)) {
-          unlinkSync(path$e.join(directory, file), (err) => {
+          unlinkSync(path$d.join(directory, file), (err) => {
             if (err) throw err;
           });
         }
@@ -788,20 +808,20 @@ function removeFilesFromDirectory(directory, excludeFiles = []) {
 }
 
 var file = {
-  ensureDirectoryExistence: ensureDirectoryExistence$3,
-  getFileContents: getFileContents$7,
-  writeToFile: writeToFile$3,
+  ensureDirectoryExistence: ensureDirectoryExistence$2,
+  getFileContents: getFileContents$6,
+  writeToFile: writeToFile$2,
   removeFilesFromDirectory,
   checkDirectory: checkDirectory$1,
 };
 
-const { app: app$8 } = require$$0;
-const path$d = require$$1$1;
-const { writeFileSync: writeFileSync$4 } = require$$2;
-const { getFileContents: getFileContents$6 } = file;
+const { app: app$7 } = require$$0;
+const path$c = require$$1$1;
+const { writeFileSync: writeFileSync$3 } = require$$2;
+const { getFileContents: getFileContents$5 } = file;
 
-const configFilename$5 = "workspaces.json";
-const appName$6 = "Dashboard";
+const configFilename$4 = "workspaces.json";
+const appName$5 = "Dashboard";
 
 const workspaceController$1 = {
   /**
@@ -843,13 +863,13 @@ const workspaceController$1 = {
   saveWorkspaceForApplication: (win, appId, workspaceObject) => {
     try {
       // filename to the pages file (live pages)
-      const filename = path$d.join(
-        app$8.getPath("userData"),
-        appName$6,
+      const filename = path$c.join(
+        app$7.getPath("userData"),
+        appName$5,
         appId,
-        configFilename$5,
+        configFilename$4,
       );
-      const workspacesArray = getFileContents$6(filename);
+      const workspacesArray = getFileContents$5(filename);
 
       // lets check to see if we already have this one!
       let indexOfExistingItem = null;
@@ -869,7 +889,7 @@ const workspaceController$1 = {
       }
 
       // write the new pages configuration back to the file
-      writeFileSync$4(filename, JSON.stringify(workspacesArray, null, 2));
+      writeFileSync$3(filename, JSON.stringify(workspacesArray, null, 2));
 
       console.log("[workspaceController] Workspace saved successfully");
 
@@ -892,13 +912,13 @@ const workspaceController$1 = {
   saveMenuItemsForApplication: (win, appId, menuItems) => {
     try {
       // filename to the workspaces file
-      const filename = path$d.join(
-        app$8.getPath("userData"),
-        appName$6,
+      const filename = path$c.join(
+        app$7.getPath("userData"),
+        appName$5,
         appId,
-        configFilename$5,
+        configFilename$4,
       );
-      const workspacesArray = getFileContents$6(filename);
+      const workspacesArray = getFileContents$5(filename);
 
       // Update menu items for workspaces
       // This assumes menuItems is an object with workspace IDs as keys
@@ -912,7 +932,7 @@ const workspaceController$1 = {
       }
 
       // write the updated workspaces configuration back to the file
-      writeFileSync$4(filename, JSON.stringify(workspacesArray, null, 2));
+      writeFileSync$3(filename, JSON.stringify(workspacesArray, null, 2));
 
       console.log("[workspaceController] Menu items saved successfully");
 
@@ -941,19 +961,19 @@ const workspaceController$1 = {
    */
   deleteWorkspaceForApplication: (win, appId, workspaceId) => {
     try {
-      const filename = path$d.join(
-        app$8.getPath("userData"),
-        appName$6,
+      const filename = path$c.join(
+        app$7.getPath("userData"),
+        appName$5,
         appId,
-        configFilename$5,
+        configFilename$4,
       );
-      const workspacesArray = getFileContents$6(filename);
+      const workspacesArray = getFileContents$5(filename);
 
       const filtered = workspacesArray.filter(
         (workspace) => workspace.id !== workspaceId,
       );
 
-      writeFileSync$4(filename, JSON.stringify(filtered, null, 2));
+      writeFileSync$3(filename, JSON.stringify(filtered, null, 2));
 
       console.log(
         `[workspaceController] Workspace ${workspaceId} deleted successfully`,
@@ -975,14 +995,14 @@ const workspaceController$1 = {
 
   listWorkspacesForApplication: (win, appId) => {
     try {
-      const filename = path$d.join(
-        app$8.getPath("userData"),
-        appName$6,
+      const filename = path$c.join(
+        app$7.getPath("userData"),
+        appName$5,
         appId,
-        configFilename$5,
+        configFilename$4,
       );
 
-      const workspacesArray = getFileContents$6(filename);
+      const workspacesArray = getFileContents$5(filename);
       console.log(
         `[workspaceController] Loaded ${workspacesArray.length} workspaces for appId: ${appId}`,
       );
@@ -1003,13 +1023,13 @@ const workspaceController$1 = {
 
   listMenuItemsForApplication: (win, appId) => {
     try {
-      const filename = path$d.join(
-        app$8.getPath("userData"),
-        appName$6,
+      const filename = path$c.join(
+        app$7.getPath("userData"),
+        appName$5,
         appId,
-        configFilename$5,
+        configFilename$4,
       );
-      const workspacesArray = getFileContents$6(filename);
+      const workspacesArray = getFileContents$5(filename);
 
       // Extract unique menu items from workspaces
       // Each workspace can have a menuId, we need to build the menu items list
@@ -1047,13 +1067,13 @@ const workspaceController$1 = {
 
 var workspaceController_1 = workspaceController$1;
 
-const { app: app$7 } = require$$0;
-const path$c = require$$1$1;
-const { writeFileSync: writeFileSync$3 } = require$$2;
-const { getFileContents: getFileContents$5 } = file;
+const { app: app$6 } = require$$0;
+const path$b = require$$1$1;
+const { writeFileSync: writeFileSync$2 } = require$$2;
+const { getFileContents: getFileContents$4 } = file;
 
-const configFilename$4 = "themes.json";
-const appName$5 = "Dashboard";
+const configFilename$3 = "themes.json";
+const appName$4 = "Dashboard";
 
 const themeController$1 = {
   /**
@@ -1068,13 +1088,13 @@ const themeController$1 = {
   saveThemeForApplication: (win, appId, name, obj) => {
     try {
       // filename to the pages file (live pages)
-      const filename = path$c.join(
-        app$7.getPath("userData"),
-        appName$5,
+      const filename = path$b.join(
+        app$6.getPath("userData"),
+        appName$4,
         appId,
-        configFilename$4,
+        configFilename$3,
       );
-      const data = getFileContents$5(filename, {});
+      const data = getFileContents$4(filename, {});
 
       // Add/update the theme based on the name
       if (name in data === false) {
@@ -1084,7 +1104,7 @@ const themeController$1 = {
       data[name] = obj;
 
       // write the new pages configuration back to the file
-      writeFileSync$3(filename, JSON.stringify(data, null, 2));
+      writeFileSync$2(filename, JSON.stringify(data, null, 2));
 
       console.log("[themeController] Theme saved successfully");
 
@@ -1114,14 +1134,14 @@ const themeController$1 = {
    */
   listThemesForApplication: (win, appId) => {
     try {
-      const filename = path$c.join(
-        app$7.getPath("userData"),
-        appName$5,
+      const filename = path$b.join(
+        app$6.getPath("userData"),
+        appName$4,
         appId,
-        configFilename$4,
+        configFilename$3,
       );
 
-      const data = getFileContents$5(filename, {});
+      const data = getFileContents$4(filename, {});
 
       console.log(
         "[themeController] Loading themes from:",
@@ -1156,17 +1176,17 @@ const themeController$1 = {
    */
   deleteThemeForApplication: (win, appId, themeKey) => {
     try {
-      const filename = path$c.join(
-        app$7.getPath("userData"),
-        appName$5,
+      const filename = path$b.join(
+        app$6.getPath("userData"),
+        appName$4,
         appId,
-        configFilename$4,
+        configFilename$3,
       );
-      const data = getFileContents$5(filename, {});
+      const data = getFileContents$4(filename, {});
 
       if (themeKey in data) {
         delete data[themeKey];
-        writeFileSync$3(filename, JSON.stringify(data, null, 2));
+        writeFileSync$2(filename, JSON.stringify(data, null, 2));
       }
 
       console.log("[themeController] Theme deleted successfully:", themeKey);
@@ -1203,9 +1223,9 @@ var xmlParser = require$$3;
 var JSONStream$1 = require$$4;
 const stream = require$$5;
 var csv = require$$6;
-const path$b = require$$1$1;
-const { app: app$6 } = require$$0;
-const { ensureDirectoryExistence: ensureDirectoryExistence$2 } = file;
+const path$a = require$$1$1;
+const { app: app$5 } = require$$0;
+const { ensureDirectoryExistence: ensureDirectoryExistence$1 } = file;
 
 const TRANSFORM_APP_NAME = "Dashboard";
 const MAX_MAPPING_BODY_SIZE = 10240; // 10KB limit for mapping function body
@@ -1492,18 +1512,18 @@ let Transform$1 = class Transform {
       }
 
       // Validate file paths are within app data directory
-      const appDataDir = path$b.join(app$6.getPath("userData"), TRANSFORM_APP_NAME);
-      const resolvedFilepath = path$b.resolve(filepath);
-      const resolvedOutFilepath = path$b.resolve(outFilepath);
+      const appDataDir = path$a.join(app$5.getPath("userData"), TRANSFORM_APP_NAME);
+      const resolvedFilepath = path$a.resolve(filepath);
+      const resolvedOutFilepath = path$a.resolve(outFilepath);
 
-      if (!resolvedFilepath.startsWith(appDataDir + path$b.sep)) {
+      if (!resolvedFilepath.startsWith(appDataDir + path$a.sep)) {
         return reject(
           new Error(
             "Input file path must be within the application data directory",
           ),
         );
       }
-      if (!resolvedOutFilepath.startsWith(appDataDir + path$b.sep)) {
+      if (!resolvedOutFilepath.startsWith(appDataDir + path$a.sep)) {
         return reject(
           new Error(
             "Output file path must be within the application data directory",
@@ -1519,7 +1539,7 @@ let Transform$1 = class Transform {
         // create the readStream to parse the large file (json)
         var readStream = fs$8.createReadStream(resolvedFilepath).pipe(parser);
 
-        ensureDirectoryExistence$2(resolvedOutFilepath);
+        ensureDirectoryExistence$1(resolvedOutFilepath);
 
         var writeStream = fs$8.createWriteStream(resolvedOutFilepath);
 
@@ -3361,18 +3381,18 @@ async function extractColorsFromImageURL$2(url, toDirectory) {
 
 var color = { extractColorsFromImageURL: extractColorsFromImageURL$2 };
 
-const { app: app$5 } = require$$0;
+const { app: app$4 } = require$$0;
 var fs$7 = require$$2;
-const path$a = require$$1$1;
+const path$9 = require$$1$1;
 const events$5 = events$8;
-const { getFileContents: getFileContents$4, writeToFile: writeToFile$2 } = file;
+const { getFileContents: getFileContents$3, writeToFile: writeToFile$1 } = file;
 
 // Convert Json to Csv
 const ObjectsToCsv = require$$5$1;
 const Transform = transform;
 const { extractColorsFromImageURL: extractColorsFromImageURL$1 } = color;
 const https = require$$8;
-const appName$4 = "Dashboard";
+const appName$3 = "Dashboard";
 
 const dataController$1 = {
   /**
@@ -3386,16 +3406,16 @@ const dataController$1 = {
   convertJsonToCsvFile: (win, appId, jsonObject, toFilename = "test.csv") => {
     try {
       // filename to the pages file (live pages)
-      const filename = path$a.join(
-        app$5.getPath("userData"),
-        appName$4,
+      const filename = path$9.join(
+        app$4.getPath("userData"),
+        appName$3,
         appId,
         "data",
         toFilename,
       );
 
       // make sure the file exists...
-      const fileContents = getFileContents$4(filename, "");
+      const fileContents = getFileContents$3(filename, "");
 
       const csv = new ObjectsToCsv(jsonObject);
 
@@ -3514,9 +3534,9 @@ const dataController$1 = {
       }
 
       // Validate toFilepath is within the app data directory
-      const appDataDir = path$a.join(app$5.getPath("userData"), appName$4);
-      const resolvedFilepath = path$a.resolve(toFilepath);
-      if (!resolvedFilepath.startsWith(appDataDir + path$a.sep)) {
+      const appDataDir = path$9.join(app$4.getPath("userData"), appName$3);
+      const resolvedFilepath = path$9.resolve(toFilepath);
+      if (!resolvedFilepath.startsWith(appDataDir + path$9.sep)) {
         throw new Error(
           "File path must be within the application data directory",
         );
@@ -3663,9 +3683,9 @@ const dataController$1 = {
     try {
       if (data) {
         // filename to the pages file (live pages)
-        const toFilename = path$a.join(
-          app$5.getPath("userData"),
-          appName$4,
+        const toFilename = path$9.join(
+          app$4.getPath("userData"),
+          appName$3,
           "data",
           filename,
         );
@@ -3673,7 +3693,7 @@ const dataController$1 = {
         //console.log("saving to file ", toFilename);
 
         // // call this to make sure the directory structure exists
-        let fileContents = getFileContents$4(toFilename, returnEmpty);
+        let fileContents = getFileContents$3(toFilename, returnEmpty);
         if (fileContents === null || fileContents === "") {
           fileContents = JSON.stringify(returnEmpty);
         }
@@ -3689,7 +3709,7 @@ const dataController$1 = {
             const tempWriteContents = JSON.parse(fileContents);
             tempWriteContents[stamp] = data;
             writeContents = JSON.stringify(tempWriteContents);
-            writeToFile$2(toFilename, writeContents);
+            writeToFile$1(toFilename, writeContents);
           }
 
           if (JSON.stringify(returnEmpty) === "[]") {
@@ -3698,20 +3718,20 @@ const dataController$1 = {
             writeContents = JSON.stringify(tempWriteContents);
             // writeContents = JSON.parse(fileContents);
             // writeContents.push({ [stamp]: data });
-            writeToFile$2(toFilename, writeContents);
+            writeToFile$1(toFilename, writeContents);
           }
         } else {
           // overwrite existing
           writeContents = JSON.stringify(data);
           if (JSON.stringify(returnEmpty) === "{}") {
-            writeToFile$2(
+            writeToFile$1(
               toFilename,
               writeContents,
               // JSON.stringify({ [stamp]: data })
             );
           }
           if (JSON.stringify(returnEmpty) === "[]") {
-            writeToFile$2(
+            writeToFile$1(
               toFilename,
               writeContents,
               // JSON.stringify([{ [stamp]: data }])
@@ -3745,15 +3765,15 @@ const dataController$1 = {
     try {
       if (filename) {
         // filename to the pages file (live pages)
-        const fromFilename = path$a.join(
-          app$5.getPath("userData"),
-          appName$4,
+        const fromFilename = path$9.join(
+          app$4.getPath("userData"),
+          appName$3,
           "data",
           filename,
         );
         console.log("reading from file ", fromFilename, returnIfEmpty);
         // make sure the file exists...
-        const fileContents = getFileContents$4(fromFilename, returnIfEmpty);
+        const fileContents = getFileContents$3(fromFilename, returnIfEmpty);
 
         console.log("file contents ", fileContents, fromFilename);
 
@@ -3823,9 +3843,9 @@ const dataController$1 = {
     try {
       console.log(url);
       const fileExtension = ".jpg";
-      const filename = path$a.join(
-        app$5.getPath("userData"),
-        appName$4,
+      const filename = path$9.join(
+        app$4.getPath("userData"),
+        appName$3,
         "@algolia/dash-electron",
         "data",
         "imageExtract" + fileExtension,
@@ -3848,13 +3868,13 @@ var dataController_1 = dataController$1;
  * settingsController
  */
 
-const { app: app$4 } = require$$0;
-const path$9 = require$$1$1;
+const { app: app$3 } = require$$0;
+const path$8 = require$$1$1;
 const fs$6 = require$$2;
-const { getFileContents: getFileContents$3, writeToFile: writeToFile$1 } = file;
+const { getFileContents: getFileContents$2, writeToFile } = file;
 
-const configFilename$3 = "settings.json";
-const appName$3 = "Dashboard";
+const configFilename$2 = "settings.json";
+const appName$2 = "Dashboard";
 
 // Helper function to recursively copy directory
 function copyDirectory(source, destination) {
@@ -3864,8 +3884,8 @@ function copyDirectory(source, destination) {
 
   const files = fs$6.readdirSync(source);
   for (const file of files) {
-    const srcPath = path$9.join(source, file);
-    const destPath = path$9.join(destination, file);
+    const srcPath = path$8.join(source, file);
+    const destPath = path$8.join(destination, file);
     const stat = fs$6.lstatSync(srcPath);
 
     // Skip symlinks to prevent following links to sensitive files
@@ -3893,12 +3913,12 @@ const settingsController$1 = {
     try {
       if (data) {
         // <appId>/settings.json
-        const filename = path$9.join(
-          app$4.getPath("userData"),
-          appName$3,
-          configFilename$3,
+        const filename = path$8.join(
+          app$3.getPath("userData"),
+          appName$2,
+          configFilename$2,
         );
-        writeToFile$1(filename, JSON.stringify(data, null, 2));
+        writeToFile(filename, JSON.stringify(data, null, 2));
         console.log("[settingsController] Settings saved successfully");
         // Return the data for ipcMain.handle() - modern promise-based approach
         return {
@@ -3929,13 +3949,13 @@ const settingsController$1 = {
   getSettingsForApplication: (win) => {
     try {
       // <appId>/settings.json
-      const filename = path$9.join(
-        app$4.getPath("userData"),
-        appName$3,
-        configFilename$3,
+      const filename = path$8.join(
+        app$3.getPath("userData"),
+        appName$2,
+        configFilename$2,
       );
       // make sure the file exists...
-      const fileContents = getFileContents$3(filename, {});
+      const fileContents = getFileContents$2(filename, {});
       console.log("[settingsController] Settings loaded successfully");
       // Return the data for ipcMain.handle() - modern promise-based approach
       return {
@@ -3960,15 +3980,15 @@ const settingsController$1 = {
    */
   getDataDirectory: (win) => {
     try {
-      const settingsPath = path$9.join(
-        app$4.getPath("userData"),
-        appName$3,
-        configFilename$3,
+      const settingsPath = path$8.join(
+        app$3.getPath("userData"),
+        appName$2,
+        configFilename$2,
       );
-      const settings = getFileContents$3(settingsPath, {});
+      const settings = getFileContents$2(settingsPath, {});
       const userDataDir =
         settings.userDataDirectory ||
-        path$9.join(app$4.getPath("userData"), appName$3);
+        path$8.join(app$3.getPath("userData"), appName$2);
 
       console.log("[settingsController] Data directory retrieved successfully");
       // Return the data for ipcMain.handle() - modern promise-based approach
@@ -4005,14 +4025,14 @@ const settingsController$1 = {
       }
 
       // Update settings
-      const settingsPath = path$9.join(
-        app$4.getPath("userData"),
-        appName$3,
-        configFilename$3,
+      const settingsPath = path$8.join(
+        app$3.getPath("userData"),
+        appName$2,
+        configFilename$2,
       );
-      const settings = getFileContents$3(settingsPath, {});
+      const settings = getFileContents$2(settingsPath, {});
       settings.userDataDirectory = newPath;
-      writeToFile$1(settingsPath, JSON.stringify(settings, null, 2));
+      writeToFile(settingsPath, JSON.stringify(settings, null, 2));
 
       console.log("[settingsController] Data directory set successfully");
       // Return the data for ipcMain.handle() - modern promise-based approach
@@ -4039,20 +4059,20 @@ const settingsController$1 = {
   migrateDataDirectory: (win, oldPath, newPath) => {
     try {
       // Resolve paths to prevent traversal
-      const resolvedOldPath = path$9.resolve(oldPath);
-      const resolvedNewPath = path$9.resolve(newPath);
+      const resolvedOldPath = path$8.resolve(oldPath);
+      const resolvedNewPath = path$8.resolve(newPath);
 
       // Validate oldPath is the current configured data directory
-      const settingsCheckPath = path$9.join(
-        app$4.getPath("userData"),
-        appName$3,
-        configFilename$3,
+      const settingsCheckPath = path$8.join(
+        app$3.getPath("userData"),
+        appName$2,
+        configFilename$2,
       );
-      const currentSettings = getFileContents$3(settingsCheckPath, {});
+      const currentSettings = getFileContents$2(settingsCheckPath, {});
       const currentDataDir =
         currentSettings.userDataDirectory ||
-        path$9.join(app$4.getPath("userData"), appName$3);
-      if (resolvedOldPath !== path$9.resolve(currentDataDir)) {
+        path$8.join(app$3.getPath("userData"), appName$2);
+      if (resolvedOldPath !== path$8.resolve(currentDataDir)) {
         throw new Error("Source path must be the current data directory");
       }
 
@@ -4088,14 +4108,14 @@ const settingsController$1 = {
       copyDirectory(resolvedOldPath, resolvedNewPath);
 
       // Update settings to use new path
-      const settingsPath = path$9.join(
-        app$4.getPath("userData"),
-        appName$3,
-        configFilename$3,
+      const settingsPath = path$8.join(
+        app$3.getPath("userData"),
+        appName$2,
+        configFilename$2,
       );
-      const settings = getFileContents$3(settingsPath, {});
+      const settings = getFileContents$2(settingsPath, {});
       settings.userDataDirectory = resolvedNewPath;
-      writeToFile$1(settingsPath, JSON.stringify(settings, null, 2));
+      writeToFile(settingsPath, JSON.stringify(settings, null, 2));
 
       console.log("[settingsController] Data directory migrated successfully");
       // Return the data for ipcMain.handle() - modern promise-based approach
@@ -4117,285 +4137,543 @@ const settingsController$1 = {
 var settingsController_1 = settingsController$1;
 
 /**
- * providerController.js
+ * responseCache.js
  *
- * Handle provider (credentials) management with encryption
- * Saves encrypted credentials to ~/.userData/Dashboard/{appId}/providers.json
+ * TTL-based API response cache with in-flight deduplication.
+ * Renderer-driven: widget developer includes { cache: true } or { cache: { ttl: N } }
+ * in IPC messages to opt-in to caching per call.
+ *
+ * Usage:
+ *   // Wrap a handler:
+ *   ipcMain.handle("my-channel", responseCache.cachedHandler("my-channel", handler));
+ *
+ *   // Widget-side (renderer):
+ *   window.mainApi.myService.getData({ ...pc, cache: true });              // 30s default
+ *   window.mainApi.myService.getData({ ...pc, cache: 60000 });             // 60s
+ *   window.mainApi.myService.getData({ ...pc, cache: { ttl: 120000 } });   // 120s
+ *   window.mainApi.myService.getData({ ...pc, cache: true, forceRefresh: true }); // bypass
  */
 
-const { app: app$3, safeStorage } = require$$0;
-const path$8 = require$$1$1;
-const { writeFileSync: writeFileSync$2 } = require$$2;
-const {
-  ensureDirectoryExistence: ensureDirectoryExistence$1,
-  getFileContents: getFileContents$2,
-  writeToFile,
-} = file;
+const cache = new Map(); // key → { data, timestamp, ttl }
+const inflight = new Map(); // key → Promise
 
-const appName$2 = "Dashboard";
-const configFilename$2 = "providers.json";
+function stableHash(obj) {
+  const str = JSON.stringify(obj, Object.keys(obj).sort());
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0xffffffff;
+  }
+  return hash.toString(36);
+}
+
+const responseCache$1 = {
+  async get(key, fetcher, options = {}) {
+    const { ttl = 30000, forceRefresh = false } = options;
+
+    if (!forceRefresh && cache.has(key)) {
+      const entry = cache.get(key);
+      if (Date.now() - entry.timestamp < entry.ttl) {
+        console.log(`[responseCache] HIT ${key}`);
+        return entry.data;
+      }
+      cache.delete(key);
+    }
+
+    if (!forceRefresh && inflight.has(key)) {
+      console.log(`[responseCache] DEDUP ${key}`);
+      return inflight.get(key);
+    }
+
+    console.log(`[responseCache] MISS ${key}`);
+    const promise = fetcher();
+    inflight.set(key, promise);
+    try {
+      const data = await promise;
+      if (data && !data.error) {
+        cache.set(key, { data, timestamp: Date.now(), ttl });
+      }
+      return data;
+    } finally {
+      inflight.delete(key);
+    }
+  },
 
-const providerController$2 = {
   /**
-   * saveProvider
-   * Save a new provider with encrypted credentials
+   * Wrap an ipcMain.handle handler with renderer-driven caching.
+   * If the incoming message has a `cache` property, the response is cached.
+   * If the message has `forceRefresh: true`, the cache is bypassed.
    *
-   * @param {BrowserWindow} win the main window
-   * @param {string} appId the application id
-   * @param {string} providerName user-defined name (e.g., "Algolia Production")
-   * @param {string} providerType provider type (e.g., "algolia", "slack")
-   * @param {object} credentials credentials object
-   * @param {string} providerClass "credential" (default) or "mcp"
-   * @param {object} mcpConfig MCP server config (transport, command, args, envMapping) - only for providerClass "mcp"
+   * The `cache` and `forceRefresh` properties are stripped from the message
+   * before passing to the handler, so handlers receive clean params.
+   *
+   * Cache parameter forms:
+   *   cache: true         → 30s default TTL
+   *   cache: 60000        → 60s (number shorthand)
+   *   cache: { ttl: N }   → explicit TTL in ms
    */
-  saveProvider: (
-    win,
-    appId,
-    providerName,
-    providerType,
-    credentials,
-    providerClass = "credential",
-    mcpConfig = null,
-  ) => {
-    try {
-      // Build file path
-      const filename = path$8.join(
-        app$3.getPath("userData"),
-        appName$2,
-        appId,
-        configFilename$2,
-      );
+  cachedHandler(channelName, handler) {
+    return async (e, msg) => {
+      const { cache: cacheOpt, forceRefresh, ...params } = msg || {};
+      if (cacheOpt) {
+        const ttl =
+          typeof cacheOpt === "number" ? cacheOpt : cacheOpt?.ttl || 30000;
+        const key = `${channelName}:${stableHash(params)}`;
+        return this.get(key, () => handler(e, params), {
+          ttl,
+          forceRefresh,
+        });
+      }
+      return handler(e, msg);
+    };
+  },
 
-      // Ensure directory exists
-      ensureDirectoryExistence$1(filename);
+  invalidate(key) {
+    cache.delete(key);
+  },
 
-      // Load existing providers
-      const providers = getFileContents$2(filename, {});
+  invalidatePrefix(prefix) {
+    for (const k of cache.keys()) {
+      if (k.startsWith(prefix)) cache.delete(k);
+    }
+  },
 
-      // Encrypt credentials
-      const credentialsJson = JSON.stringify(credentials);
-      const encryptedCredentials = safeStorage.encryptString(credentialsJson);
+  clear() {
+    cache.clear();
+    inflight.clear();
+  },
 
-      // Add/update provider
-      const providerEntry = {
-        type: providerType,
-        providerClass: providerClass || "credential",
-        credentials: encryptedCredentials.toString("base64"),
-        dateCreated:
-          providers[providerName]?.dateCreated || new Date().toISOString(),
-        dateUpdated: new Date().toISOString(),
-      };
+  stats() {
+    return {
+      entries: cache.size,
+      inflight: inflight.size,
+      keys: [...cache.keys()],
+    };
+  },
+};
 
-      // Add mcpConfig for MCP providers
-      if (providerClass === "mcp" && mcpConfig) {
-        providerEntry.mcpConfig = mcpConfig;
-      }
+var responseCache_1 = responseCache$1;
 
-      providers[providerName] = providerEntry;
+/**
+ * clientCache
+ *
+ * Generic provider client cache for the main process.
+ * Caches API clients (e.g., algoliasearch, Stripe) by provider hash.
+ * Factories are registered per provider type; credentials are resolved
+ * from the encrypted store — renderer never sends credential fields.
+ */
 
-      // Save to file with restrictive permissions (owner read/write only)
-      writeFileSync$2(filename, JSON.stringify(providers, null, 2), {
-        mode: 0o600,
-      });
+var clientCache_1;
+var hasRequiredClientCache;
 
-      console.log(
-        `[providerController] Provider saved: ${providerName} (${providerType}, ${providerClass})`,
-      );
+function requireClientCache () {
+	if (hasRequiredClientCache) return clientCache_1;
+	hasRequiredClientCache = 1;
+	const providerController = requireProviderController();
 
-      // Return the data for ipcMain.handle() - modern promise-based approach
-      return {
-        success: true,
-        providerName,
-        providerType,
-        providerClass,
-      };
-    } catch (error) {
-      console.error("[providerController] Error saving provider:", error);
-      return {
-        error: true,
-        message: error.message,
-      };
-    }
-  },
+	const clients = new Map(); // hash → client
+	const factories = new Map(); // providerType → factoryFn(credentials)
+	const pendingClients = new Map(); // hash → Promise (dedup in-flight)
+	const providerLookup = new Map(); // "appId:providerName" → hash (reverse lookup)
 
-  /**
-   * listProviders
-   * Get list of all providers with decrypted credentials
-   *
-   * @param {BrowserWindow} win the main window
-   * @param {string} appId the application id
-   */
-  listProviders: (win, appId) => {
-    try {
-      const filename = path$8.join(
-        app$3.getPath("userData"),
-        appName$2,
-        appId,
-        configFilename$2,
-      );
+	const clientCache = {
+	  registerFactory(providerType, factoryFn) {
+	    factories.set(providerType, factoryFn);
+	  },
 
-      // Load providers file
-      const providersData = getFileContents$2(filename, {});
+	  async getClient(providerHash, appId, providerName) {
+	    // Cache hit
+	    if (clients.has(providerHash)) {
+	      return clients.get(providerHash);
+	    }
 
-      // Decrypt all credentials
-      const decryptedProviders = [];
-      Object.entries(providersData).forEach(([name, data]) => {
-        try {
-          const credentialsBuffer = Buffer.from(data.credentials, "base64");
-          const decryptedJson = safeStorage.decryptString(credentialsBuffer);
-          const credentials = JSON.parse(decryptedJson);
-
-          const provider = {
-            name,
-            type: data.type,
-            providerClass: data.providerClass || "credential",
-            credentials,
-            dateCreated: data.dateCreated,
-            dateUpdated: data.dateUpdated,
-          };
-
-          // Include mcpConfig for MCP providers
-          if (data.mcpConfig) {
-            provider.mcpConfig = data.mcpConfig;
-          }
+	    // Dedup in-flight (same pattern as mcpController.pendingStarts)
+	    if (pendingClients.has(providerHash)) {
+	      return pendingClients.get(providerHash);
+	    }
+
+	    const promise = this._resolve(providerHash, appId, providerName);
+	    pendingClients.set(providerHash, promise);
+	    try {
+	      return await promise;
+	    } finally {
+	      pendingClients.delete(providerHash);
+	    }
+	  },
+
+	  async _resolve(providerHash, appId, providerName) {
+	    const result = providerController.getProvider(null, appId, providerName);
+	    if (result.error) throw new Error(result.message);
+
+	    const { provider } = result;
+	    const factory = factories.get(provider.type);
+	    if (!factory) {
+	      throw new Error(`No client factory for type: ${provider.type}`);
+	    }
+
+	    const client = factory(provider.credentials);
+	    clients.set(providerHash, client);
+	    providerLookup.set(`${appId}:${providerName}`, providerHash);
+	    console.log(
+	      `[clientCache] Created ${provider.type} client (hash: ${providerHash.slice(0, 8)}...)`,
+	    );
+	    return client;
+	  },
+
+	  invalidate(appId, providerName) {
+	    const lookupKey = `${appId}:${providerName}`;
+	    const hash = providerLookup.get(lookupKey);
+	    if (hash) {
+	      clients.delete(hash);
+	      providerLookup.delete(lookupKey);
+	      console.log(
+	        `[clientCache] Invalidated ${providerName} (hash: ${hash.slice(0, 8)}...)`,
+	      );
+	    }
+	  },
+
+	  invalidateAll() {
+	    const count = clients.size;
+	    clients.clear();
+	    providerLookup.clear();
+	    pendingClients.clear();
+	    console.log(`[clientCache] Invalidated all (${count} clients cleared)`);
+	  },
+
+	  clear() {
+	    clients.clear();
+	    providerLookup.clear();
+	    pendingClients.clear();
+	  },
+
+	  /**
+	   * Register IPC handlers for cache management.
+	   * Call this once in the consuming app's electron.js alongside setupWidgetRegistryHandlers().
+	   */
+	  setupCacheHandlers() {
+	    const { ipcMain } = require$$0;
+	    const responseCache = responseCache_1;
+
+	    ipcMain.handle(
+	      "client-cache-invalidate",
+	      async (e, { appId, providerName }) => {
+	        clientCache.invalidate(appId, providerName);
+	        responseCache.clear(); // credential change = all responses stale
+	        return { success: true };
+	      },
+	    );
+	    ipcMain.handle("client-cache-invalidate-all", async () => {
+	      clientCache.invalidateAll();
+	      responseCache.clear();
+	      return { success: true };
+	    });
+	    ipcMain.handle("response-cache-clear", async () => {
+	      responseCache.clear();
+	      return { success: true };
+	    });
+	    ipcMain.handle("response-cache-stats", async () => responseCache.stats());
+	  },
+	};
+
+	clientCache_1 = clientCache;
+	return clientCache_1;
+}
+
+/**
+ * providerController.js
+ *
+ * Handle provider (credentials) management with encryption
+ * Saves encrypted credentials to ~/.userData/Dashboard/{appId}/providers.json
+ */
+
+var providerController_1;
+var hasRequiredProviderController;
+
+function requireProviderController () {
+	if (hasRequiredProviderController) return providerController_1;
+	hasRequiredProviderController = 1;
+	const { app, safeStorage } = require$$0;
+	const path = require$$1$1;
+	const { writeFileSync } = require$$2;
+	const {
+	  ensureDirectoryExistence,
+	  getFileContents,
+	  writeToFile,
+	} = file;
+
+	const appName = "Dashboard";
+	const configFilename = "providers.json";
+
+	const providerController = {
+	  /**
+	   * saveProvider
+	   * Save a new provider with encrypted credentials
+	   *
+	   * @param {BrowserWindow} win the main window
+	   * @param {string} appId the application id
+	   * @param {string} providerName user-defined name (e.g., "Algolia Production")
+	   * @param {string} providerType provider type (e.g., "algolia", "slack")
+	   * @param {object} credentials credentials object
+	   * @param {string} providerClass "credential" (default) or "mcp"
+	   * @param {object} mcpConfig MCP server config (transport, command, args, envMapping) - only for providerClass "mcp"
+	   */
+	  saveProvider: (
+	    win,
+	    appId,
+	    providerName,
+	    providerType,
+	    credentials,
+	    providerClass = "credential",
+	    mcpConfig = null,
+	  ) => {
+	    try {
+	      // Build file path
+	      const filename = path.join(
+	        app.getPath("userData"),
+	        appName,
+	        appId,
+	        configFilename,
+	      );
+
+	      // Ensure directory exists
+	      ensureDirectoryExistence(filename);
+
+	      // Load existing providers
+	      const providers = getFileContents(filename, {});
+
+	      // Encrypt credentials
+	      const credentialsJson = JSON.stringify(credentials);
+	      const encryptedCredentials = safeStorage.encryptString(credentialsJson);
+
+	      // Add/update provider
+	      const providerEntry = {
+	        type: providerType,
+	        providerClass: providerClass || "credential",
+	        credentials: encryptedCredentials.toString("base64"),
+	        dateCreated:
+	          providers[providerName]?.dateCreated || new Date().toISOString(),
+	        dateUpdated: new Date().toISOString(),
+	      };
+
+	      // Add mcpConfig for MCP providers
+	      if (providerClass === "mcp" && mcpConfig) {
+	        providerEntry.mcpConfig = mcpConfig;
+	      }
+
+	      providers[providerName] = providerEntry;
+
+	      // Save to file with restrictive permissions (owner read/write only)
+	      writeFileSync(filename, JSON.stringify(providers, null, 2), {
+	        mode: 0o600,
+	      });
+
+	      console.log(
+	        `[providerController] Provider saved: ${providerName} (${providerType}, ${providerClass})`,
+	      );
+
+	      // Invalidate any cached client so the next getClient() call uses fresh credentials
+	      const clientCache = requireClientCache();
+	      clientCache.invalidate(appId, providerName);
+
+	      // Return the data for ipcMain.handle() - modern promise-based approach
+	      return {
+	        success: true,
+	        providerName,
+	        providerType,
+	        providerClass,
+	      };
+	    } catch (error) {
+	      console.error("[providerController] Error saving provider:", error);
+	      return {
+	        error: true,
+	        message: error.message,
+	      };
+	    }
+	  },
+
+	  /**
+	   * listProviders
+	   * Get list of all providers with decrypted credentials
+	   *
+	   * @param {BrowserWindow} win the main window
+	   * @param {string} appId the application id
+	   */
+	  listProviders: (win, appId) => {
+	    try {
+	      const filename = path.join(
+	        app.getPath("userData"),
+	        appName,
+	        appId,
+	        configFilename,
+	      );
+
+	      // Load providers file
+	      const providersData = getFileContents(filename, {});
+
+	      // Decrypt all credentials
+	      const decryptedProviders = [];
+	      Object.entries(providersData).forEach(([name, data]) => {
+	        try {
+	          const credentialsBuffer = Buffer.from(data.credentials, "base64");
+	          const decryptedJson = safeStorage.decryptString(credentialsBuffer);
+	          const credentials = JSON.parse(decryptedJson);
+
+	          const provider = {
+	            name,
+	            type: data.type,
+	            providerClass: data.providerClass || "credential",
+	            credentials,
+	            dateCreated: data.dateCreated,
+	            dateUpdated: data.dateUpdated,
+	          };
+
+	          // Include mcpConfig for MCP providers
+	          if (data.mcpConfig) {
+	            provider.mcpConfig = data.mcpConfig;
+	          }
 
-          decryptedProviders.push(provider);
-        } catch (decryptError) {
-          console.error(
-            `[providerController] Failed to decrypt provider ${name}:`,
-            decryptError,
-          );
-          // Skip this provider if decryption fails
-        }
-      });
+	          decryptedProviders.push(provider);
+	        } catch (decryptError) {
+	          console.error(
+	            `[providerController] Failed to decrypt provider ${name}:`,
+	            decryptError,
+	          );
+	          // Skip this provider if decryption fails
+	        }
+	      });
 
-      console.log(
-        `[providerController] Loaded ${decryptedProviders.length} providers`,
-      );
+	      console.log(
+	        `[providerController] Loaded ${decryptedProviders.length} providers`,
+	      );
 
-      // Return the data for ipcMain.handle() - modern promise-based approach
-      return {
-        providers: decryptedProviders,
-      };
-    } catch (error) {
-      console.error("[providerController] Error listing providers:", error);
-      return {
-        error: true,
-        message: error.message,
-        providers: [],
-      };
-    }
-  },
+	      // Return the data for ipcMain.handle() - modern promise-based approach
+	      return {
+	        providers: decryptedProviders,
+	      };
+	    } catch (error) {
+	      console.error("[providerController] Error listing providers:", error);
+	      return {
+	        error: true,
+	        message: error.message,
+	        providers: [],
+	      };
+	    }
+	  },
 
-  /**
-   * getProvider
-   * Get a specific provider by name with decrypted credentials
-   *
-   * @param {BrowserWindow} win the main window
-   * @param {string} appId the application id
-   * @param {string} providerName the provider name to retrieve
-   */
-  getProvider: (win, appId, providerName) => {
-    try {
-      const filename = path$8.join(
-        app$3.getPath("userData"),
-        appName$2,
-        appId,
-        configFilename$2,
-      );
+	  /**
+	   * getProvider
+	   * Get a specific provider by name with decrypted credentials
+	   *
+	   * @param {BrowserWindow} win the main window
+	   * @param {string} appId the application id
+	   * @param {string} providerName the provider name to retrieve
+	   */
+	  getProvider: (win, appId, providerName) => {
+	    try {
+	      const filename = path.join(
+	        app.getPath("userData"),
+	        appName,
+	        appId,
+	        configFilename,
+	      );
 
-      // Load providers file
-      const providersData = getFileContents$2(filename, {});
+	      // Load providers file
+	      const providersData = getFileContents(filename, {});
 
-      // Find and decrypt the specific provider
-      const providerData = providersData[providerName];
-      if (!providerData) {
-        throw new Error(`Provider not found: ${providerName}`);
-      }
+	      // Find and decrypt the specific provider
+	      const providerData = providersData[providerName];
+	      if (!providerData) {
+	        throw new Error(`Provider not found: ${providerName}`);
+	      }
 
-      const credentialsBuffer = Buffer.from(providerData.credentials, "base64");
-      const decryptedJson = safeStorage.decryptString(credentialsBuffer);
-      const credentials = JSON.parse(decryptedJson);
+	      const credentialsBuffer = Buffer.from(providerData.credentials, "base64");
+	      const decryptedJson = safeStorage.decryptString(credentialsBuffer);
+	      const credentials = JSON.parse(decryptedJson);
+
+	      const provider = {
+	        name: providerName,
+	        type: providerData.type,
+	        providerClass: providerData.providerClass || "credential",
+	        credentials,
+	        dateCreated: providerData.dateCreated,
+	        dateUpdated: providerData.dateUpdated,
+	      };
 
-      const provider = {
-        name: providerName,
-        type: providerData.type,
-        providerClass: providerData.providerClass || "credential",
-        credentials,
-        dateCreated: providerData.dateCreated,
-        dateUpdated: providerData.dateUpdated,
-      };
+	      // Include mcpConfig for MCP providers
+	      if (providerData.mcpConfig) {
+	        provider.mcpConfig = providerData.mcpConfig;
+	      }
 
-      // Include mcpConfig for MCP providers
-      if (providerData.mcpConfig) {
-        provider.mcpConfig = providerData.mcpConfig;
-      }
+	      console.log(`[providerController] Provider retrieved: ${providerName}`);
 
-      console.log(`[providerController] Provider retrieved: ${providerName}`);
+	      // Return the data for ipcMain.handle() - modern promise-based approach
+	      return {
+	        provider,
+	      };
+	    } catch (error) {
+	      console.error("[providerController] Error getting provider:", error);
+	      return {
+	        error: true,
+	        message: error.message,
+	      };
+	    }
+	  },
 
-      // Return the data for ipcMain.handle() - modern promise-based approach
-      return {
-        provider,
-      };
-    } catch (error) {
-      console.error("[providerController] Error getting provider:", error);
-      return {
-        error: true,
-        message: error.message,
-      };
-    }
-  },
+	  /**
+	   * deleteProvider
+	   * Delete a provider from the providers file
+	   *
+	   * @param {BrowserWindow} win the main window
+	   * @param {string} appId the application id
+	   * @param {string} providerName the provider name to delete
+	   */
+	  deleteProvider: (win, appId, providerName) => {
+	    try {
+	      const filename = path.join(
+	        app.getPath("userData"),
+	        appName,
+	        appId,
+	        configFilename,
+	      );
 
-  /**
-   * deleteProvider
-   * Delete a provider from the providers file
-   *
-   * @param {BrowserWindow} win the main window
-   * @param {string} appId the application id
-   * @param {string} providerName the provider name to delete
-   */
-  deleteProvider: (win, appId, providerName) => {
-    try {
-      const filename = path$8.join(
-        app$3.getPath("userData"),
-        appName$2,
-        appId,
-        configFilename$2,
-      );
+	      // Load existing providers
+	      const providers = getFileContents(filename, {});
 
-      // Load existing providers
-      const providers = getFileContents$2(filename, {});
+	      // Delete the provider
+	      if (!providers.hasOwnProperty(providerName)) {
+	        throw new Error(`Provider not found: ${providerName}`);
+	      }
 
-      // Delete the provider
-      if (!providers.hasOwnProperty(providerName)) {
-        throw new Error(`Provider not found: ${providerName}`);
-      }
+	      delete providers[providerName];
 
-      delete providers[providerName];
+	      // Save to file with restrictive permissions (owner read/write only)
+	      writeFileSync(filename, JSON.stringify(providers, null, 2), {
+	        mode: 0o600,
+	      });
 
-      // Save to file with restrictive permissions (owner read/write only)
-      writeFileSync$2(filename, JSON.stringify(providers, null, 2), {
-        mode: 0o600,
-      });
+	      console.log(`[providerController] Provider deleted: ${providerName}`);
 
-      console.log(`[providerController] Provider deleted: ${providerName}`);
+	      // Invalidate any cached client for the deleted provider
+	      const clientCache = requireClientCache();
+	      clientCache.invalidate(appId, providerName);
 
-      // Return the data for ipcMain.handle() - modern promise-based approach
-      return {
-        success: true,
-        providerName,
-      };
-    } catch (error) {
-      console.error("[providerController] Error deleting provider:", error);
-      return {
-        error: true,
-        message: error.message,
-      };
-    }
-  },
-};
+	      // Return the data for ipcMain.handle() - modern promise-based approach
+	      return {
+	        success: true,
+	        providerName,
+	      };
+	    } catch (error) {
+	      console.error("[providerController] Error deleting provider:", error);
+	      return {
+	        error: true,
+	        message: error.message,
+	      };
+	    }
+	  },
+	};
 
-var providerController_1 = providerController$2;
+	providerController_1 = providerController;
+	return providerController_1;
+}
 
 const { app: app$2 } = require$$0;
 const path$7 = require$$1$1;
@@ -5955,214 +6233,31 @@ const pluginController$1 = {
 var pluginController_1 = pluginController$1;
 
 /**
- * clientCache
- *
- * Generic provider client cache for the main process.
- * Caches API clients (e.g., algoliasearch, Stripe) by provider hash.
- * Factories are registered per provider type; credentials are resolved
- * from the encrypted store — renderer never sends credential fields.
- */
-
-const providerController$1 = providerController_1;
-
-const clients = new Map(); // hash → client
-const factories = new Map(); // providerType → factoryFn(credentials)
-const pendingClients = new Map(); // hash → Promise (dedup in-flight)
-const providerLookup = new Map(); // "appId:providerName" → hash (reverse lookup)
-
-const clientCache$1 = {
-    registerFactory(providerType, factoryFn) {
-        factories.set(providerType, factoryFn);
-    },
-
-    async getClient(providerHash, appId, providerName) {
-        // Cache hit
-        if (clients.has(providerHash)) {
-            return clients.get(providerHash);
-        }
-
-        // Dedup in-flight (same pattern as mcpController.pendingStarts)
-        if (pendingClients.has(providerHash)) {
-            return pendingClients.get(providerHash);
-        }
-
-        const promise = this._resolve(providerHash, appId, providerName);
-        pendingClients.set(providerHash, promise);
-        try {
-            return await promise;
-        } finally {
-            pendingClients.delete(providerHash);
-        }
-    },
-
-    async _resolve(providerHash, appId, providerName) {
-        const result = providerController$1.getProvider(null, appId, providerName);
-        if (result.error) throw new Error(result.message);
-
-        const { provider } = result;
-        const factory = factories.get(provider.type);
-        if (!factory) {
-            throw new Error(`No client factory for type: ${provider.type}`);
-        }
-
-        const client = factory(provider.credentials);
-        clients.set(providerHash, client);
-        providerLookup.set(`${appId}:${providerName}`, providerHash);
-        console.log(
-            `[clientCache] Created ${provider.type} client (hash: ${providerHash.slice(0, 8)}...)`
-        );
-        return client;
-    },
-
-    invalidate(appId, providerName) {
-        const lookupKey = `${appId}:${providerName}`;
-        const hash = providerLookup.get(lookupKey);
-        if (hash) {
-            clients.delete(hash);
-            providerLookup.delete(lookupKey);
-            console.log(
-                `[clientCache] Invalidated ${providerName} (hash: ${hash.slice(0, 8)}...)`
-            );
-        }
-    },
-
-    invalidateAll() {
-        const count = clients.size;
-        clients.clear();
-        providerLookup.clear();
-        pendingClients.clear();
-        console.log(
-            `[clientCache] Invalidated all (${count} clients cleared)`
-        );
-    },
-
-    clear() {
-        clients.clear();
-        providerLookup.clear();
-        pendingClients.clear();
-    },
-};
-
-var clientCache_1 = clientCache$1;
-
-/**
- * responseCache.js
- *
- * TTL-based API response cache with in-flight deduplication.
- * Renderer-driven: widget developer includes { cache: true } or { cache: { ttl: N } }
- * in IPC messages to opt-in to caching per call.
+ * clientFactories.js
  *
- * Usage:
- *   // Wrap a handler:
- *   ipcMain.handle("my-channel", responseCache.cachedHandler("my-channel", handler));
+ * Registers built-in provider type factories with clientCache.
+ * SDK packages are lazy-required so they're only loaded when first needed.
  *
- *   // Widget-side (renderer):
- *   window.mainApi.myService.getData({ ...pc, cache: true });              // 30s default
- *   window.mainApi.myService.getData({ ...pc, cache: 60000 });             // 60s
- *   window.mainApi.myService.getData({ ...pc, cache: { ttl: 120000 } });   // 120s
- *   window.mainApi.myService.getData({ ...pc, cache: true, forceRefresh: true }); // bypass
+ * Auto-imported by electron/index.js — factories are registered the moment
+ * any consuming app does require("@trops/dash-core/electron").
  */
 
-const cache = new Map(); // key → { data, timestamp, ttl }
-const inflight = new Map(); // key → Promise
-
-function stableHash(obj) {
-    const str = JSON.stringify(obj, Object.keys(obj).sort());
-    let hash = 5381;
-    for (let i = 0; i < str.length; i++) {
-        hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0xffffffff;
-    }
-    return hash.toString(36);
-}
-
-const responseCache$1 = {
-    async get(key, fetcher, options = {}) {
-        const { ttl = 30000, forceRefresh = false } = options;
-
-        if (!forceRefresh && cache.has(key)) {
-            const entry = cache.get(key);
-            if (Date.now() - entry.timestamp < entry.ttl) {
-                console.log(`[responseCache] HIT ${key}`);
-                return entry.data;
-            }
-            cache.delete(key);
-        }
-
-        if (!forceRefresh && inflight.has(key)) {
-            console.log(`[responseCache] DEDUP ${key}`);
-            return inflight.get(key);
-        }
-
-        console.log(`[responseCache] MISS ${key}`);
-        const promise = fetcher();
-        inflight.set(key, promise);
-        try {
-            const data = await promise;
-            if (data && !data.error) {
-                cache.set(key, { data, timestamp: Date.now(), ttl });
-            }
-            return data;
-        } finally {
-            inflight.delete(key);
-        }
-    },
-
-    /**
-     * Wrap an ipcMain.handle handler with renderer-driven caching.
-     * If the incoming message has a `cache` property, the response is cached.
-     * If the message has `forceRefresh: true`, the cache is bypassed.
-     *
-     * The `cache` and `forceRefresh` properties are stripped from the message
-     * before passing to the handler, so handlers receive clean params.
-     *
-     * Cache parameter forms:
-     *   cache: true         → 30s default TTL
-     *   cache: 60000        → 60s (number shorthand)
-     *   cache: { ttl: N }   → explicit TTL in ms
-     */
-    cachedHandler(channelName, handler) {
-        return async (e, msg) => {
-            const { cache: cacheOpt, forceRefresh, ...params } = msg || {};
-            if (cacheOpt) {
-                const ttl =
-                    typeof cacheOpt === "number"
-                        ? cacheOpt
-                        : cacheOpt?.ttl || 30000;
-                const key = `${channelName}:${stableHash(params)}`;
-                return this.get(key, () => handler(e, params), {
-                    ttl,
-                    forceRefresh,
-                });
-            }
-            return handler(e, msg);
-        };
-    },
-
-    invalidate(key) {
-        cache.delete(key);
-    },
-
-    invalidatePrefix(prefix) {
-        for (const k of cache.keys()) {
-            if (k.startsWith(prefix)) cache.delete(k);
-        }
-    },
-
-    clear() {
-        cache.clear();
-        inflight.clear();
-    },
+const clientCache$1 = requireClientCache();
 
-    stats() {
-        return {
-            entries: cache.size,
-            inflight: inflight.size,
-            keys: [...cache.keys()],
-        };
-    },
-};
+// --- Algolia ---
+clientCache$1.registerFactory("algolia", (credentials) => {
+  const algoliasearch = require$$2$4;
+  return algoliasearch(
+    credentials.appId,
+    credentials.apiKey || credentials.key,
+  );
+});
 
-var responseCache_1 = responseCache$1;
+// --- OpenAI ---
+clientCache$1.registerFactory("openai", (credentials) => {
+  const OpenAI = require$$0$3;
+  return new OpenAI({ apiKey: credentials.apiKey });
+});
 
 /**
  * Controller exports.
@@ -6209,7 +6304,7 @@ const {
   listProviders,
   getProvider,
   deleteProvider,
-} = providerController_1;
+} = requireProviderController();
 const {
   listIndices,
   partialUpdateObjectsFromDirectory,
@@ -6267,7 +6362,7 @@ var controller = {
   searchIndex,
 };
 
-const { ipcRenderer: ipcRenderer$f } = require$$0;
+const { ipcRenderer: ipcRenderer$g } = require$$0;
 const {
   SECURE_STORE_ENCRYPTION_CHECK,
   SECURE_STORE_SET_DATA,
@@ -6279,10 +6374,10 @@ const {
  */
 const secureStoreApi$2 = {
   isEncryptionAvailable: () =>
-    ipcRenderer$f.invoke(SECURE_STORE_ENCRYPTION_CHECK, {}),
+    ipcRenderer$g.invoke(SECURE_STORE_ENCRYPTION_CHECK, {}),
   saveData: (key, value) =>
-    ipcRenderer$f.invoke(SECURE_STORE_SET_DATA, { key, value }),
-  getData: (key) => ipcRenderer$f.invoke(SECURE_STORE_GET_DATA, { key }),
+    ipcRenderer$g.invoke(SECURE_STORE_SET_DATA, { key, value }),
+  getData: (key) => ipcRenderer$g.invoke(SECURE_STORE_GET_DATA, { key }),
 };
 
 var secureStoreApi_1 = secureStoreApi$2;
@@ -6293,7 +6388,7 @@ var secureStoreApi_1 = secureStoreApi$2;
  * Handle the workspace configuration file
  */
 
-const { ipcRenderer: ipcRenderer$e } = require$$0;
+const { ipcRenderer: ipcRenderer$f } = require$$0;
 const {
   WORKSPACE_LIST,
   WORKSPACE_SAVE,
@@ -6310,7 +6405,7 @@ const workspaceApi$2 = {
    */
   listWorkspacesForApplication: (appId) => {
     console.log("listWorkspacesForApplication called with appId:", appId);
-    return ipcRenderer$e.invoke(WORKSPACE_LIST, { appId });
+    return ipcRenderer$f.invoke(WORKSPACE_LIST, { appId });
   },
 
   /**
@@ -6321,7 +6416,7 @@ const workspaceApi$2 = {
    * @returns
    */
   saveWorkspaceForApplication: (appId, data) =>
-    ipcRenderer$e.invoke(WORKSPACE_SAVE, { appId, data }),
+    ipcRenderer$f.invoke(WORKSPACE_SAVE, { appId, data }),
 
   /**
    * deleteWorkspaceForApplication
@@ -6331,7 +6426,7 @@ const workspaceApi$2 = {
    * @returns
    */
   deleteWorkspaceForApplication: (appId, workspaceId) =>
-    ipcRenderer$e.invoke(WORKSPACE_DELETE, { appId, workspaceId }),
+    ipcRenderer$f.invoke(WORKSPACE_DELETE, { appId, workspaceId }),
 };
 
 var workspaceApi_1 = workspaceApi$2;
@@ -6343,15 +6438,15 @@ var workspaceApi_1 = workspaceApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$d } = require$$0;
+const { ipcRenderer: ipcRenderer$e } = require$$0;
 
 const { LAYOUT_LIST, LAYOUT_SAVE } = events$8;
 
 const layoutApi$2 = {
   listLayoutsForApplication: (appId) =>
-    ipcRenderer$d.invoke(LAYOUT_LIST, { appId }),
+    ipcRenderer$e.invoke(LAYOUT_LIST, { appId }),
   saveLayoutForApplication: (appId, data) =>
-    ipcRenderer$d.invoke(LAYOUT_SAVE, { appId, data }),
+    ipcRenderer$e.invoke(LAYOUT_SAVE, { appId, data }),
 };
 
 var layoutApi_1 = layoutApi$2;
@@ -6363,7 +6458,7 @@ var layoutApi_1 = layoutApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$c } = require$$0;
+const { ipcRenderer: ipcRenderer$d } = require$$0;
 
 const {
   DATA_JSON_TO_CSV_FILE,
@@ -6382,7 +6477,7 @@ const {
 const dataApi$2 = {
   // convert a json array of objects to a csv string and save to file
   convertJsonToCsvFile: (appId, jsonObject, filename) =>
-    ipcRenderer$c.invoke(DATA_JSON_TO_CSV_FILE, {
+    ipcRenderer$d.invoke(DATA_JSON_TO_CSV_FILE, {
       appId,
       jsonObject,
       filename,
@@ -6390,10 +6485,10 @@ const dataApi$2 = {
 
   // convert a json array of objects to a csv string and return a string
   convertJsonToCsvString: (appId, jsonObject) =>
-    ipcRenderer$c.invoke(DATA_JSON_TO_CSV_STRING, { appId, jsonObject }),
+    ipcRenderer$d.invoke(DATA_JSON_TO_CSV_STRING, { appId, jsonObject }),
 
   parseXMLStream: (filepath, outpath, start) =>
-    ipcRenderer$c.invoke(PARSE_XML_STREAM, {
+    ipcRenderer$d.invoke(PARSE_XML_STREAM, {
       filepath,
       outpath,
       start,
@@ -6407,7 +6502,7 @@ const dataApi$2 = {
     headers = null,
     limit = null,
   ) => {
-    ipcRenderer$c.invoke(PARSE_CSV_STREAM, {
+    ipcRenderer$d.invoke(PARSE_CSV_STREAM, {
       filepath,
       outpath,
       delimiter,
@@ -6418,15 +6513,15 @@ const dataApi$2 = {
   },
 
   readLinesFromFile: (filepath, lineCount) => {
-    ipcRenderer$c.invoke(READ_LINES, { filepath, lineCount });
+    ipcRenderer$d.invoke(READ_LINES, { filepath, lineCount });
   },
 
   readJSONFromFile: (filepath, objectCount = null) => {
-    ipcRenderer$c.invoke(READ_JSON, { filepath, objectCount });
+    ipcRenderer$d.invoke(READ_JSON, { filepath, objectCount });
   },
 
   readDataFromURL: (url, toFilepath) => {
-    ipcRenderer$c.invoke(READ_DATA_URL, { url, toFilepath });
+    ipcRenderer$d.invoke(READ_DATA_URL, { url, toFilepath });
   },
 
   /*
@@ -6435,7 +6530,7 @@ const dataApi$2 = {
    * @param {object} returnEmpty the return empty object
    */
   saveData: (data, filename, append, returnEmpty, uuid) =>
-    ipcRenderer$c.invoke(DATA_SAVE_TO_FILE, {
+    ipcRenderer$d.invoke(DATA_SAVE_TO_FILE, {
       data,
       filename,
       append,
@@ -6447,14 +6542,14 @@ const dataApi$2 = {
    * @param {string} filename the filename to read (not path)
    */
   readData: (filename, returnEmpty = []) =>
-    ipcRenderer$c.invoke(DATA_READ_FROM_FILE, { filename, returnEmpty }),
+    ipcRenderer$d.invoke(DATA_READ_FROM_FILE, { filename, returnEmpty }),
 
   /**
    * transformFile
    * @returns
    */
   transformFile: (filepath, outFilepath, mappingFunctionBody, args) => {
-    ipcRenderer$c.invoke(TRANSFORM_FILE, {
+    ipcRenderer$d.invoke(TRANSFORM_FILE, {
       filepath,
       outFilepath,
       mappingFunctionBody,
@@ -6463,7 +6558,7 @@ const dataApi$2 = {
   },
 
   extractColorsFromImageURL: (url) => {
-    ipcRenderer$c.invoke(EXTRACT_COLORS_FROM_IMAGE, {
+    ipcRenderer$d.invoke(EXTRACT_COLORS_FROM_IMAGE, {
       url,
     });
   },
@@ -6478,7 +6573,7 @@ var dataApi_1 = dataApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$b } = require$$0;
+const { ipcRenderer: ipcRenderer$c } = require$$0;
 
 const {
   SETTINGS_GET,
@@ -6489,14 +6584,14 @@ const {
 } = events$8;
 
 const settingsApi$2 = {
-  getSettingsForApplication: () => ipcRenderer$b.invoke(SETTINGS_GET, {}),
+  getSettingsForApplication: () => ipcRenderer$c.invoke(SETTINGS_GET, {}),
   saveSettingsForApplication: (data) =>
-    ipcRenderer$b.invoke(SETTINGS_SAVE, { data }),
-  getDataDirectory: () => ipcRenderer$b.invoke(SETTINGS_GET_DATA_DIR, {}),
+    ipcRenderer$c.invoke(SETTINGS_SAVE, { data }),
+  getDataDirectory: () => ipcRenderer$c.invoke(SETTINGS_GET_DATA_DIR, {}),
   setDataDirectory: (dataDirectory) =>
-    ipcRenderer$b.invoke(SETTINGS_SET_DATA_DIR, { dataDirectory }),
+    ipcRenderer$c.invoke(SETTINGS_SET_DATA_DIR, { dataDirectory }),
   migrateDataDirectory: (oldDirectory, newDirectory) =>
-    ipcRenderer$b.invoke(SETTINGS_MIGRATE_DATA_DIR, {
+    ipcRenderer$c.invoke(SETTINGS_MIGRATE_DATA_DIR, {
       oldDirectory,
       newDirectory,
     }),
@@ -6511,7 +6606,7 @@ var settingsApi_1 = settingsApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$a } = require$$0;
+const { ipcRenderer: ipcRenderer$b } = require$$0;
 
 const { CHOOSE_FILE } = events$8;
 
@@ -6523,7 +6618,7 @@ const dialogApi$2 = {
    */
   chooseFile: (allowFile = true, extensions = ["*"]) => {
     console.log("dialog api choose file");
-    return ipcRenderer$a.invoke(CHOOSE_FILE, { allowFile, extensions });
+    return ipcRenderer$b.invoke(CHOOSE_FILE, { allowFile, extensions });
   },
 };
 
@@ -6542,7 +6637,7 @@ var dialogApi_1 = dialogApi$2;
  * mainApi.widgets.uninstall('Weather')
  */
 
-const { ipcRenderer: ipcRenderer$9 } = require$$0;
+const { ipcRenderer: ipcRenderer$a } = require$$0;
 
 const widgetApi$2 = {
   /**
@@ -6551,7 +6646,7 @@ const widgetApi$2 = {
    */
   list: async () => {
     try {
-      return await ipcRenderer$9.invoke("widget:list");
+      return await ipcRenderer$a.invoke("widget:list");
     } catch (error) {
       console.error("[WidgetApi] Error listing widgets:", error);
       throw error;
@@ -6565,7 +6660,7 @@ const widgetApi$2 = {
    */
   get: async (widgetName) => {
     try {
-      return await ipcRenderer$9.invoke("widget:get", widgetName);
+      return await ipcRenderer$a.invoke("widget:get", widgetName);
     } catch (error) {
       console.error(`[WidgetApi] Error getting widget ${widgetName}:`, error);
       throw error;
@@ -6596,7 +6691,7 @@ const widgetApi$2 = {
       console.log(
         `[WidgetApi] Installing widget: ${widgetName} from ${downloadUrl}`,
       );
-      const config = await ipcRenderer$9.invoke(
+      const config = await ipcRenderer$a.invoke(
         "widget:install",
         widgetName,
         downloadUrl,
@@ -6636,7 +6731,7 @@ const widgetApi$2 = {
       console.log(
         `[WidgetApi] Installing local widget: ${widgetName} from ${localPath}`,
       );
-      const config = await ipcRenderer$9.invoke(
+      const config = await ipcRenderer$a.invoke(
         "widget:install-local",
         widgetName,
         localPath,
@@ -6667,7 +6762,7 @@ const widgetApi$2 = {
   loadFolder: async (folderPath) => {
     try {
       console.log(`[WidgetApi] Loading widgets from folder: ${folderPath}`);
-      const results = await ipcRenderer$9.invoke(
+      const results = await ipcRenderer$a.invoke(
         "widget:load-folder",
         folderPath,
       );
@@ -6691,7 +6786,7 @@ const widgetApi$2 = {
   uninstall: async (widgetName) => {
     try {
       console.log(`[WidgetApi] Uninstalling widget: ${widgetName}`);
-      const success = await ipcRenderer$9.invoke("widget:uninstall", widgetName);
+      const success = await ipcRenderer$a.invoke("widget:uninstall", widgetName);
       if (success) {
         console.log(`[WidgetApi] ✓ Widget ${widgetName} uninstalled`);
       } else {
@@ -6714,7 +6809,7 @@ const widgetApi$2 = {
    */
   getCachePath: async () => {
     try {
-      return await ipcRenderer$9.invoke("widget:cache-path");
+      return await ipcRenderer$a.invoke("widget:cache-path");
     } catch (error) {
       console.error("[WidgetApi] Error getting cache path:", error);
       throw error;
@@ -6728,7 +6823,7 @@ const widgetApi$2 = {
    */
   getStoragePath: async () => {
     try {
-      return await ipcRenderer$9.invoke("widget:storage-path");
+      return await ipcRenderer$a.invoke("widget:storage-path");
     } catch (error) {
       console.error("[WidgetApi] Error getting storage path:", error);
       throw error;
@@ -6745,7 +6840,7 @@ const widgetApi$2 = {
   setStoragePath: async (customPath) => {
     try {
       console.log(`[WidgetApi] Setting storage path to: ${customPath}`);
-      const result = await ipcRenderer$9.invoke(
+      const result = await ipcRenderer$a.invoke(
         "widget:set-storage-path",
         customPath,
       );
@@ -6767,7 +6862,7 @@ const widgetApi$2 = {
    */
   getComponentConfigs: async () => {
     try {
-      return await ipcRenderer$9.invoke("widget:get-component-configs");
+      return await ipcRenderer$a.invoke("widget:get-component-configs");
     } catch (error) {
       console.error("[WidgetApi] Error getting component configs:", error);
       return [];
@@ -6782,7 +6877,7 @@ const widgetApi$2 = {
    */
   readBundle: async (widgetName) => {
     try {
-      return await ipcRenderer$9.invoke("widget:read-bundle", widgetName);
+      return await ipcRenderer$a.invoke("widget:read-bundle", widgetName);
     } catch (error) {
       console.error(
         `[WidgetApi] Error reading bundle for ${widgetName}:`,
@@ -6799,7 +6894,7 @@ const widgetApi$2 = {
    */
   readAllBundles: async () => {
     try {
-      return await ipcRenderer$9.invoke("widget:read-all-bundles");
+      return await ipcRenderer$a.invoke("widget:read-all-bundles");
     } catch (error) {
       console.error("[WidgetApi] Error reading all bundles:", error);
       return [];
@@ -6819,7 +6914,7 @@ const widgetApi$2 = {
    * });
    */
   onInstalled: (callback) => {
-    ipcRenderer$9.on("widget:installed", (event, data) => {
+    ipcRenderer$a.on("widget:installed", (event, data) => {
       callback(data);
     });
   },
@@ -6837,7 +6932,7 @@ const widgetApi$2 = {
    * });
    */
   onLoaded: (callback) => {
-    ipcRenderer$9.on("widgets:loaded", (event, data) => {
+    ipcRenderer$a.on("widgets:loaded", (event, data) => {
       callback(data);
     });
   },
@@ -6848,7 +6943,7 @@ const widgetApi$2 = {
    * @param {Function} callback - The callback to remove
    */
   removeInstalledListener: (callback) => {
-    ipcRenderer$9.removeListener("widget:installed", callback);
+    ipcRenderer$a.removeListener("widget:installed", callback);
   },
 
   /**
@@ -6857,7 +6952,7 @@ const widgetApi$2 = {
    * @param {Function} callback - The callback to remove
    */
   removeLoadedListener: (callback) => {
-    ipcRenderer$9.removeListener("widgets:loaded", callback);
+    ipcRenderer$a.removeListener("widgets:loaded", callback);
   },
 };
 
@@ -6870,7 +6965,7 @@ var widgetApi_1 = widgetApi$2;
  * Communicates with main process via IPC to handle encryption and file storage
  */
 
-const { ipcRenderer: ipcRenderer$8 } = require$$0;
+const { ipcRenderer: ipcRenderer$9 } = require$$0;
 const {
   PROVIDER_SAVE,
   PROVIDER_LIST,
@@ -6900,7 +6995,7 @@ const providerApi$2 = {
     providerClass = "credential",
     mcpConfig = null,
   ) =>
-    ipcRenderer$8.invoke(PROVIDER_SAVE, {
+    ipcRenderer$9.invoke(PROVIDER_SAVE, {
       appId,
       providerName,
       providerType,
@@ -6917,7 +7012,7 @@ const providerApi$2 = {
    * @param {String} appId - the appId specified in the dash initialization
    * @returns {Promise<Array>} Array of provider objects with name, type, credentials
    */
-  listProviders: (appId) => ipcRenderer$8.invoke(PROVIDER_LIST, { appId }),
+  listProviders: (appId) => ipcRenderer$9.invoke(PROVIDER_LIST, { appId }),
 
   /**
    * getProvider
@@ -6929,7 +7024,7 @@ const providerApi$2 = {
    * @returns {Promise<Object>} Provider object with name, type, credentials
    */
   getProvider: (appId, providerName) =>
-    ipcRenderer$8.invoke(PROVIDER_GET, { appId, providerName }),
+    ipcRenderer$9.invoke(PROVIDER_GET, { appId, providerName }),
 
   /**
    * deleteProvider
@@ -6941,7 +7036,7 @@ const providerApi$2 = {
    * @returns {Promise}
    */
   deleteProvider: (appId, providerName) =>
-    ipcRenderer$8.invoke(PROVIDER_DELETE, { appId, providerName }),
+    ipcRenderer$9.invoke(PROVIDER_DELETE, { appId, providerName }),
 
   /**
    * listProvidersForApplication
@@ -6951,14 +7046,14 @@ const providerApi$2 = {
    * @param {String} appId - the appId specified in the dash initialization
    */
   listProvidersForApplication: (appId) => {
-    ipcRenderer$8
+    ipcRenderer$9
       .invoke(PROVIDER_LIST, { appId })
       .then((result) => {
         // Emit the event for ElectronDashboardApi to listen to
-        ipcRenderer$8.send("PROVIDER_LIST_COMPLETE", result);
+        ipcRenderer$9.send("PROVIDER_LIST_COMPLETE", result);
       })
       .catch((error) => {
-        ipcRenderer$8.send("PROVIDER_LIST_ERROR", {
+        ipcRenderer$9.send("PROVIDER_LIST_ERROR", {
           error: error.message,
         });
       });
@@ -6975,7 +7070,7 @@ const providerApi$2 = {
     providerType,
     credentials,
   ) => {
-    ipcRenderer$8
+    ipcRenderer$9
       .invoke(PROVIDER_SAVE, {
         appId,
         providerName,
@@ -6983,10 +7078,10 @@ const providerApi$2 = {
         credentials,
       })
       .then((result) => {
-        ipcRenderer$8.send("PROVIDER_SAVE_COMPLETE", result);
+        ipcRenderer$9.send("PROVIDER_SAVE_COMPLETE", result);
       })
       .catch((error) => {
-        ipcRenderer$8.send("PROVIDER_SAVE_ERROR", {
+        ipcRenderer$9.send("PROVIDER_SAVE_ERROR", {
           error: error.message,
         });
       });
@@ -6998,13 +7093,13 @@ const providerApi$2 = {
    * Event-listener-based version for use with ElectronDashboardApi
    */
   getProviderForApplication: (appId, providerName) => {
-    ipcRenderer$8
+    ipcRenderer$9
       .invoke(PROVIDER_GET, { appId, providerName })
       .then((result) => {
-        ipcRenderer$8.send("PROVIDER_GET_COMPLETE", result);
+        ipcRenderer$9.send("PROVIDER_GET_COMPLETE", result);
       })
       .catch((error) => {
-        ipcRenderer$8.send("PROVIDER_GET_ERROR", {
+        ipcRenderer$9.send("PROVIDER_GET_ERROR", {
           error: error.message,
         });
       });
@@ -7016,13 +7111,13 @@ const providerApi$2 = {
    * Event-listener-based version for use with ElectronDashboardApi
    */
   deleteProviderForApplication: (appId, providerName) => {
-    ipcRenderer$8
+    ipcRenderer$9
       .invoke(PROVIDER_DELETE, { appId, providerName })
       .then((result) => {
-        ipcRenderer$8.send("PROVIDER_DELETE_COMPLETE", result);
+        ipcRenderer$9.send("PROVIDER_DELETE_COMPLETE", result);
       })
       .catch((error) => {
-        ipcRenderer$8.send("PROVIDER_DELETE_ERROR", {
+        ipcRenderer$9.send("PROVIDER_DELETE_ERROR", {
           error: error.message,
         });
       });
@@ -7038,7 +7133,7 @@ var providerApi_1 = providerApi$2;
  * Communicates with main process via IPC to manage MCP server lifecycle.
  */
 
-const { ipcRenderer: ipcRenderer$7 } = require$$0;
+const { ipcRenderer: ipcRenderer$8 } = require$$0;
 const {
   MCP_START_SERVER,
   MCP_STOP_SERVER,
@@ -7061,7 +7156,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ success, serverName, tools, status } | { error, message }>}
    */
   startServer: (serverName, mcpConfig, credentials) =>
-    ipcRenderer$7.invoke(MCP_START_SERVER, {
+    ipcRenderer$8.invoke(MCP_START_SERVER, {
       serverName,
       mcpConfig,
       credentials,
@@ -7075,7 +7170,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ success, serverName } | { error, message }>}
    */
   stopServer: (serverName) =>
-    ipcRenderer$7.invoke(MCP_STOP_SERVER, { serverName }),
+    ipcRenderer$8.invoke(MCP_STOP_SERVER, { serverName }),
 
   /**
    * listTools
@@ -7084,7 +7179,7 @@ const mcpApi$2 = {
    * @param {string} serverName the server name
    * @returns {Promise<{ tools } | { error, message }>}
    */
-  listTools: (serverName) => ipcRenderer$7.invoke(MCP_LIST_TOOLS, { serverName }),
+  listTools: (serverName) => ipcRenderer$8.invoke(MCP_LIST_TOOLS, { serverName }),
 
   /**
    * callTool
@@ -7097,7 +7192,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ result } | { error, message }>}
    */
   callTool: (serverName, toolName, args, allowedTools = null) =>
-    ipcRenderer$7.invoke(MCP_CALL_TOOL, {
+    ipcRenderer$8.invoke(MCP_CALL_TOOL, {
       serverName,
       toolName,
       args,
@@ -7112,7 +7207,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ resources } | { error, message }>}
    */
   listResources: (serverName) =>
-    ipcRenderer$7.invoke(MCP_LIST_RESOURCES, { serverName }),
+    ipcRenderer$8.invoke(MCP_LIST_RESOURCES, { serverName }),
 
   /**
    * readResource
@@ -7123,7 +7218,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ resource } | { error, message }>}
    */
   readResource: (serverName, uri) =>
-    ipcRenderer$7.invoke(MCP_READ_RESOURCE, { serverName, uri }),
+    ipcRenderer$8.invoke(MCP_READ_RESOURCE, { serverName, uri }),
 
   /**
    * getServerStatus
@@ -7133,7 +7228,7 @@ const mcpApi$2 = {
    * @returns {Promise<{ status, tools, error }>}
    */
   getServerStatus: (serverName) =>
-    ipcRenderer$7.invoke(MCP_SERVER_STATUS, { serverName }),
+    ipcRenderer$8.invoke(MCP_SERVER_STATUS, { serverName }),
 
   /**
    * getCatalog
@@ -7141,7 +7236,7 @@ const mcpApi$2 = {
    *
    * @returns {Promise<{ catalog } | { error, message }>}
    */
-  getCatalog: () => ipcRenderer$7.invoke(MCP_GET_CATALOG),
+  getCatalog: () => ipcRenderer$8.invoke(MCP_GET_CATALOG),
 };
 
 var mcpApi_1 = mcpApi$2;
@@ -7159,7 +7254,7 @@ var mcpApi_1 = mcpApi$2;
  * mainApi.registry.checkUpdates([{ name: "weather-widgets", version: "1.0.0" }])
  */
 
-const { ipcRenderer: ipcRenderer$6 } = require$$0;
+const { ipcRenderer: ipcRenderer$7 } = require$$0;
 
 const registryApi$2 = {
   /**
@@ -7169,7 +7264,7 @@ const registryApi$2 = {
    */
   fetchIndex: async (forceRefresh = false) => {
     try {
-      return await ipcRenderer$6.invoke("registry:fetch-index", forceRefresh);
+      return await ipcRenderer$7.invoke("registry:fetch-index", forceRefresh);
     } catch (error) {
       console.error("[RegistryApi] Error fetching index:", error);
       throw error;
@@ -7184,7 +7279,7 @@ const registryApi$2 = {
    */
   search: async (query = "", filters = {}) => {
     try {
-      return await ipcRenderer$6.invoke("registry:search", query, filters);
+      return await ipcRenderer$7.invoke("registry:search", query, filters);
     } catch (error) {
       console.error("[RegistryApi] Error searching registry:", error);
       throw error;
@@ -7198,7 +7293,7 @@ const registryApi$2 = {
    */
   getPackage: async (packageName) => {
     try {
-      return await ipcRenderer$6.invoke("registry:get-package", packageName);
+      return await ipcRenderer$7.invoke("registry:get-package", packageName);
     } catch (error) {
       console.error(
         `[RegistryApi] Error getting package ${packageName}:`,
@@ -7215,7 +7310,7 @@ const registryApi$2 = {
    */
   checkUpdates: async (installedWidgets = []) => {
     try {
-      return await ipcRenderer$6.invoke(
+      return await ipcRenderer$7.invoke(
         "registry:check-updates",
         installedWidgets,
       );
@@ -7234,17 +7329,17 @@ var registryApi_1 = registryApi$2;
  * Handle the theme configuration file
  */
 
-const { ipcRenderer: ipcRenderer$5 } = require$$0;
+const { ipcRenderer: ipcRenderer$6 } = require$$0;
 
 const { THEME_LIST, THEME_SAVE, THEME_DELETE } = events$8;
 
 const themeApi$2 = {
   listThemesForApplication: (appId) =>
-    ipcRenderer$5.invoke(THEME_LIST, { appId }),
+    ipcRenderer$6.invoke(THEME_LIST, { appId }),
   saveThemeForApplication: (appId, themeName, themeObject) =>
-    ipcRenderer$5.invoke(THEME_SAVE, { appId, themeName, themeObject }),
+    ipcRenderer$6.invoke(THEME_SAVE, { appId, themeName, themeObject }),
   deleteThemeForApplication: (appId, themeKey) =>
-    ipcRenderer$5.invoke(THEME_DELETE, { appId, themeKey }),
+    ipcRenderer$6.invoke(THEME_DELETE, { appId, themeKey }),
 };
 
 var themeApi_1 = themeApi$2;
@@ -7256,7 +7351,7 @@ var themeApi_1 = themeApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$4 } = require$$0;
+const { ipcRenderer: ipcRenderer$5 } = require$$0;
 
 const {
   ALGOLIA_LIST_INDICES,
@@ -7270,10 +7365,10 @@ const {
 
 const algoliaApi$2 = {
   listIndices: (application) =>
-    ipcRenderer$4.invoke(ALGOLIA_LIST_INDICES, application),
+    ipcRenderer$5.invoke(ALGOLIA_LIST_INDICES, application),
 
   browseObjects: (appId, apiKey, indexName) => {
-    ipcRenderer$4.invoke(ALGOLIA_BROWSE_OBJECTS, {
+    ipcRenderer$5.invoke(ALGOLIA_BROWSE_OBJECTS, {
       appId,
       apiKey,
       indexName,
@@ -7281,10 +7376,10 @@ const algoliaApi$2 = {
     });
   },
 
-  saveSynonyms: () => ipcRenderer$4.invoke(ALGOLIA_SAVE_SYNONYMS, {}),
+  saveSynonyms: () => ipcRenderer$5.invoke(ALGOLIA_SAVE_SYNONYMS, {}),
 
   getAnalyticsForQuery: (application, indexName, query) =>
-    ipcRenderer$4.invoke(ALGOLIA_ANALYTICS_FOR_QUERY, {
+    ipcRenderer$5.invoke(ALGOLIA_ANALYTICS_FOR_QUERY, {
       application,
       indexName,
       query,
@@ -7297,7 +7392,7 @@ const algoliaApi$2 = {
     dir,
     createIfNotExists = false,
   ) =>
-    ipcRenderer$4.invoke(ALGOLIA_PARTIAL_UPDATE_OBJECTS, {
+    ipcRenderer$5.invoke(ALGOLIA_PARTIAL_UPDATE_OBJECTS, {
       appId,
       apiKey,
       indexName,
@@ -7306,7 +7401,7 @@ const algoliaApi$2 = {
     }),
 
   createBatchesFromFile: (filepath, batchFilepath, batchSize) => {
-    ipcRenderer$4.invoke(ALGOLIA_CREATE_BATCH, {
+    ipcRenderer$5.invoke(ALGOLIA_CREATE_BATCH, {
       filepath,
       batchFilepath,
       batchSize,
@@ -7314,7 +7409,7 @@ const algoliaApi$2 = {
   },
 
   browseObjectsToFile: (appId, apiKey, indexName, toFilename, query = "") => {
-    ipcRenderer$4.invoke(ALGOLIA_BROWSE_OBJECTS, {
+    ipcRenderer$5.invoke(ALGOLIA_BROWSE_OBJECTS, {
       appId,
       apiKey,
       indexName,
@@ -7324,7 +7419,7 @@ const algoliaApi$2 = {
   },
 
   search: (appId, apiKey, indexName, query = "", options = {}) =>
-    ipcRenderer$4.invoke(ALGOLIA_SEARCH, {
+    ipcRenderer$5.invoke(ALGOLIA_SEARCH, {
       appId,
       apiKey,
       indexName,
@@ -7339,14 +7434,14 @@ var algoliaApi_1 = algoliaApi$2;
  * openAI
  */
 
-const { ipcRenderer: ipcRenderer$3 } = require$$0;
+const { ipcRenderer: ipcRenderer$4 } = require$$0;
 
 const { OPENAI_DESCRIBE_IMAGE } = openaiEvents$1;
 
 const openaiApi$2 = {
   // convert a json array of objects to a csv string and save to file
   describeImage: (imageUrl, apiKey, prompt = "What's in this image?") =>
-    ipcRenderer$3.invoke(OPENAI_DESCRIBE_IMAGE, { imageUrl, apiKey, prompt }),
+    ipcRenderer$4.invoke(OPENAI_DESCRIBE_IMAGE, { imageUrl, apiKey, prompt }),
 };
 
 var openaiApi_1 = openaiApi$2;
@@ -7357,14 +7452,14 @@ var openaiApi_1 = openaiApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$2 } = require$$0;
+const { ipcRenderer: ipcRenderer$3 } = require$$0;
 
 const { MENU_ITEMS_SAVE, MENU_ITEMS_LIST } = events$8;
 
 const menuItemsApi$2 = {
   saveMenuItem: (appId, menuItem) =>
-    ipcRenderer$2.invoke(MENU_ITEMS_SAVE, { appId, menuItem }),
-  listMenuItems: (appId) => ipcRenderer$2.invoke(MENU_ITEMS_LIST, { appId }),
+    ipcRenderer$3.invoke(MENU_ITEMS_SAVE, { appId, menuItem }),
+  listMenuItems: (appId) => ipcRenderer$3.invoke(MENU_ITEMS_LIST, { appId }),
 };
 
 var menuItemsApi_1 = menuItemsApi$2;
@@ -7376,16 +7471,67 @@ var menuItemsApi_1 = menuItemsApi$2;
  */
 
 // ipcRenderer that must be used to invoke the events
-const { ipcRenderer: ipcRenderer$1 } = require$$0;
+const { ipcRenderer: ipcRenderer$2 } = require$$0;
 
 const pluginApi$2 = {
   install: (packageName, filepath) =>
-    ipcRenderer$1.invoke("plugin-install", { packageName, filepath }),
-  uninstall: (filepath) => ipcRenderer$1.invoke("plugin-uninstall", filepath),
+    ipcRenderer$2.invoke("plugin-install", { packageName, filepath }),
+  uninstall: (filepath) => ipcRenderer$2.invoke("plugin-uninstall", filepath),
 };
 
 var pluginApi_1 = pluginApi$2;
 
+/**
+ * clientCacheApi.js
+ *
+ * Renderer-side API for cache management.
+ * Communicates with main process via IPC to invalidate cached clients
+ * and manage the response cache.
+ */
+
+const { ipcRenderer: ipcRenderer$1 } = require$$0;
+const {
+  CLIENT_CACHE_INVALIDATE,
+  CLIENT_CACHE_INVALIDATE_ALL,
+  RESPONSE_CACHE_CLEAR,
+  RESPONSE_CACHE_STATS,
+} = events$8;
+
+const clientCacheApi$2 = {
+  /**
+   * Invalidate a specific cached client by provider identity.
+   *
+   * @param {string} appId - the application id
+   * @param {string} providerName - the provider name to invalidate
+   * @returns {Promise<{success: boolean}>}
+   */
+  invalidate: (appId, providerName) =>
+    ipcRenderer$1.invoke(CLIENT_CACHE_INVALIDATE, { appId, providerName }),
+
+  /**
+   * Invalidate all cached clients.
+   *
+   * @returns {Promise<{success: boolean}>}
+   */
+  invalidateAll: () => ipcRenderer$1.invoke(CLIENT_CACHE_INVALIDATE_ALL),
+
+  /**
+   * Clear the response cache.
+   *
+   * @returns {Promise<{success: boolean}>}
+   */
+  clearResponseCache: () => ipcRenderer$1.invoke(RESPONSE_CACHE_CLEAR),
+
+  /**
+   * Get response cache statistics.
+   *
+   * @returns {Promise<{entries: number, inflight: number, keys: string[]}>}
+   */
+  responseCacheStats: () => ipcRenderer$1.invoke(RESPONSE_CACHE_STATS),
+};
+
+var clientCacheApi_1 = clientCacheApi$2;
+
 var widgetRegistry$1 = {exports: {}};
 
 var dynamicWidgetLoader$2 = {exports: {}};
@@ -8739,6 +8885,7 @@ const algoliaApi$1 = algoliaApi_1;
 const openaiApi$1 = openaiApi_1;
 const menuItemsApi$1 = menuItemsApi_1;
 const pluginApi$1 = pluginApi_1;
+const clientCacheApi$1 = clientCacheApi_1;
 
 // Events constants
 const events$1 = events$8;
@@ -8806,6 +8953,7 @@ function createMainApi$1(extensions = {}) {
     openai: openaiApi$1,
     menuItems: menuItemsApi$1,
     plugins: pluginApi$1,
+    clientCache: clientCacheApi$1,
 
     // Merge template-specific extensions
     ...extensions,
@@ -8835,7 +8983,7 @@ const workspaceController = workspaceController_1;
 const themeController = themeController_1;
 const dataController = dataController_1;
 const settingsController = settingsController_1;
-const providerController = providerController_1;
+const providerController = requireProviderController();
 const layoutController = layoutController_1;
 const mcpController = mcpController_1;
 const registryController = registryController$1;
@@ -8845,7 +8993,8 @@ const menuItemsController = menuItemsController_1;
 const pluginController = pluginController_1;
 
 // --- Utils ---
-const clientCache = clientCache_1;
+const clientCache = requireClientCache();
+ // auto-register built-in factories
 const responseCache = responseCache_1;
 
 // --- Controller functions (flat, for convenient destructuring) ---
@@ -8867,6 +9016,7 @@ const algoliaApi = algoliaApi_1;
 const openaiApi = openaiApi_1;
 const menuItemsApi = menuItemsApi_1;
 const pluginApi = pluginApi_1;
+const clientCacheApi = clientCacheApi_1;
 
 // --- Events ---
 const events = events$8;
@@ -8915,6 +9065,7 @@ var electron = {
   openaiApi,
   menuItemsApi,
   pluginApi,
+  clientCacheApi,
 
   // Events
   events,
@@ -8931,6 +9082,9 @@ var electron = {
   // Utils
   clientCache,
   responseCache,
+
+  // Setup helpers
+  setupCacheHandlers: clientCache.setupCacheHandlers.bind(clientCache),
 };
 
 var index = /*@__PURE__*/getDefaultExportFromCjs(electron);