@kenjura/ursa 0.75.0 → 0.77.0

package/src/helper/portUtils.js

@@ -0,0 +1,132 @@
+import net from 'net';
+import readline from 'readline';
+
+/**
+ * Check if a specific port is available.
+ * @param {number} port
+ * @returns {Promise<boolean>}
+ */
+export function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port);
+  });
+}
+
+/**
+ * Find the closest available port to the preferred port.
+ * Searches both upward and downward from the preferred port, returning
+ * the closest available one.
+ * @param {number} preferred - The preferred port number
+ * @param {number} [maxDistance=100] - Maximum distance to search from preferred port
+ * @returns {Promise<number|null>} The closest available port, or null if none found
+ */
+export async function findClosestAvailablePort(preferred, maxDistance = 100) {
+  for (let offset = 1; offset <= maxDistance; offset++) {
+    const candidates = [];
+    if (preferred + offset <= 65535) candidates.push(preferred + offset);
+    if (preferred - offset >= 1024) candidates.push(preferred - offset);
+
+    // Check both candidates (up and down) in parallel
+    const results = await Promise.all(
+      candidates.map(async (port) => ({
+        port,
+        available: await isPortAvailable(port),
+      }))
+    );
+
+    // Return the first available candidate (lower offset = closer)
+    // Since we push +offset first, it's preferred over -offset at the same distance
+    const found = results.find((r) => r.available);
+    if (found) return found.port;
+  }
+  return null;
+}
+
+/**
+ * Prompt the user via stdin to confirm using an alternative port.
+ * @param {number} originalPort
+ * @param {number} alternativePort
+ * @returns {Promise<boolean>} True if user accepts the alternative port
+ */
+function promptUser(originalPort, alternativePort) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question(
+      `⚠️  Port ${originalPort} is already in use. Use port ${alternativePort} instead? (Y/n) `,
+      (answer) => {
+        rl.close();
+        const normalized = answer.trim().toLowerCase();
+        resolve(normalized === '' || normalized === 'y' || normalized === 'yes');
+      }
+    );
+  });
+}
+
+/**
+ * Resolve an available port for the server. If the requested port is occupied,
+ * find the closest available port and prompt the user to accept it.
+ *
+ * Also checks wsPort (port + 1) availability since the WebSocket server needs it.
+ *
+ * @param {number} port - The desired port
+ * @returns {Promise<number>} The port to use (original or user-accepted alternative)
+ * @throws {Error} If no available port is found or user declines the alternative
+ */
+export async function resolvePort(port) {
+  const httpAvailable = await isPortAvailable(port);
+  const wsAvailable = await isPortAvailable(port + 1);
+
+  if (httpAvailable && wsAvailable) {
+    return port;
+  }
+
+  const reason = !httpAvailable
+    ? `Port ${port} is already in use`
+    : `WebSocket port ${port + 1} is already in use`;
+
+  console.log(`\n⚠️  ${reason}.`);
+  console.log(`🔍 Searching for an available port...`);
+
+  const alternative = await findClosestAvailablePort(port);
+
+  if (!alternative) {
+    throw new Error(
+      `Could not find an available port near ${port}. Please free up a port and try again.`
+    );
+  }
+
+  // Also verify the ws port for the alternative
+  const altWsAvailable = await isPortAvailable(alternative + 1);
+  if (!altWsAvailable) {
+    // Try again, skipping this one
+    const secondTry = await findClosestAvailablePort(alternative + 1);
+    if (!secondTry) {
+      throw new Error(
+        `Could not find an available port pair (HTTP + WebSocket) near ${port}.`
+      );
+    }
+    const accepted = await promptUser(port, secondTry);
+    if (!accepted) {
+      console.log('👋 Server startup cancelled.');
+      process.exit(0);
+    }
+    return secondTry;
+  }
+
+  const accepted = await promptUser(port, alternative);
+  if (!accepted) {
+    console.log('👋 Server startup cancelled.');
+    process.exit(0);
+  }
+
+  return alternative;
+}

package/src/jobs/generate.js

