@trops/dash-core 0.1.533 → 0.1.534

package/dist/electron/index.js

@@ -1642,7 +1642,7 @@ var themeController_1 = themeController$5;
  */
 
 const path$j = require$$1$1;
-const fs$f = require$$0$2;
+const fs$g = require$$0$2;
 const { app: app$c } = require$$0$1;
 
 const APP_NAME = "Dashboard";
@@ -1691,8 +1691,8 @@ function readDataDirectoryFromSettings() {
       APP_NAME,
       "settings.json",
     );
-    if (!fs$f.existsSync(settingsPath)) return undefined;
-    const raw = fs$f.readFileSync(settingsPath, "utf8");
+    if (!fs$g.existsSync(settingsPath)) return undefined;
+    const raw = fs$g.readFileSync(settingsPath, "utf8");
     const settings = JSON.parse(raw);
     const dir = settings && settings.dataDirectory;
     if (typeof dir === "string" && dir) return dir;
@@ -1725,10 +1725,10 @@ function safePath$3(requested, allowedRoots) {
   // parent chain can't trick us.
   let real = resolved;
   try {
-    real = fs$f.realpathSync(resolved);
+    real = fs$g.realpathSync(resolved);
   } catch (_e) {
     try {
-      const parent = fs$f.realpathSync(path$j.dirname(resolved));
+      const parent = fs$g.realpathSync(path$j.dirname(resolved));
       real = path$j.join(parent, path$j.basename(resolved));
     } catch (_e2) {
       // Parent doesn't exist either. Use the resolved-but-not-
@@ -1741,7 +1741,7 @@ function safePath$3(requested, allowedRoots) {
   for (const root of allowedRoots) {
     let realRoot = root;
     try {
-      if (fs$f.existsSync(root)) realRoot = fs$f.realpathSync(root);
+      if (fs$g.existsSync(root)) realRoot = fs$g.realpathSync(root);
     } catch (_e) {
       // root doesn't exist or isn't reachable — keep as-is for
       // the comparison below
@@ -1809,7 +1809,7 @@ var safePath_1 = {
  *   clearCache() → void   // test-only
  */
 
-const fs$e = require$$0$2;
+const fs$f = require$$0$2;
 const path$i = require$$1$1;
 const { app: app$b } = require$$0$1;
 
@@ -1825,9 +1825,9 @@ function grantsFilePath() {
 
 function loadFromDisk() {
   const p = grantsFilePath();
-  if (!fs$e.existsSync(p)) return {};
+  if (!fs$f.existsSync(p)) return {};
   try {
-    const raw = fs$e.readFileSync(p, "utf8");
+    const raw = fs$f.readFileSync(p, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return {};
     return parsed;
@@ -1847,9 +1847,9 @@ function writeToDisk(data) {
   const tmp = p + ".tmp";
   // Ensure parent dir exists (userData should already, but be defensive
   // for first-launch / freshly-cleared profile cases).
-  fs$e.mkdirSync(path$i.dirname(p), { recursive: true });
-  fs$e.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf8");
-  fs$e.renameSync(tmp, p);
+  fs$f.mkdirSync(path$i.dirname(p), { recursive: true });
+  fs$f.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf8");
+  fs$f.renameSync(tmp, p);
 }
 
 // Recognized origins for a persisted grant.
@@ -2481,7 +2481,7 @@ function commonjsRequire(path) {
  * Runs in the Electron main process at widget install time.
  */
 
-const fs$d = require$$0$2;
+const fs$e = require$$0$2;
 const path$h = require$$1$1;
 
 /**
@@ -2535,7 +2535,7 @@ function getEsbuildDiagnostics() {
         ? path$h.join(archDir, "esbuild.exe")
         : path$h.join(archDir, "bin", "esbuild");
     diagnostics.nativeBinaryPath = candidate;
-    diagnostics.nativeBinaryExists = fs$d.existsSync(candidate);
+    diagnostics.nativeBinaryExists = fs$e.existsSync(candidate);
   } catch (err) {
     diagnostics.archResolveError = err.message;
   }
@@ -2582,25 +2582,25 @@ async function healthCheck() {
  */
 function findWidgetsDir$2(widgetPath) {
   const direct = path$h.join(widgetPath, "widgets");
-  if (fs$d.existsSync(direct)) {
+  if (fs$e.existsSync(direct)) {
     return direct;
   }
 
   // Check configs/widgets/ (packageZip.js nests .dash.js files here)
   const configsWidgets = path$h.join(widgetPath, "configs", "widgets");
-  if (fs$d.existsSync(configsWidgets)) {
+  if (fs$e.existsSync(configsWidgets)) {
     return configsWidgets;
   }
 
   // Check configs/ directory (used by packageZip.js for distributed widgets)
   const configs = path$h.join(widgetPath, "configs");
-  if (fs$d.existsSync(configs)) {
+  if (fs$e.existsSync(configs)) {
     return configs;
   }
 
   // Check one level deeper for nested ZIP extraction
   try {
-    const entries = fs$d.readdirSync(widgetPath, { withFileTypes: true });
+    const entries = fs$e.readdirSync(widgetPath, { withFileTypes: true });
     const subdirs = entries.filter(
       (e) =>
         e.isDirectory() &&
@@ -2611,7 +2611,7 @@ function findWidgetsDir$2(widgetPath) {
 
     for (const subdir of subdirs) {
       const nested = path$h.join(widgetPath, subdir.name, "widgets");
-      if (fs$d.existsSync(nested)) {
+      if (fs$e.existsSync(nested)) {
         console.log(`[WidgetCompiler] Found nested widgets/ at ${nested}`);
         return nested;
       }
@@ -2645,7 +2645,7 @@ async function compileWidget$1(widgetPath) {
   }
 
   // Discover .dash.js config files
-  const files = fs$d.readdirSync(widgetsDir);
+  const files = fs$e.readdirSync(widgetsDir);
   const dashFiles = files.filter((f) => f.endsWith(".dash.js"));
 
   if (dashFiles.length === 0) {
@@ -2667,7 +2667,7 @@ async function compileWidget$1(widgetPath) {
     const componentName = dashFile.replace(".dash.js", "");
     const componentFile = `${componentName}.js`;
     const componentFilePath = path$h.join(widgetsDir, componentFile);
-    const hasComponent = fs$d.existsSync(componentFilePath);
+    const hasComponent = fs$e.existsSync(componentFilePath);
 
     // Import the config (always)
     imports.push(
@@ -2705,11 +2705,11 @@ async function compileWidget$1(widgetPath) {
 
   try {
     // Ensure dist/ directory exists
-    if (!fs$d.existsSync(distDir)) {
-      fs$d.mkdirSync(distDir, { recursive: true });
+    if (!fs$e.existsSync(distDir)) {
+      fs$e.mkdirSync(distDir, { recursive: true });
     }
 
-    fs$d.writeFileSync(entryPath, entryContent, "utf8");
+    fs$e.writeFileSync(entryPath, entryContent, "utf8");
 
     console.log(
       `[WidgetCompiler] Compiling ${dashFiles.length} component(s) from ${widgetPath}`,
@@ -2765,8 +2765,8 @@ async function compileWidget$1(widgetPath) {
   } finally {
     // Clean up temporary entry file
     try {
-      if (fs$d.existsSync(entryPath)) {
-        fs$d.unlinkSync(entryPath);
+      if (fs$e.existsSync(entryPath)) {
+        fs$e.unlinkSync(entryPath);
       }
     } catch (cleanupError) {
       // Non-fatal
@@ -2798,7 +2798,7 @@ var widgetCompiler$1 = {
  * Integrates with ComponentManager for automatic registration
  */
 
-const fs$c = require$$0$2;
+const fs$d = require$$0$2;
 const path$g = require$$1$1;
 const vm = require$$2;
 const { findWidgetsDir: findWidgetsDir$1 } = widgetCompiler$1;
@@ -2891,10 +2891,10 @@ class DynamicWidgetLoader {
       const componentPath = path$g.join(widgetsDir, `${componentName}.js`);
       const configPath = path$g.join(widgetsDir, `${componentName}.dash.js`);
 
-      if (!fs$c.existsSync(componentPath)) {
+      if (!fs$d.existsSync(componentPath)) {
         throw new Error(`Component file not found: ${componentPath}`);
       }
-      if (!fs$c.existsSync(configPath)) {
+      if (!fs$d.existsSync(configPath)) {
         throw new Error(`Config file not found: ${configPath}`);
       }
 
@@ -2945,7 +2945,7 @@ class DynamicWidgetLoader {
    */
   async loadConfigFile(configPath) {
     try {
-      const source = fs$c.readFileSync(configPath, "utf8");
+      const source = fs$d.readFileSync(configPath, "utf8");
 
       let exportMatch = source.match(/export\s+default\s+({[\s\S]*});?\s*$/);
 
@@ -3013,7 +3013,7 @@ class DynamicWidgetLoader {
         return [];
       }
 
-      const files = fs$c.readdirSync(widgetsDir);
+      const files = fs$d.readdirSync(widgetsDir);
       const widgets = new Set();
 
       files.forEach((file) => {
@@ -3499,7 +3499,7 @@ var registryAuthController$2 = {
  *     Test-only. Drops the in-process cache so tests can re-read.
  */
 
-const fs$b = require$$0$2;
+const fs$c = require$$0$2;
 const path$f = require$$1$1;
 const os$2 = require$$2$1;
 const { app: app$a } = require$$0$1;
@@ -3599,12 +3599,12 @@ function resolveWidgetPackagePath(widgetId) {
 function getWidgetMcpPermissions$1(widgetId) {
   if (_cache.has(widgetId)) return _cache.get(widgetId);
   const pkgPath = resolveWidgetPackagePath(widgetId);
-  if (!pkgPath || !fs$b.existsSync(pkgPath)) {
+  if (!pkgPath || !fs$c.existsSync(pkgPath)) {
     _cache.set(widgetId, null);
     return null;
   }
   try {
-    const raw = fs$b.readFileSync(pkgPath, "utf8");
+    const raw = fs$c.readFileSync(pkgPath, "utf8");
     const pkg = JSON.parse(raw);
     const perms = parseManifestPermissions(pkg);
     _cache.set(widgetId, perms);
@@ -3654,7 +3654,7 @@ var widgetPermissions = {
  * (Slices 1-3) is the actual boundary.
  */
 
-const fs$a = require$$0$2;
+const fs$b = require$$0$2;
 const path$e = require$$1$1;
 
 const SOURCE_EXTENSIONS = new Set([
@@ -3708,7 +3708,7 @@ function readSourceFiles(dir) {
   function walk(current, relBase) {
     let entries;
     try {
-      entries = fs$a.readdirSync(current, { withFileTypes: true });
+      entries = fs$b.readdirSync(current, { withFileTypes: true });
     } catch {
       return;
     }
@@ -3725,7 +3725,7 @@ function readSourceFiles(dir) {
         try {
           result.push({
             relPath: rel,
-            source: fs$a.readFileSync(abs, "utf8"),
+            source: fs$b.readFileSync(abs, "utf8"),
           });
         } catch {
           // unreadable — skip
@@ -7623,7 +7623,7 @@ function requireTransform () {
 }
 
 const { app: app$9 } = require$$0$1;
-var fs$9 = require$$0$2;
+var fs$a = require$$0$2;
 const path$d = require$$1$1;
 const events$5 = events$8;
 const { getFileContents: getFileContents$5, writeToFile: writeToFile$2 } = file;
@@ -7646,8 +7646,8 @@ function _loadFlags$1() {
       appName$5,
       "settings.json",
     );
-    if (!fs$9.existsSync(settingsPath)) return null;
-    return JSON.parse(fs$9.readFileSync(settingsPath, "utf8"));
+    if (!fs$a.existsSync(settingsPath)) return null;
+    return JSON.parse(fs$a.readFileSync(settingsPath, "utf8"));
   } catch (_e) {
     return null;
   }
@@ -7904,7 +7904,7 @@ const dataController$1 = {
       // intent, plus realpath/symlink protection.
       const resolvedFilepath = safePath$2(toFilepath, getAllowedRoots$1("data"));
 
-      const writeStream = fs$9.createWriteStream(resolvedFilepath);
+      const writeStream = fs$a.createWriteStream(resolvedFilepath);
 
       https$3
         .get(url, (resp) => {
@@ -8280,7 +8280,7 @@ var dataController_1 = dataController$1;
 
 const { app: app$8 } = require$$0$1;
 const path$c = require$$1$1;
-const fs$8 = require$$0$2;
+const fs$9 = require$$0$2;
 const { getFileContents: getFileContents$4, writeToFile: writeToFile$1 } = file;
 
 const configFilename$3 = "settings.json";
@@ -8288,15 +8288,15 @@ const appName$4 = "Dashboard";
 
 // Helper function to recursively copy directory
 function copyDirectory(source, destination) {
-  if (!fs$8.existsSync(destination)) {
-    fs$8.mkdirSync(destination, { recursive: true });
+  if (!fs$9.existsSync(destination)) {
+    fs$9.mkdirSync(destination, { recursive: true });
   }
 
-  const files = fs$8.readdirSync(source);
+  const files = fs$9.readdirSync(source);
   for (const file of files) {
     const srcPath = path$c.join(source, file);
     const destPath = path$c.join(destination, file);
-    const stat = fs$8.lstatSync(srcPath);
+    const stat = fs$9.lstatSync(srcPath);
 
     // Skip symlinks to prevent following links to sensitive files
     if (stat.isSymbolicLink()) {
@@ -8307,7 +8307,7 @@ function copyDirectory(source, destination) {
     if (stat.isDirectory()) {
       copyDirectory(srcPath, destPath);
     } else {
-      fs$8.copyFileSync(srcPath, destPath);
+      fs$9.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -8425,11 +8425,11 @@ const settingsController$4 = {
   setDataDirectory: (win, newPath) => {
     try {
       // Validate the path exists and is a directory
-      if (!fs$8.existsSync(newPath)) {
-        fs$8.mkdirSync(newPath, { recursive: true });
+      if (!fs$9.existsSync(newPath)) {
+        fs$9.mkdirSync(newPath, { recursive: true });
       }
 
-      const stats = fs$8.statSync(newPath);
+      const stats = fs$9.statSync(newPath);
       if (!stats.isDirectory()) {
         throw new Error("Path is not a directory");
       }
@@ -8506,12 +8506,12 @@ const settingsController$4 = {
       }
 
       // Validate paths
-      if (!fs$8.existsSync(resolvedOldPath)) {
+      if (!fs$9.existsSync(resolvedOldPath)) {
         throw new Error("Source directory does not exist");
       }
 
-      if (!fs$8.existsSync(resolvedNewPath)) {
-        fs$8.mkdirSync(resolvedNewPath, { recursive: true });
+      if (!fs$9.existsSync(resolvedNewPath)) {
+        fs$9.mkdirSync(resolvedNewPath, { recursive: true });
       }
 
       // Copy files
@@ -26946,7 +26946,7 @@ const {
   StreamableHTTPClientTransport,
 } = streamableHttp$1;
 const path$a = require$$1$1;
-const fs$7 = require$$0$2;
+const fs$8 = require$$0$2;
 const os$1 = require$$2$1;
 const responseCache$2 = responseCache_1;
 const { gateToolCall, gateToolCallWithJit } = permissionGate;
@@ -26967,8 +26967,8 @@ function loadSettingsForFlags() {
       "Dashboard",
       "settings.json",
     );
-    if (!fs$7.existsSync(settingsPath)) return null;
-    const raw = fs$7.readFileSync(settingsPath, "utf8");
+    if (!fs$8.existsSync(settingsPath)) return null;
+    const raw = fs$8.readFileSync(settingsPath, "utf8");
     return JSON.parse(raw);
   } catch (_e) {
     return null;
@@ -27135,7 +27135,7 @@ function getShellPath$1() {
     fallbackDirs.push(`${home}/.nodenv/shims`);
     try {
       const nvmDir = `${home}/.nvm/versions/node`;
-      const versions = fs$7.readdirSync(nvmDir).sort();
+      const versions = fs$8.readdirSync(nvmDir).sort();
       if (versions.length > 0) {
         // Find the highest compatible version (v18/v20/v22)
         for (let i = versions.length - 1; i >= 0; i--) {
@@ -27271,15 +27271,15 @@ async function refreshGoogleOAuthToken(tokenRefresh) {
   const credPath = tokenRefresh.credentialsPath.replace(/^~/, home);
   const keysPath = tokenRefresh.oauthKeysPath.replace(/^~/, home);
 
-  if (!fs$7.existsSync(credPath) || !fs$7.existsSync(keysPath)) {
+  if (!fs$8.existsSync(credPath) || !fs$8.existsSync(keysPath)) {
     console.log(
       "[mcpController] Token refresh skipped: credential files not found",
     );
     return;
   }
 
-  const credentials = JSON.parse(fs$7.readFileSync(credPath, "utf8"));
-  const keysFile = JSON.parse(fs$7.readFileSync(keysPath, "utf8"));
+  const credentials = JSON.parse(fs$8.readFileSync(credPath, "utf8"));
+  const keysFile = JSON.parse(fs$8.readFileSync(keysPath, "utf8"));
   const keyData = keysFile.installed || keysFile.web;
 
   if (
@@ -27348,7 +27348,7 @@ async function refreshGoogleOAuthToken(tokenRefresh) {
     credentials.refresh_token = body.refresh_token;
   }
 
-  fs$7.writeFileSync(credPath, JSON.stringify(credentials, null, 2));
+  fs$8.writeFileSync(credPath, JSON.stringify(credentials, null, 2));
   console.log("[mcpController] Google OAuth token refreshed successfully");
 }
 
@@ -27998,13 +27998,13 @@ const mcpController$3 = {
         "mcpServerCatalog.json",
       );
 
-      if (!fs$7.existsSync(catalogPath)) {
+      if (!fs$8.existsSync(catalogPath)) {
         return {
           catalog: [],
         };
       }
 
-      const catalogData = fs$7.readFileSync(catalogPath, "utf8");
+      const catalogData = fs$8.readFileSync(catalogPath, "utf8");
       const catalog = JSON.parse(catalogData);
 
       return {
@@ -28039,11 +28039,11 @@ const mcpController$3 = {
         "knownExternalMcpServers.json",
       );
 
-      if (!fs$7.existsSync(catalogPath)) {
+      if (!fs$8.existsSync(catalogPath)) {
         return { success: true, servers: [] };
       }
 
-      const catalogData = fs$7.readFileSync(catalogPath, "utf8");
+      const catalogData = fs$8.readFileSync(catalogPath, "utf8");
       const catalog = JSON.parse(catalogData);
 
       return {
@@ -28108,8 +28108,8 @@ const mcpController$3 = {
         const destPath = to.replace(/^~/, os$1.homedir());
         const destDir = require$$1$1.dirname(destPath);
         try {
-          fs$7.mkdirSync(destDir, { recursive: true });
-          fs$7.copyFileSync(sourcePath, destPath);
+          fs$8.mkdirSync(destDir, { recursive: true });
+          fs$8.copyFileSync(sourcePath, destPath);
         } catch (err) {
           return {
             error: true,
@@ -28278,7 +28278,7 @@ var mcpControllerExports = mcpController$4.exports;
  */
 
 const path$9 = require$$1$1;
-const fs$6 = require$$0$2;
+const fs$7 = require$$0$2;
 const os = require$$2$1;
 const { toPackageId } = packageId;
 const { getStoredToken: getStoredToken$3 } = registryAuthController$2;
@@ -28354,12 +28354,12 @@ async function fetchRegistryIndex(forceRefresh = false) {
     if (isDev()) {
       // In dev mode, try local test file first
       const testPath = getTestRegistryPath();
-      if (fs$6.existsSync(testPath)) {
+      if (fs$7.existsSync(testPath)) {
         console.log(
           "[RegistryController] Loading test registry from:",
           testPath,
         );
-        const raw = fs$6.readFileSync(testPath, "utf8");
+        const raw = fs$7.readFileSync(testPath, "utf8");
         indexData = JSON.parse(raw);
       } else {
         // Fall back to API (supports DASH_REGISTRY_URL as full-URL override)
@@ -28786,8 +28786,8 @@ async function fetchPackageSource(packageName, componentName = null) {
     let configCode = "";
     let widgetName = null;
 
-    if (fs$6.existsSync(widgetsDir)) {
-      const files = fs$6.readdirSync(widgetsDir);
+    if (fs$7.existsSync(widgetsDir)) {
+      const files = fs$7.readdirSync(widgetsDir);
       const dashFiles = files.filter((f) => f.endsWith(".dash.js"));
       const componentFiles = files.filter(
         (f) => f.endsWith(".js") && !f.endsWith(".dash.js") && f !== "index.js",
@@ -28809,7 +28809,7 @@ async function fetchPackageSource(packageName, componentName = null) {
       if (!configFile) configFile = dashFiles[0];
 
       if (configFile) {
-        configCode = fs$6.readFileSync(path$9.join(widgetsDir, configFile), "utf8");
+        configCode = fs$7.readFileSync(path$9.join(widgetsDir, configFile), "utf8");
         widgetName = configFile.replace(/\.dash\.js$/, "");
       }
 
@@ -28823,7 +28823,7 @@ async function fetchPackageSource(packageName, componentName = null) {
       if (!componentFile) componentFile = componentFiles[0];
 
       if (componentFile) {
-        componentCode = fs$6.readFileSync(
+        componentCode = fs$7.readFileSync(
           path$9.join(widgetsDir, componentFile),
           "utf8",
         );
@@ -28833,15 +28833,15 @@ async function fetchPackageSource(packageName, componentName = null) {
 
     let bundleSource = null;
     const bundlePath = path$9.join(tempDir, "dist", "index.cjs.js");
-    if (fs$6.existsSync(bundlePath)) {
-      bundleSource = fs$6.readFileSync(bundlePath, "utf8");
+    if (fs$7.existsSync(bundlePath)) {
+      bundleSource = fs$7.readFileSync(bundlePath, "utf8");
     }
 
     let dashMeta = {};
     const dashPath = path$9.join(tempDir, "dash.json");
-    if (fs$6.existsSync(dashPath)) {
+    if (fs$7.existsSync(dashPath)) {
       try {
-        dashMeta = JSON.parse(fs$6.readFileSync(dashPath, "utf8"));
+        dashMeta = JSON.parse(fs$7.readFileSync(dashPath, "utf8"));
       } catch {
         // Ignore — metadata is optional for preview
       }
@@ -28860,7 +28860,7 @@ async function fetchPackageSource(packageName, componentName = null) {
     };
   } finally {
     try {
-      fs$6.rmSync(tempDir, { recursive: true, force: true });
+      fs$7.rmSync(tempDir, { recursive: true, force: true });
     } catch (err) {
       console.warn(
         `[RegistryController] Failed to clean up preview temp dir ${tempDir}:`,
@@ -28880,7 +28880,7 @@ var registryController$3 = {
   fetchPackageSource,
 };
 
-var fs$5 = require$$0$2;
+var fs$6 = require$$0$2;
 var JSONStream = require$$4$1;
 const algoliasearch$1 = require$$2$3;
 const path$8 = require$$3$3;
@@ -28921,7 +28921,7 @@ let AlgoliaIndex$1 = class AlgoliaIndex {
       var batchNumber = 1;
 
       // create the readStream to parse the large file (json)
-      var readStream = fs$5.createReadStream(filepath).pipe(parser);
+      var readStream = fs$6.createReadStream(filepath).pipe(parser);
 
       var batch = [];
 
@@ -28935,7 +28935,7 @@ let AlgoliaIndex$1 = class AlgoliaIndex {
               // lets write to the batch file
               if (countForBatch === batchSize) {
                 // write to the batch file
-                var writeStream = fs$5.createWriteStream(
+                var writeStream = fs$6.createWriteStream(
                   batchFilepath + "/batch_" + batchNumber + ".json",
                 );
                 writeStream.write(JSON.stringify(batch));
@@ -28986,11 +28986,11 @@ let AlgoliaIndex$1 = class AlgoliaIndex {
     return new Promise((resolve, reject) => {
       try {
         checkDirectory(directoryPath);
-        fs$5.readdir(directoryPath, (err, files) => {
+        fs$6.readdir(directoryPath, (err, files) => {
           if (err) reject(err);
           if (files) {
             files.forEach((file) => {
-              fs$5.unlinkSync(path$8.join(directoryPath, file));
+              fs$6.unlinkSync(path$8.join(directoryPath, file));
             });
             resolve();
           }
@@ -29009,7 +29009,7 @@ let AlgoliaIndex$1 = class AlgoliaIndex {
   ) {
     try {
       // read the directory...
-      const files = await fs$5.readdirSync(batchFilepath);
+      const files = await fs$6.readdirSync(batchFilepath);
       let results = [];
       for (const fileIndex in files) {
         // for each file lets read the file and then push to algolia
@@ -29038,7 +29038,7 @@ let AlgoliaIndex$1 = class AlgoliaIndex {
 
   async readFile(filepath) {
     return await new Promise((resolve, reject) => {
-      fs$5.readFile(filepath, "utf8", (err, data) => {
+      fs$6.readFile(filepath, "utf8", (err, data) => {
         if (err) {
           reject(err);
         }
@@ -29188,7 +29188,7 @@ var algolia = AlgoliaIndex$1;
 const algoliasearch = require$$2$3;
 const events$3 = events$8;
 const AlgoliaIndex = algolia;
-var fs$4 = require$$0$2;
+var fs$5 = require$$0$2;
 const { safePath, getAllowedRoots } = safePath_1;
 
 const algoliaController$1 = {
@@ -29297,7 +29297,7 @@ const algoliaController$1 = {
         // init the Algolia Index helper
         const a = new AlgoliaIndex(appId, apiKey, indexName);
         // create the write stream to store the hits
-        const writeStream = fs$4.createWriteStream(toFilename);
+        const writeStream = fs$5.createWriteStream(toFilename);
         writeStream.write("[");
 
         let sep = "";
@@ -49390,7 +49390,7 @@ streamableHttp.StreamableHTTPServerTransport = StreamableHTTPServerTransport$1;
  *   https.createServer({ key, cert }, handler);
  */
 
-const fs$3 = require$$0$2;
+const fs$4 = require$$0$2;
 const path$6 = require$$1$1;
 const forge = require$$2$4;
 
@@ -49404,10 +49404,10 @@ function getOrCreateCert$1(certsDir) {
   const keyPath = path$6.join(certsDir, "key.pem");
 
   // Return existing cert if valid
-  if (fs$3.existsSync(certPath) && fs$3.existsSync(keyPath)) {
+  if (fs$4.existsSync(certPath) && fs$4.existsSync(keyPath)) {
     try {
-      const cert = fs$3.readFileSync(certPath, "utf8");
-      const key = fs$3.readFileSync(keyPath, "utf8");
+      const cert = fs$4.readFileSync(certPath, "utf8");
+      const key = fs$4.readFileSync(keyPath, "utf8");
       // Verify cert is not expired
       const parsed = forge.pki.certificateFromPem(cert);
       if (parsed.validity.notAfter > new Date()) {
@@ -49473,9 +49473,9 @@ function getOrCreateCert$1(certsDir) {
   const keyPem = forge.pki.privateKeyToPem(keys.privateKey);
 
   // Write to disk
-  fs$3.mkdirSync(certsDir, { recursive: true });
-  fs$3.writeFileSync(certPath, certPem, { mode: 0o644 });
-  fs$3.writeFileSync(keyPath, keyPem, { mode: 0o600 });
+  fs$4.mkdirSync(certsDir, { recursive: true });
+  fs$4.writeFileSync(certPath, certPem, { mode: 0o644 });
+  fs$4.writeFileSync(keyPath, keyPem, { mode: 0o600 });
 
   console.log(`[tlsCert] Certificate saved to ${certsDir}`);
 
@@ -56904,6 +56904,74 @@ var dashboardConfigValidator$1 = {
   CURRENT_SCHEMA_VERSION: CURRENT_SCHEMA_VERSION$1,
 };
 
+/**
+ * aggregateWidgetPermissions
+ *
+ * Pure helper that unions every widget's `dash.permissions.mcp` block
+ * into a single dashboard-level summary. Each input entry carries
+ * `{ packageId, version, permissions }`; this function ignores
+ * packageId / version (they belong on the per-widget entry in the
+ * manifest) and just produces the merged `{ server: { tools, readPaths,
+ * writePaths } }` shape suitable for top-level display.
+ *
+ * The aggregate is a UX convenience for "what does this dashboard
+ * need overall?" The authoritative source remains the per-widget
+ * permissions block embedded next to each widget dependency in the
+ * registry manifest — those carry their pinned version, so installers
+ * can be sure the disclosure matches what they're about to fetch.
+ */
+
+var aggregateWidgetPermissions_1;
+var hasRequiredAggregateWidgetPermissions;
+
+function requireAggregateWidgetPermissions () {
+	if (hasRequiredAggregateWidgetPermissions) return aggregateWidgetPermissions_1;
+	hasRequiredAggregateWidgetPermissions = 1;
+
+	function aggregateWidgetPermissions(entries) {
+	  const out = {};
+	  if (!Array.isArray(entries)) return out;
+	  for (const entry of entries) {
+	    if (!entry || typeof entry !== "object") continue;
+	    const perms = entry.permissions;
+	    if (!perms || typeof perms !== "object") continue;
+	    for (const [serverName, raw] of Object.entries(perms)) {
+	      if (!raw || typeof raw !== "object") continue;
+	      if (!out[serverName]) {
+	        out[serverName] = { tools: [], readPaths: [], writePaths: [] };
+	      }
+	      mergeStringArray(out[serverName], "tools", raw.tools);
+	      mergeStringArray(out[serverName], "readPaths", raw.readPaths);
+	      mergeStringArray(out[serverName], "writePaths", raw.writePaths);
+	    }
+	  }
+	  // Drop empty arrays from the output to keep the manifest small.
+	  for (const serverName of Object.keys(out)) {
+	    const block = out[serverName];
+	    if (block.tools.length === 0) delete block.tools;
+	    if (block.readPaths.length === 0) delete block.readPaths;
+	    if (block.writePaths.length === 0) delete block.writePaths;
+	    // If the server has no content at all, drop the server entry too.
+	    if (Object.keys(block).length === 0) delete out[serverName];
+	  }
+	  // Re-add `tools: []` for tests that expect the field to exist.
+	  // (Handled implicitly by mergeStringArray; just leaves out empty.)
+	  return out;
+	}
+
+	function mergeStringArray(target, key, source) {
+	  if (!Array.isArray(source)) return;
+	  const set = new Set(target[key]);
+	  for (const item of source) {
+	    if (typeof item === "string" && item) set.add(item);
+	  }
+	  target[key] = Array.from(set);
+	}
+
+	aggregateWidgetPermissions_1 = { aggregateWidgetPermissions };
+	return aggregateWidgetPermissions_1;
+}
+
 /**
  * dashboardConfigUtils.js
  *
@@ -57479,7 +57547,16 @@ function generateRegistryManifest(dashboardConfig, options = {}) {
       const scopedPackageId = remappedScope
         ? `@${remappedScope.replace(/^@/, "")}/${bareName}`
         : bareName;
-      return {
+      // Slice 13c: pair each widget dependency with its
+      // `dash.permissions.mcp` block, sourced from the publisher's
+      // local install at publish time. The block stays paired with
+      // the pinned version next to it (`version` field above) so
+      // installers can verify "the permissions disclosure was
+      // computed against the version we're about to fetch."
+      const permEntry = (options.widgetPermissions || []).find(
+        (p) => p && p.packageId === scopedPackageId,
+      );
+      const out = {
         id: w.id,
         scope: remappedScope,
         packageName: bareName,
@@ -57495,11 +57572,28 @@ function generateRegistryManifest(dashboardConfig, options = {}) {
         required: w.required !== false,
         author: w.author || "",
       };
+      if (permEntry && permEntry.permissions) {
+        out.permissions = permEntry.permissions;
+      }
+      return out;
     }),
     providers: dashboardConfig.providers || [],
     eventWiring: dashboardConfig.eventWiring || [],
   };
 
+  // Slice 13c: top-level aggregated permissions for fast UI summary.
+  // The per-widget permissions on `manifest.widgets[i].permissions`
+  // remain the authoritative version-pinned source.
+  if (Array.isArray(options.widgetPermissions)) {
+    const {
+      aggregateWidgetPermissions,
+    } = requireAggregateWidgetPermissions();
+    const aggregated = aggregateWidgetPermissions(options.widgetPermissions);
+    if (Object.keys(aggregated).length > 0) {
+      manifest.permissions = aggregated;
+    }
+  }
+
   if (options.appOrigin || dashboardConfig.appOrigin) {
     manifest.appOrigin = options.appOrigin || dashboardConfig.appOrigin;
   }
@@ -58135,7 +58229,7 @@ var dashboardConfigUtils$1 = {
  * Handles publishing packages and generating registry URLs.
  */
 
-const fs$2 = require$$0$2;
+const fs$3 = require$$0$2;
 const path$5 = require$$1$1;
 const { getStoredToken: getStoredToken$2 } = registryAuthController$2;
 
@@ -58162,7 +58256,7 @@ async function publishToRegistry$1(zipPath, manifest) {
 
   try {
     // Read the ZIP file
-    const zipBuffer = fs$2.readFileSync(zipPath);
+    const zipBuffer = fs$3.readFileSync(zipPath);
 
     // Create FormData with the ZIP and manifest
     const formData = new FormData();
@@ -58372,7 +58466,7 @@ function requireWidgetPublishManifest () {
 	    })),
 	  }));
 
-	  return {
+	  const manifest = {
 	    scope,
 	    name,
 	    displayName: options.displayName || packageJson.displayName || name,
@@ -58393,6 +58487,48 @@ function requireWidgetPublishManifest () {
 	    appOrigin: options.appOrigin || "",
 	    publishedAt: new Date().toISOString(),
 	  };
+
+	  // Slice 13c: forward `dash.permissions.mcp` from package.json into
+	  // the registry manifest so installers can show "what tools does
+	  // this widget need" before downloading. The block is computed by
+	  // the install/publish/boot scanner pipeline (slice 13a/13b) and
+	  // sanitized here on the way out.
+	  const sanitizedPermissions = sanitizePermissionsBlock(
+	    packageJson?.dash?.permissions?.mcp,
+	  );
+	  if (sanitizedPermissions) manifest.permissions = sanitizedPermissions;
+
+	  return manifest;
+	}
+
+	/**
+	 * Defensive sanitizer — keeps the published manifest safe even if a
+	 * widget's package.json has a malformed permissions block. Drops
+	 * non-object server values and filters tools/readPaths/writePaths
+	 * down to non-empty strings. Returns null if the block has no
+	 * surviving content (caller omits the field entirely).
+	 */
+	function sanitizePermissionsBlock(raw) {
+	  if (!raw || typeof raw !== "object") return null;
+	  const out = {};
+	  for (const [serverName, value] of Object.entries(raw)) {
+	    if (!value || typeof value !== "object") continue;
+	    const block = {};
+	    if (Array.isArray(value.tools)) {
+	      const tools = value.tools.filter((t) => typeof t === "string" && t);
+	      if (tools.length > 0) block.tools = tools;
+	    }
+	    if (Array.isArray(value.readPaths)) {
+	      const r = value.readPaths.filter((p) => typeof p === "string" && p);
+	      if (r.length > 0) block.readPaths = r;
+	    }
+	    if (Array.isArray(value.writePaths)) {
+	      const w = value.writePaths.filter((p) => typeof p === "string" && p);
+	      if (w.length > 0) block.writePaths = w;
+	    }
+	    if (Object.keys(block).length > 0) out[serverName] = block;
+	  }
+	  return Object.keys(out).length > 0 ? out : null;
 	}
 
 	widgetPublishManifest = {
@@ -60806,6 +60942,81 @@ async function prepareDashboardForPublish$1(
       registryCheckFailed = true;
     }
 
+    // Slice 13c: collect each widget's local `dash.permissions.mcp`
+    // block and pair it with the version on disk. This array becomes
+    // the source-of-truth for both the per-widget `permissions` field
+    // on each manifest.widgets[] entry AND the top-level aggregated
+    // `manifest.permissions` block. Includes third-party widgets too
+    // — every dashboard dependency lives under widgets/ on the
+    // publisher's machine, scanner pipeline (slice 13a/b) keeps each
+    // package.json's permissions block fresh.
+    const widgetPermissions = [];
+    const installedWidgets = widgetRegistry
+      ? widgetRegistry.getWidgets() || []
+      : [];
+    const unpinnedDeps = [];
+    for (const w of dashboardConfig.widgets || []) {
+      const remappedScope =
+        resolvedCallerScope && w.scope && w.scope !== resolvedCallerScope
+          ? resolvedCallerScope
+          : w.scope || "";
+      const bareName = (w.packageName || w.package || "").replace(
+        /^@[^/]+\//,
+        "",
+      );
+      const scopedPackageId = remappedScope
+        ? `@${String(remappedScope).replace(/^@/, "")}/${bareName}`
+        : bareName;
+      // Version-pin guard: refuse to publish a dashboard whose widget
+      // dep has no concrete version. Otherwise the permissions block
+      // we ship would be computed against one version while installers
+      // resolve `*` to potentially-newer versions with a different
+      // tool surface.
+      if (!w.version || w.version === "*") {
+        unpinnedDeps.push(scopedPackageId);
+        continue;
+      }
+      // Find the installed copy by trying a few aliases — registry
+      // entries are usually `@scope/name`, but local conventions
+      // sometimes elide the @.
+      const match = installedWidgets.find((iw) => {
+        if (!iw) return false;
+        const candidates = new Set();
+        if (iw.packageId) candidates.add(iw.packageId);
+        if (iw.name) candidates.add(iw.name);
+        return (
+          candidates.has(scopedPackageId) ||
+          candidates.has(`${remappedScope}/${bareName}`) ||
+          candidates.has(bareName)
+        );
+      });
+      if (!match || !match.path) continue;
+      const pkgJsonPath = path$3.join(match.path, "package.json");
+      if (!fs.existsSync(pkgJsonPath)) continue;
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+        const perms = pkg?.dash?.permissions?.mcp;
+        if (perms && typeof perms === "object") {
+          widgetPermissions.push({
+            packageId: scopedPackageId,
+            version: w.version,
+            permissions: perms,
+          });
+        }
+      } catch (e) {
+        console.warn(
+          `[DashboardConfigController] Could not read permissions from ${pkgJsonPath}:`,
+          e.message,
+        );
+      }
+    }
+    if (unpinnedDeps.length > 0) {
+      return {
+        success: false,
+        error: `Cannot publish dashboard with unpinned widget versions: ${unpinnedDeps.join(", ")}. Reinstall these widgets from the registry to lock their versions before publishing.`,
+      };
+    }
+
     // 8. Generate registry manifest — pass callerScope so local-only
     //    scopes (e.g. `@ai-built/…`) get rewritten to the publisher's
     //    actual registry scope on the way out.
@@ -60817,6 +61028,7 @@ async function prepareDashboardForPublish$1(
       appOrigin: appId,
       visibility: options.visibility || "public",
       version: nextVersion,
+      widgetPermissions,
     });
 
     // 9. Show save dialog for the publish package
@@ -61381,7 +61593,7 @@ var notificationController_1 = notificationController$2;
  */
 
 const { app: app$2 } = require$$0$1;
-const fs$1 = require$$0$2;
+const fs$2 = require$$0$2;
 const path$2 = require$$1$1;
 const WebSocket = require$$3$4;
 const {
@@ -61397,8 +61609,8 @@ function _loadFlags() {
       "Dashboard",
       "settings.json",
     );
-    if (!fs$1.existsSync(settingsPath)) return null;
-    return JSON.parse(fs$1.readFileSync(settingsPath, "utf8"));
+    if (!fs$2.existsSync(settingsPath)) return null;
+    return JSON.parse(fs$2.readFileSync(settingsPath, "utf8"));
   } catch (_e) {
     return null;
   }
@@ -63022,7 +63234,7 @@ var dashboardRatingsController = {
  *   - Batch-publish from the dashboard publish dialog
  */
 
-const fs = require$$0$2;
+const fs$1 = require$$0$2;
 const path = require$$1$1;
 const AdmZip = require$$3$1;
 const { app } = require$$0$1;
@@ -63125,17 +63337,17 @@ function cleanupProvidersInWidgetPackage(widgetPath) {
   try {
     const widgetsDir =
       findWidgetsDir(widgetPath) || path.join(widgetPath, "widgets");
-    if (!fs.existsSync(widgetsDir)) return summary;
-    for (const file of fs.readdirSync(widgetsDir)) {
+    if (!fs$1.existsSync(widgetsDir)) return summary;
+    for (const file of fs$1.readdirSync(widgetsDir)) {
       if (!file.endsWith(".dash.js")) continue;
       const filePath = path.join(widgetsDir, file);
       try {
-        const original = fs.readFileSync(filePath, "utf8");
+        const original = fs$1.readFileSync(filePath, "utf8");
         summary.filesScanned++;
         const { source: deduped, dropped } =
           dedupProvidersInDashSource(original);
         if (dropped > 0 && deduped !== original) {
-          fs.writeFileSync(filePath, deduped, "utf8");
+          fs$1.writeFileSync(filePath, deduped, "utf8");
           summary.filesRewritten++;
           summary.totalDropped += dropped;
           console.log(
@@ -63167,8 +63379,8 @@ async function scanWidgetConfigs(widgetPath) {
   try {
     const widgetsDir =
       findWidgetsDir(widgetPath) || path.join(widgetPath, "widgets");
-    if (!fs.existsSync(widgetsDir)) return [];
-    const files = fs.readdirSync(widgetsDir);
+    if (!fs$1.existsSync(widgetsDir)) return [];
+    const files = fs$1.readdirSync(widgetsDir);
     const configs = [];
     for (const file of files) {
       if (!file.endsWith(".dash.js")) continue;
@@ -63275,7 +63487,7 @@ function serializeDashConfig(config) {
  */
 async function stageOverrides(srcDir, dstDir, overrides) {
   // Copy the whole package tree into dstDir.
-  fs.cpSync(srcDir, dstDir, {
+  fs$1.cpSync(srcDir, dstDir, {
     recursive: true,
     filter: (src) => {
       const base = path.basename(src);
@@ -63288,10 +63500,10 @@ async function stageOverrides(srcDir, dstDir, overrides) {
   if (!overrides || Object.keys(overrides).length === 0) return [];
 
   const widgetsDir = findWidgetsDir(dstDir) || path.join(dstDir, "widgets");
-  if (!fs.existsSync(widgetsDir)) return [];
+  if (!fs$1.existsSync(widgetsDir)) return [];
 
   const rewritten = [];
-  const files = fs.readdirSync(widgetsDir);
+  const files = fs$1.readdirSync(widgetsDir);
   for (const file of files) {
     if (!file.endsWith(".dash.js")) continue;
     const filePath = path.join(widgetsDir, file);
@@ -63327,7 +63539,7 @@ async function stageOverrides(srcDir, dstDir, overrides) {
     }
     if (!changed) continue;
 
-    fs.writeFileSync(filePath, serializeDashConfig(cfg));
+    fs$1.writeFileSync(filePath, serializeDashConfig(cfg));
     rewritten.push(file);
   }
   return rewritten;
@@ -63395,7 +63607,7 @@ function scanForPersonalPaths(packagePath) {
     if (findings.length >= MAX_FINDINGS) return;
     let entries;
     try {
-      entries = fs.readdirSync(absDir, { withFileTypes: true });
+      entries = fs$1.readdirSync(absDir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -63414,9 +63626,9 @@ function scanForPersonalPaths(packagePath) {
       if (!SCANNABLE_EXTS.has(ext)) continue;
       let content;
       try {
-        const stat = fs.statSync(abs);
+        const stat = fs$1.statSync(abs);
         if (stat.size > MAX_FILE_SIZE) continue;
-        content = fs.readFileSync(abs, "utf8");
+        content = fs$1.readFileSync(abs, "utf8");
       } catch {
         continue;
       }
@@ -63448,7 +63660,7 @@ function scanForPersonalPaths(packagePath) {
  * Recursively add a directory to a ZIP, skipping excluded dirs + dotfiles.
  */
 function addDirToZip(zip, absDir, relDir = "") {
-  const entries = fs.readdirSync(absDir, { withFileTypes: true });
+  const entries = fs$1.readdirSync(absDir, { withFileTypes: true });
   for (const entry of entries) {
     if (ZIP_EXCLUDE_DIRS.has(entry.name)) continue;
     if (entry.name.startsWith(".")) continue;
@@ -63458,7 +63670,7 @@ function addDirToZip(zip, absDir, relDir = "") {
       addDirToZip(zip, abs, rel);
     } else if (entry.isFile()) {
       try {
-        zip.addFile(rel, fs.readFileSync(abs));
+        zip.addFile(rel, fs$1.readFileSync(abs));
       } catch (err) {
         console.warn(`[widgetRegistry] skip ${rel}: ${err.message}`);
       }
@@ -63519,12 +63731,12 @@ async function prepareWidgetForPublish$1(appId, packageId, options = {}) {
     const pkgJsonPath = path.join(widget.path, "package.json");
     const dashJsonPath = path.join(widget.path, "dash.json");
     let pkgJson;
-    if (fs.existsSync(pkgJsonPath)) {
-      pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
-    } else if (fs.existsSync(dashJsonPath)) {
+    if (fs$1.existsSync(pkgJsonPath)) {
+      pkgJson = JSON.parse(fs$1.readFileSync(pkgJsonPath, "utf8"));
+    } else if (fs$1.existsSync(dashJsonPath)) {
       // Registry-installed widgets only have dash.json — synthesize
       // the fields the publish flow needs from it.
-      const dashJson = JSON.parse(fs.readFileSync(dashJsonPath, "utf8"));
+      const dashJson = JSON.parse(fs$1.readFileSync(dashJsonPath, "utf8"));
       pkgJson = {
         name: dashJson.name ? `@${callerScope}/${dashJson.name}` : packageId,
         version: dashJson.version || "1.0.0",
@@ -63558,8 +63770,8 @@ async function prepareWidgetForPublish$1(appId, packageId, options = {}) {
       if (merged) {
         // Re-read pkgJson so subsequent steps in this function see the
         // updated manifest (the version bump below uses pkgJson too).
-        if (fs.existsSync(pkgJsonPath)) {
-          pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+        if (fs$1.existsSync(pkgJsonPath)) {
+          pkgJson = JSON.parse(fs$1.readFileSync(pkgJsonPath, "utf8"));
         }
       }
     } catch (e) {
@@ -63593,12 +63805,12 @@ async function prepareWidgetForPublish$1(appId, packageId, options = {}) {
     if (newVersion !== previousVersion) {
       pkgJson.version = newVersion;
       // Persist to whichever metadata file exists
-      if (fs.existsSync(pkgJsonPath)) {
-        fs.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
-      } else if (fs.existsSync(dashJsonPath)) {
-        const dashJson = JSON.parse(fs.readFileSync(dashJsonPath, "utf8"));
+      if (fs$1.existsSync(pkgJsonPath)) {
+        fs$1.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+      } else if (fs$1.existsSync(dashJsonPath)) {
+        const dashJson = JSON.parse(fs$1.readFileSync(dashJsonPath, "utf8"));
         dashJson.version = newVersion;
-        fs.writeFileSync(
+        fs$1.writeFileSync(
           dashJsonPath,
           JSON.stringify(dashJson, null, 2) + "\n",
         );
@@ -63618,14 +63830,14 @@ async function prepareWidgetForPublish$1(appId, packageId, options = {}) {
       profile?.displayName ||
       profile?.username ||
       "";
-    if (authorOverride && fs.existsSync(dashJsonPath)) {
+    if (authorOverride && fs$1.existsSync(dashJsonPath)) {
       try {
-        const dashJson = JSON.parse(fs.readFileSync(dashJsonPath, "utf8"));
+        const dashJson = JSON.parse(fs$1.readFileSync(dashJsonPath, "utf8"));
         const current = (dashJson.author || "").trim();
         const isPlaceholder = !current || current === "AI Assistant";
         if (isPlaceholder && dashJson.author !== authorOverride) {
           dashJson.author = authorOverride;
-          fs.writeFileSync(
+          fs$1.writeFileSync(
             dashJsonPath,
             JSON.stringify(dashJson, null, 2) + "\n",
           );
@@ -63695,7 +63907,7 @@ async function prepareWidgetForPublish$1(appId, packageId, options = {}) {
       typeof options.defaultsOverride === "object" &&
       Object.keys(options.defaultsOverride).length > 0;
     const stagedDir = hasOverrides
-      ? fs.mkdtempSync(path.join(app.getPath("temp"), `dash-publish-stage-`))
+      ? fs$1.mkdtempSync(path.join(app.getPath("temp"), `dash-publish-stage-`))
       : null;
     let registryResult;
     try {
@@ -63738,7 +63950,7 @@ async function prepareWidgetForPublish$1(appId, packageId, options = {}) {
         if (newVersion !== previousVersion) {
           try {
             pkgJson.version = previousVersion;
-            fs.writeFileSync(
+            fs$1.writeFileSync(
               pkgJsonPath,
               JSON.stringify(pkgJson, null, 2) + "\n",
             );
@@ -63756,14 +63968,14 @@ async function prepareWidgetForPublish$1(appId, packageId, options = {}) {
 
       // Clean up the temp zip on success.
       try {
-        fs.unlinkSync(zipPath);
+        fs$1.unlinkSync(zipPath);
       } catch {
         /* ignore */
       }
     } finally {
       if (stagedDir) {
         try {
-          fs.rmSync(stagedDir, { recursive: true, force: true });
+          fs$1.rmSync(stagedDir, { recursive: true, force: true });
         } catch {
           /* best effort */
         }
@@ -63804,9 +64016,9 @@ async function inspectWidgetPackage$1(packageId) {
 
     let pkgJson = {};
     const pkgJsonPath = path.join(widget.path, "package.json");
-    if (fs.existsSync(pkgJsonPath)) {
+    if (fs$1.existsSync(pkgJsonPath)) {
       try {
-        pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+        pkgJson = JSON.parse(fs$1.readFileSync(pkgJsonPath, "utf8"));
       } catch {
         /* ignore */
       }