@@ -26,9 +26,12 @@ import {
 import { getAndIncrementBuildId } from "../helper/ursaConfig.js";
 import { extractSections } from "../helper/sectionExtractor.js";
 import { renderFile, renderFileAsync, terminateParserPool } from "../helper/fileRenderer.js";
-import { findStyleCss } from "../helper/findStyleCss.js";
-import { findScriptJs } from "../helper/findScriptJs.js";
+import { findStyleCss, findAllStyleCss } from "../helper/findStyleCss.js";
+import { findScriptJs, findAllScriptJs } from "../helper/findScriptJs.js";
+import { bundleMetaTemplateAssets, bundleDocumentCss, bundleDocumentJs, clearMetaBundleCache, generateSeparateCssTags, generateSeparateJsTags } from "../helper/assetBundler.js";
 import { buildFullTextIndex, buildIncrementalIndex, loadIndexCache, saveIndexCache } from "../helper/fullTextIndex.js";
+import { dependencyTracker } from "../helper/dependencyTracker.js";
+import { CacheBustHashMap } from "../helper/build/cacheBust.js";
 import { copy as copyDir, emptyDir, outputFile } from "fs-extra";
 import { basename, dirname, extname, join, parse, resolve } from "path";
 import { URL } from "url";
@@ -71,6 +74,7 @@ import {
   getFooter,
   generateAutoIndices,
   generateAutoIndexHtmlFromSource,
+  copyMetaAssets,
 } from "../helper/build/index.js";
 import { getProfiler } from "../helper/build/profiler.js";
 
@@ -83,10 +87,15 @@ const cssPathCache = new Map();
 // Cache for script path lookups to avoid repeated filesystem walks
 const scriptPathCache = new Map();
 
+// Cache for document-level CSS/JS bundle paths to avoid re-bundling identical sets
+const docBundleCache = new Map();
+
 // Wrapper for clearWatchCache that passes cssPathCache and scriptPathCache
 export function clearWatchCache() {
   clearWatchCacheBase(cssPathCache);
   scriptPathCache.clear();
+  docBundleCache.clear();
+  clearMetaBundleCache();
 }
 
 const progress = new ProgressReporter();
@@ -116,8 +125,12 @@ export async function generate({
 
   // Generate cache-busting timestamp for this build
   const cacheBustTimestamp = generateCacheBustTimestamp();
+  const cacheBustHashes = new CacheBustHashMap();
   progress.logTimed(`Cache-bust timestamp: ${cacheBustTimestamp}`);
 
+  // Initialize dependency tracker for this build
+  dependencyTracker.init(source);
+
   // Clear output directory when --clean is specified
   if (_clean) {
     progress.startTimer('Clean');
@@ -283,7 +296,27 @@ export async function generate({
   // create public folder
   const pub = join(output, "public");
   await mkdir(pub, { recursive: true });
-  await copyDir(meta, pub);
+  
+  // Copy meta assets with new template folder structure
+  const { copiedFiles, orphanedFiles } = await copyMetaAssets(meta, pub);
+  
+  // Warn about orphaned files in meta that aren't part of any template
+  if (orphanedFiles.length > 0) {
+    console.warn(`\n⚠️  Warning: Found ${orphanedFiles.length} orphaned file(s) in meta directory:`);
+    console.warn(`   These files are not in meta/templates/ or meta/shared/ and won't be included:`);
+    for (const file of orphanedFiles.slice(0, 10)) {
+      console.warn(`   - ${file}`);
+    }
+    if (orphanedFiles.length > 10) {
+      console.warn(`   ... and ${orphanedFiles.length - 10} more`);
+    }
+    console.warn(`   Move them to meta/templates/{templateName}/ or meta/shared/ to include them.\n`);
+  }
+
+  // Bundle meta template assets (CSS + JS) into single files per template
+  // This must happen after copying meta to public but before cache-busting
+  templates = await bundleMetaTemplateAssets(templates, meta, pub, { minify: true, sourcemap: false });
+  progress.logTimed(`Meta template assets bundled`);
 
   // Process all CSS files in the entire output directory tree for cache-busting
   const allOutputFiles = await recurse(output, [() => false]);
@@ -313,6 +346,8 @@ export async function generate({
   const searchIndex = [];
   // Full-text index: collect documents for word-to-document mapping
   const fullTextDocs = [];
+  // Recent activity: collect {title, url, mtime} for all articles, keep top 10 by mtime
+  const recentActivity = [];
   // Track paths of documents that were regenerated (for incremental index updates)
   const changedPaths = new Set();
   // Directory index cache: only stores minimal data needed for directory indices
@@ -481,6 +516,18 @@ export async function generate({
         title: title,
         content: rawBody
       });
+
+      // Collect mtime for recent activity tracking
+      try {
+        const fileStat = await stat(file);
+        recentActivity.push({
+          title: title,
+          url: searchUrl,
+          mtime: fileStat.mtimeMs
+        });
+      } catch (e) {
+        // ignore stat errors
+      }
       
       // Check if a corresponding .html file already exists in source directory
       const outputHtmlRelative = relativePath.startsWith('/') ? relativePath.slice(1) : relativePath;
@@ -582,52 +629,73 @@ export async function generate({
         }
       }
 
-      // Find nearest style.css or _style.css up the tree and copy to output
-      // Use cache to avoid repeated filesystem walks for same directory
+      // Find all style.css files up the tree and bundle them into a single CSS file per folder path
+      // (Generate mode: one CSS bundle per unique folder, minimizing requests per page load)
       let styleLink = "";
       try {
-        // For root-level files, dir may be "/" which would resolve to filesystem root
-        // Use source directory directly in that case
         const dirKey = (dir === "/" || dir === "") ? _source : resolve(_source, dir);
-        let cssPath = cssPathCache.get(dirKey);
-        if (cssPath === undefined) {
-          cssPath = await findStyleCss(dirKey);
-          cssPathCache.set(dirKey, cssPath); // Cache null results too
-        }
-        if (cssPath) {
-          // Calculate output path for the CSS file (mirrors source structure)
-          const cssOutputPath = cssPath.replace(source, output);
-          const cssUrlPath = '/' + cssPath.replace(source, '');
-          
-          // Copy CSS file if not already copied
-          if (!copiedCssFiles.has(cssPath)) {
-            const cssContent = await readFile(cssPath, 'utf8');
-            await outputFile(cssOutputPath, cssContent);
-            copiedCssFiles.add(cssPath);
+        const folderRelative = (dir === "/" || dir === "") ? "" : dir;
+
+        // Check bundle cache first (dirs with same CSS ancestry share the same bundle)
+        let cachedBundleUrl = docBundleCache.get(`css:${dirKey}`);
+        if (cachedBundleUrl !== undefined) {
+          if (cachedBundleUrl) {
+            styleLink = `<link rel="stylesheet" href="${cachedBundleUrl}" />`;
+          }
+        } else {
+          let cssPaths = cssPathCache.get(dirKey);
+          if (cssPaths === undefined) {
+            cssPaths = await findAllStyleCss(dirKey, _source);
+            cssPathCache.set(dirKey, cssPaths);
+          }
+          if (cssPaths.length > 0) {
+            // Copy all source CSS files to output (still needed for serve mode fallback)
+            for (const cssPath of cssPaths) {
+              if (!copiedCssFiles.has(cssPath)) {
+                const cssOutputPath = cssPath.replace(source, output);
+                const cssContent = await readFile(cssPath, 'utf8');
+                await outputFile(cssOutputPath, cssContent);
+                copiedCssFiles.add(cssPath);
+              }
+            }
+            // Bundle into a single file
+            const bundleUrl = await bundleDocumentCss(cssPaths, output, source, folderRelative, { minify: true });
+            docBundleCache.set(`css:${dirKey}`, bundleUrl);
+            styleLink = `<link rel="stylesheet" href="${bundleUrl}" />`;
+          } else {
+            docBundleCache.set(`css:${dirKey}`, null);
           }
-          
-          // Generate link tag
-          styleLink = `<link rel="stylesheet" href="${cssUrlPath}" />`;
         }
       } catch (e) {
         // ignore
         console.error(e);
       }
 
-      // Find nearest script.js or _script.js up the tree and inline its contents
-      // Use cache to avoid repeated filesystem walks for same directory
+      // Find all script.js files from docroot to current dir and bundle them
+      // (Generate mode: one JS bundle per unique folder, external not inlined)
       let customScript = "";
       try {
         const dirKey = (dir === "/" || dir === "") ? _source : resolve(_source, dir);
-        let scriptPath = scriptPathCache.get(dirKey);
-        if (scriptPath === undefined) {
-          scriptPath = await findScriptJs(dirKey);
-          scriptPathCache.set(dirKey, scriptPath); // Cache null results too
-        }
-        if (scriptPath) {
-          const scriptContent = await readFile(scriptPath, 'utf8');
-          // Inline the script content in a script tag
-          customScript = `<script>\n${scriptContent}\n</script>`;
+        const folderRelative = (dir === "/" || dir === "") ? "" : dir;
+
+        let cachedBundleUrl = docBundleCache.get(`js:${dirKey}`);
+        if (cachedBundleUrl !== undefined) {
+          if (cachedBundleUrl) {
+            customScript = `<script src="${cachedBundleUrl}"></script>`;
+          }
+        } else {
+          let scriptPaths = scriptPathCache.get(dirKey);
+          if (scriptPaths === undefined) {
+            scriptPaths = await findAllScriptJs(dirKey, _source);
+            scriptPathCache.set(dirKey, scriptPaths);
+          }
+          if (scriptPaths.length > 0) {
+            const bundleUrl = await bundleDocumentJs(scriptPaths, output, source, folderRelative, { minify: true });
+            docBundleCache.set(`js:${dirKey}`, bundleUrl);
+            customScript = `<script src="${bundleUrl}"></script>`;
+          } else {
+            docBundleCache.set(`js:${dirKey}`, null);
+          }
         }
       } catch (e) {
         // ignore
@@ -635,11 +703,23 @@ export async function generate({
       }
 
       const requestedTemplateName = fileMeta && fileMeta.template;
-      const template =
-        templates[requestedTemplateName] || templates[DEFAULT_TEMPLATE_NAME];
+      const templateName = requestedTemplateName || DEFAULT_TEMPLATE_NAME;
+      const template = templates[templateName];
 
       if (!template) {
-        throw new Error(`Template not found. Requested: "${requestedTemplateName || DEFAULT_TEMPLATE_NAME}". Available templates: ${Object.keys(templates).join(', ') || 'none'}`);
+        throw new Error(`Template not found. Requested: "${templateName}". Available templates: ${Object.keys(templates).join(', ') || 'none'}`);
+      }
+
+      // Register this document's dependencies for invalidation tracking
+      {
+        const dirKey = (dir === "/" || dir === "") ? _source : resolve(_source, dir);
+        const cssDeps = cssPathCache.get(dirKey) || [];
+        const jsDeps = scriptPathCache.get(dirKey) || [];
+        dependencyTracker.registerDocument(file, {
+          templateName,
+          cssPaths: cssDeps,
+          scriptPaths: jsDeps,
+        });
       }
 
       // Check if this file has a custom menu
@@ -807,6 +887,17 @@ export async function generate({
     profiler.endPhase('Write search index');
   }
 
+  // Phase: Write recent activity data
+  profiler.startPhase('Write recent activity');
+  progress.startTimer('Recent activity');
+  // Sort by mtime descending, keep top 10
+  recentActivity.sort((a, b) => b.mtime - a.mtime);
+  const top10 = recentActivity.slice(0, 10);
+  const recentActivityPath = join(output, 'public', 'recent-activity.json');
+  await outputFile(recentActivityPath, JSON.stringify(top10));
+  progress.done('Recent activity', `${top10.length} entries [${progress.stopTimer('Recent activity')}]`);
+  profiler.endPhase('Write recent activity');
+
   // Phase: Write menu data
   profiler.startPhase('Write menu data');
   progress.startTimer('Menu data');
@@ -1000,11 +1091,15 @@ export async function generate({
   watchModeCache.meta = meta;
   watchModeCache.output = output;
   watchModeCache.hashCache = hashCache;
+  watchModeCache.cacheBustTimestamp = cacheBustTimestamp;
+  watchModeCache.cacheBustHashes = cacheBustHashes;
+  watchModeCache.allArticlePaths = [...allSourceFilenamesThatAreArticles];
   watchModeCache.imageMap = imageMap;
   watchModeCache.customMenus = customMenus;
   watchModeCache.lastFullBuild = Date.now();
   watchModeCache.isInitialized = true;
-  progress.log(`Watch cache initialized for fast single-file regeneration`);
+  const depStats = dependencyTracker.getStats();
+  progress.log(`Watch cache initialized (${depStats.totalDocuments} documents, ${depStats.uniqueFiles} dependencies tracked)`);
 
   // Write error report if there were any errors
   if (errors.length > 0) {
@@ -1059,6 +1154,104 @@ export async function generate({
   };
 }
 
+/**
+ * Regenerate multiple documents affected by a dependency change (e.g., style.css, script.js, template).
+ * Uses the watchModeCache and dependency tracker to efficiently re-render affected documents
+ * with updated cache-bust timestamps.
+ *
+ * @param {string[]} documentPaths - Absolute paths to documents to regenerate
+ * @param {Object} options
+ * @param {string} options._source - Source directory
+ * @param {string} options._meta - Meta directory
+ * @param {string} options._output - Output directory
+ * @param {string} [options.reason] - Reason for regeneration (for logging)
+ * @param {string[]} [options.priorityPaths] - Document paths to regenerate first (e.g. client-viewed docs)
+ * @param {function} [options.onPriorityComplete] - Callback after priority paths are done (receives { regenerated, failed })
+ * @returns {Promise<{success: boolean, message: string, regenerated: number, failed: number}>}
+ */
+export async function regenerateAffectedDocuments(documentPaths, {
+  _source,
+  _meta,
+  _output,
+  reason = "dependency change",
+  priorityPaths = [],
+  onPriorityComplete = null,
+} = {}) {
+  const startTime = Date.now();
+
+  if (!watchModeCache.isInitialized) {
+    return { success: false, message: "Cache not initialized - need full build first", regenerated: 0, failed: 0 };
+  }
+
+  if (documentPaths.length === 0) {
+    return { success: true, message: "No documents to regenerate", regenerated: 0, failed: 0 };
+  }
+
+  // Generate a fresh cache-bust timestamp for this invalidation pass
+  const newTimestamp = generateCacheBustTimestamp();
+  watchModeCache.cacheBustTimestamp = newTimestamp;
+
+  let regenerated = 0;
+  let failed = 0;
+
+  // Separate priority paths from the rest
+  const prioritySet = new Set(priorityPaths.map(p => resolve(p)));
+  const priorityDocs = documentPaths.filter(p => prioritySet.has(resolve(p)));
+  const remainingDocs = documentPaths.filter(p => !prioritySet.has(resolve(p)));
+
+  if (priorityDocs.length > 0) {
+    console.log(`🔄 Regenerating ${priorityDocs.length} priority documents first, then ${remainingDocs.length} remaining (${reason})`);
+  } else {
+    console.log(`🔄 Regenerating ${documentPaths.length} documents (${reason})`);
+  }
+
+  // Process priority documents first
+  for (const docPath of priorityDocs) {
+    try {
+      const result = await regenerateSingleFile(docPath, { _source, _meta, _output });
+      if (result.success) {
+        regenerated++;
+      } else {
+        console.warn(`  ⚠️  ${docPath}: ${result.message}`);
+        failed++;
+      }
+    } catch (e) {
+      console.error(`  ❌ ${docPath}: ${e.message}`);
+      failed++;
+    }
+  }
+
+  // Notify caller that priority docs are done (so server can reload those clients immediately)
+  if (priorityDocs.length > 0 && onPriorityComplete) {
+    try {
+      onPriorityComplete({ regenerated, failed, priorityDocs });
+    } catch (e) {
+      console.error(`  ⚠️ onPriorityComplete callback error: ${e.message}`);
+    }
+  }
+
+  // Process remaining documents
+  for (const docPath of remainingDocs) {
+    try {
+      const result = await regenerateSingleFile(docPath, { _source, _meta, _output });
+      if (result.success) {
+        regenerated++;
+      } else {
+        console.warn(`  ⚠️  ${docPath}: ${result.message}`);
+        failed++;
+      }
+    } catch (e) {
+      console.error(`  ❌ ${docPath}: ${e.message}`);
+      failed++;
+    }
+  }
+
+  const elapsed = Date.now() - startTime;
+  const msg = `Regenerated ${regenerated}/${documentPaths.length} documents in ${elapsed}ms (${reason})${failed > 0 ? `, ${failed} failed` : ""}`;
+  console.log(`✅ ${msg}`);
+  return { success: failed === 0, message: msg, regenerated, failed };
+}
+
 /**
  * Regenerate a single file without scanning the entire source directory.
  * This is much faster for watch mode - only regenerate what changed.
@@ -1178,23 +1371,20 @@ export async function regenerateSingleFile(changedFile, {
       }
     }
 
-    // Find CSS and copy to output
+    // Find all CSS files up the tree and create separate link tags
+    // (regenerateSingleFile is used in serve mode, so separate tags per level for invalidation)
     let styleLink = "";
     try {
-      // For root-level files, dir may be "/" which would resolve to filesystem root
       const dirKey = (dir === "/" || dir === "") ? _source : resolve(_source, dir);
-      const cssPath = await findStyleCss(dirKey);
-      if (cssPath) {
-        // Calculate output path for the CSS file
-        const cssOutputPath = cssPath.replace(source, output);
-        const cssUrlPath = '/' + cssPath.replace(source, '');
-        
-        // Copy CSS file (always copy in single-file mode to ensure it's up to date)
-        const cssContent = await readFile(cssPath, 'utf8');
-        await outputFile(cssOutputPath, cssContent);
-        
-        // Generate link tag
-        styleLink = `<link rel="stylesheet" href="${cssUrlPath}" />`;
+      const cssPaths = await findAllStyleCss(dirKey, _source);
+      if (cssPaths.length > 0) {
+        // Copy all CSS files to output (always copy in single-file mode to ensure up to date)
+        for (const cssPath of cssPaths) {
+          const cssOutputPath = cssPath.replace(source, output);
+          const cssContent = await readFile(cssPath, 'utf8');
+          await outputFile(cssOutputPath, cssContent);
+        }
+        styleLink = generateSeparateCssTags(cssPaths, source);
       }
     } catch (e) {
       // ignore
@@ -1209,14 +1399,20 @@ export async function regenerateSingleFile(changedFile, {
       return { success: false, message: `Template not found: ${requestedTemplateName || DEFAULT_TEMPLATE_NAME}` };
     }
     
-    // Find nearest script.js or _script.js and inline its contents
+    // Find all script.js files from docroot to current dir and serve as separate external tags
+    // (Serve mode: separate tags per level for individual invalidation)
     let customScript = "";
     try {
       const dirKey = (dir === "/" || dir === "") ? _source : resolve(_source, dir);
-      const scriptPath = await findScriptJs(dirKey);
-      if (scriptPath) {
-        const scriptContent = await readFile(scriptPath, 'utf8');
-        customScript = `<script>\n${scriptContent}\n</script>`;
+      const scriptPaths = await findAllScriptJs(dirKey, _source);
+      if (scriptPaths.length > 0) {
+        // Copy all script files to output so they can be served
+        for (const scriptPath of scriptPaths) {
+          const scriptOutputPath = scriptPath.replace(source, output);
+          const scriptContent = await readFile(scriptPath, 'utf8');
+          await outputFile(scriptOutputPath, scriptContent);
+        }
+        customScript = generateSeparateJsTags(scriptPaths, source);
       }
     } catch (e) {
       // ignore
@@ -1296,6 +1492,27 @@ export async function regenerateSingleFile(changedFile, {
     // Update hash cache
     updateHash(changedFile, rawBody, hashCache);
     
+    // Update recent-activity.json with this file's new mtime
+    try {
+      const fileStat = await stat(changedFile);
+      const recentActivityPath = join(output, 'public', 'recent-activity.json');
+      let recentActivity = [];
+      try {
+        const existing = await readFile(recentActivityPath, 'utf8');
+        recentActivity = JSON.parse(existing);
+      } catch (e) { /* no existing file, start fresh */ }
+      // Remove old entry for this URL if present
+      recentActivity = recentActivity.filter(r => r.url !== url);
+      // Add updated entry
+      recentActivity.push({ title, url, mtime: fileStat.mtimeMs });
+      // Sort by mtime descending, keep top 10
+      recentActivity.sort((a, b) => b.mtime - a.mtime);
+      recentActivity = recentActivity.slice(0, 10);
+      await outputFile(recentActivityPath, JSON.stringify(recentActivity));
+    } catch (e) {
+      // ignore recent activity update errors
+    }
+    
     const elapsed = Date.now() - startTime;
     const shortFile = changedFile.replace(source, '');
     return { success: true, message: `Regenerated ${shortFile} in ${elapsed}ms` };