@kenjura/ursa 0.53.0 → 0.55.0

package/src/jobs/generate.js

@@ -1,108 +1,5 @@
 import { recurse } from "../helper/recursive-readdir.js";
-
 import { copyFile, mkdir, readdir, readFile, stat } from "fs/promises";
-
-// Concurrency limiter for batch processing to avoid memory exhaustion
-const BATCH_SIZE = parseInt(process.env.URSA_BATCH_SIZE || '50', 10);
-
-/**
- * Cache for watch mode - stores expensive data that doesn't change often
- * This allows single-file regeneration to skip re-building menu, templates, etc.
- */
-const watchModeCache = {
-  templates: null,
-  menu: null,
-  footer: null,
-  validPaths: null,
-  source: null,
-  meta: null,
-  output: null,
-  hashCache: null,
-  lastFullBuild: 0,
-  isInitialized: false,
-};
-
-/**
- * Clear the watch mode cache (call when templates/meta/config change)
- */
-export function clearWatchCache() {
-  watchModeCache.templates = null;
-  watchModeCache.menu = null;
-  watchModeCache.footer = null;
-  watchModeCache.validPaths = null;
-  watchModeCache.hashCache = null;
-  watchModeCache.isInitialized = false;
-  cssPathCache.clear(); // Also clear CSS path cache
-  console.log('Watch cache cleared');
-}
-
-/**
- * Progress reporter that updates lines in place (like pnpm)
- */
-class ProgressReporter {
-  constructor() {
-    this.lines = {};
-    this.isTTY = process.stdout.isTTY;
-  }
-  
-  // Update a named status line in place
-  status(name, message) {
-    if (this.isTTY) {
-      // Save cursor, move to line, clear it, write, restore cursor
-      const line = `${name}: ${message}`;
-      this.lines[name] = line;
-      // Clear line and write
-      process.stdout.write(`\r\x1b[K${line}`);
-    }
-  }
-  
-  // Complete a status line (print final state and newline)
-  done(name, message) {
-    if (this.isTTY) {
-      process.stdout.write(`\r\x1b[K${name}: ${message}\n`);
-    } else {
-      console.log(`${name}: ${message}`);
-    }
-    delete this.lines[name];
-  }
-  
-  // Regular log that doesn't get overwritten
-  log(message) {
-    if (this.isTTY) {
-      // Clear current line first, print message, then newline
-      process.stdout.write(`\r\x1b[K${message}\n`);
-    } else {
-      console.log(message);
-    }
-  }
-  
-  // Clear all status lines
-  clear() {
-    if (this.isTTY) {
-      process.stdout.write(`\r\x1b[K`);
-    }
-  }
-}
-
-const progress = new ProgressReporter();
-
-/**
- * Process items in batches to limit memory usage
- * @param {Array} items - Items to process
- * @param {Function} processor - Async function to process each item
- * @param {number} batchSize - Max concurrent operations
- */
-async function processBatched(items, processor, batchSize = BATCH_SIZE) {
-  const results = [];
-  for (let i = 0; i < items.length; i += batchSize) {
-    const batch = items.slice(i, i + batchSize);
-    const batchResults = await Promise.all(batch.map(processor));
-    results.push(...batchResults);
-    // Allow GC to run between batches
-    if (global.gc) global.gc();
-  }
-  return results;
-}
 import { getAutomenu } from "../helper/automenu.js";
 import { filterAsync } from "../helper/filterAsync.js";
 import { isDirectory } from "../helper/isDirectory.js";
@@ -124,38 +21,6 @@ import {
 } from "../helper/linkValidator.js";
 import { getAndIncrementBuildId } from "../helper/ursaConfig.js";
 import { extractSections } from "../helper/sectionExtractor.js";
-
-// Helper function to build search index from processed files
-function buildSearchIndex(jsonCache, source, output) {
-  const searchIndex = [];
-  
-  for (const [filePath, jsonObject] of jsonCache.entries()) {
-    // Generate URL path relative to output
-    const relativePath = filePath.replace(source, '').replace(/\.(md|txt|yml)$/, '.html');
-    const url = relativePath.startsWith('/') ? relativePath : '/' + relativePath;
-    
-    // Extract text content from body (strip HTML tags for search)
-    const textContent = jsonObject.bodyHtml.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
-    const excerpt = textContent.substring(0, 200); // First 200 chars for preview
-    
-    searchIndex.push({
-      title: toTitleCase(jsonObject.name),
-      path: relativePath,
-      url: url,
-      content: excerpt
-    });
-  }
-  
-  return searchIndex;
-}
-
-// Helper function to convert filename to title case
-function toTitleCase(filename) {
-  return filename
-    .split(/[-_\s]+/) // Split on hyphens, underscores, and spaces
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-    .join(' ');
-}
 import { renderFile } from "../helper/fileRenderer.js";
 import { findStyleCss } from "../helper/findStyleCss.js";
 import { copy as copyDir, emptyDir, outputFile } from "fs-extra";
@@ -164,78 +29,45 @@ import { URL } from "url";
 import o2x from "object-to-xml";
 import { existsSync } from "fs";
 import { fileExists } from "../helper/fileExists.js";
-
 import { createWhitelistFilter } from "../helper/whitelistFilter.js";
 
-const DEFAULT_TEMPLATE_NAME =
-  process.env.DEFAULT_TEMPLATE_NAME ?? "default-template";
+// Import build helpers from organized modules
+import {
+  generateCacheBustTimestamp,
+  addTimestampToCssUrls,
+  addTimestampToHtmlStaticRefs,
+  processBatched,
+  ProgressReporter,
+  watchModeCache,
+  clearWatchCache as clearWatchCacheBase,
+  toTitleCase,
+  parseExcludeOption,
+  createExcludeFilter,
+  addTrailingSlash,
+  getTemplates,
+  getMenu,
+  findAllCustomMenus,
+  getCustomMenuForFile,
+  getTransformedMetadata,
+  getFooter,
+  generateAutoIndices,
+} from "../helper/build/index.js";
+
+// Concurrency limiter for batch processing to avoid memory exhaustion
+const BATCH_SIZE = parseInt(process.env.URSA_BATCH_SIZE || '50', 10);
 
 // Cache for CSS path lookups to avoid repeated filesystem walks
 const cssPathCache = new Map();
 
-/**
- * Parse exclude option - can be comma-separated paths or a file path
- * @param {string} excludeOption - The exclude option value
- * @param {string} source - Source directory path
- * @returns {Promise<Set<string>>} Set of excluded folder paths (normalized)
- */
-async function parseExcludeOption(excludeOption, source) {
-  const excludedPaths = new Set();
-  
-  if (!excludeOption) return excludedPaths;
-  
-  // Check if it's a file path (exists as a file)
-  const isFile = existsSync(excludeOption) && (await stat(excludeOption)).isFile();
-  
-  let patterns;
-  if (isFile) {
-    // Read patterns from file (one per line)
-    const content = await readFile(excludeOption, 'utf8');
-    patterns = content.split('\n')
-      .map(line => line.trim())
-      .filter(line => line && !line.startsWith('#')); // Skip empty lines and comments
-  } else {
-    // Treat as comma-separated list
-    patterns = excludeOption.split(',').map(p => p.trim()).filter(Boolean);
-  }
-  
-  // Normalize patterns to absolute paths
-  for (const pattern of patterns) {
-    // Remove leading/trailing slashes and normalize
-    const normalized = pattern.replace(/^\/+|\/+$/g, '');
-    // Store as relative path for easier matching
-    excludedPaths.add(normalized);
-  }
-  
-  return excludedPaths;
+// Wrapper for clearWatchCache that passes cssPathCache
+export function clearWatchCache() {
+  clearWatchCacheBase(cssPathCache);
 }
 
-/**
- * Create a filter function that excludes files in specified folders
- * @param {Set<string>} excludedPaths - Set of excluded folder paths
- * @param {string} source - Source directory path
- * @returns {Function} Filter function
- */
-function createExcludeFilter(excludedPaths, source) {
-  if (excludedPaths.size === 0) {
-    return () => true; // No exclusions, allow all
-  }
-  
-  return (filePath) => {
-    // Get path relative to source
-    const relativePath = filePath.replace(source, '').replace(/^\/+/, '');
-    
-    // Check if file is in any excluded folder
-    for (const excluded of excludedPaths) {
-      if (relativePath === excluded || 
-          relativePath.startsWith(excluded + '/') ||
-          relativePath.startsWith(excluded + '\\')) {
-        return false; // Exclude this file
-      }
-    }
-    return true; // Include this file
-  };
-}
+const progress = new ProgressReporter();
+
+const DEFAULT_TEMPLATE_NAME =
+  process.env.DEFAULT_TEMPLATE_NAME ?? "default-template";
 
 export async function generate({
   _source = join(process.cwd(), "."),
@@ -252,6 +84,10 @@ export async function generate({
   const output = resolve(_output) + "/";
   console.log({ source, meta, output });
 
+  // Generate cache-busting timestamp for this build
+  const cacheBustTimestamp = generateCacheBustTimestamp();
+  progress.log(`Cache-bust timestamp: ${cacheBustTimestamp}`);
+
   // Clear output directory when --clean is specified
   if (_clean) {
     progress.log(`Clean build: clearing output directory ${output}`);
@@ -327,6 +163,10 @@ export async function generate({
   const menu = menuResult.html;
   const menuData = menuResult.menuData;
 
+  // Find all custom menus in the source tree
+  const customMenus = findAllCustomMenus(allSourceFilenames, source);
+  progress.log(`Found ${customMenus.size} custom menu(s)`);
+
   // Get and increment build ID from .ursa.json
   const buildId = getAndIncrementBuildId(resolve(_source));
   progress.log(`Build #${buildId}`);
@@ -343,11 +183,30 @@ export async function generate({
     progress.log(`Clean build: ignoring cached hashes`);
   }
 
+
   // create public folder
   const pub = join(output, "public");
   await mkdir(pub, { recursive: true });
   await copyDir(meta, pub);
 
+  // Process all CSS files in the entire output directory tree for cache-busting
+  const allOutputFiles = await recurse(output, [() => false]);
+  for (const cssFile of allOutputFiles.filter(f => f.endsWith('.css'))) {
+    const cssContent = await readFile(cssFile, 'utf8');
+    const processedCss = addTimestampToCssUrls(cssContent, cacheBustTimestamp);
+    await outputFile(cssFile, processedCss);
+  }
+
+  // Process JS files in output for cache-busting fetch URLs
+  for (const jsFile of allOutputFiles.filter(f => f.endsWith('.js'))) {
+    let jsContent = await readFile(jsFile, 'utf8');
+    jsContent = jsContent.replace(
+      /fetch\(['"]([^'"\)]+\.(json))['"](?!\s*\+)/g,
+      `fetch('$1?v=${cacheBustTimestamp}'`
+    );
+    await outputFile(jsFile, jsContent);
+  }
+
   // Track errors for error report
   const errors = [];
 
@@ -481,6 +340,9 @@ export async function generate({
         throw new Error(`Template not found. Requested: "${requestedTemplateName || DEFAULT_TEMPLATE_NAME}". Available templates: ${Object.keys(templates).join(', ') || 'none'}`);
       }
 
+      // Check if this file has a custom menu
+      const customMenuInfo = getCustomMenuForFile(file, source, customMenus);
+
       // Build final HTML with all replacements in a single regex pass
       // This avoids creating 8 intermediate strings
       const replacements = {
@@ -497,9 +359,20 @@ export async function generate({
       const pattern = /\$\{(title|menu|meta|transformedMetadata|body|styleLink|searchIndex|footer)\}/g;
       let finalHtml = template.replace(pattern, (match) => replacements[match] ?? match);
 
+      // If this page has a custom menu, add data attribute to body
+      if (customMenuInfo) {
+        finalHtml = finalHtml.replace(
+          /<body([^>]*)>/,
+          `<body$1 data-custom-menu="${customMenuInfo.menuJsonPath}">`
+        );
+      }
+
       // Resolve links and mark broken internal links as inactive
       finalHtml = markInactiveLinks(finalHtml, validPaths, docUrlPath, false);
 
+      // Add cache-busting timestamps to static file references
+      finalHtml = addTimestampToHtmlStaticRefs(finalHtml, cacheBustTimestamp);
+
       await outputFile(outputFilename, finalHtml);
       
       // Clear finalHtml reference to allow GC
@@ -558,6 +431,14 @@ export async function generate({
   progress.log(`Writing menu data (${(menuDataJson.length / 1024).toFixed(1)} KB)`);
   await outputFile(menuDataPath, menuDataJson);
 
+  // Write custom menu JSON files
+  for (const [menuDir, menuInfo] of customMenus) {
+    const customMenuPath = join(output, menuInfo.menuJsonPath);
+    const customMenuJson = JSON.stringify(menuInfo.menuData);
+    progress.log(`Writing custom menu: ${menuInfo.menuJsonPath}`);
+    await outputFile(customMenuPath, customMenuJson);
+  }
+
   // Process directory indices with batched concurrency
   const totalDirs = allSourceFilenamesThatAreDirectories.length;
   let processedDirs = 0;
@@ -613,6 +494,8 @@ export async function generate({
         for (const [key, value] of Object.entries(replacements)) {
           finalHtml = finalHtml.replace(key, value);
         }
+        // Add cache-busting timestamps to static file references
+        finalHtml = addTimestampToHtmlStaticRefs(finalHtml, cacheBustTimestamp);
         await outputFile(htmlOutputFilename, finalHtml);
       }
     } catch (e) {
@@ -647,7 +530,7 @@ export async function generate({
       processedStatic++;
       const shortFile = file.replace(source, '');
       progress.status('Static files', `${processedStatic}/${totalStatic} ${shortFile}`);
-      
+
       // Check if file has changed using file stat as a quick check
       const fileStat = await stat(file);
       const statKey = `${file}:stat`;
@@ -659,9 +542,16 @@ export async function generate({
       copiedStatic++;
 
       const outputFilename = file.replace(source, output);
-
       await mkdir(dirname(outputFilename), { recursive: true });
-      return await copyFile(file, outputFilename);
+
+      if (file.endsWith('.css')) {
+        // Process CSS for cache busting
+        const cssContent = await readFile(file, 'utf8');
+        const processedCss = addTimestampToCssUrls(cssContent, cacheBustTimestamp);
+        await outputFile(outputFilename, processedCss);
+      } else {
+        await copyFile(file, outputFilename);
+      }
     } catch (e) {
       progress.log(`Error processing static file ${file}: ${e.message}`);
       errors.push({ file, phase: 'static-file', error: e });
@@ -672,7 +562,7 @@ export async function generate({
 
   // Automatic index generation for folders without index.html
   progress.log(`Checking for missing index files...`);
-  await generateAutoIndices(output, allSourceFilenamesThatAreDirectories, source, templates, menu, footer, allSourceFilenamesThatAreArticles, copiedCssFiles, existingHtmlFiles);
+  await generateAutoIndices(output, allSourceFilenamesThatAreDirectories, source, templates, menu, footer, allSourceFilenamesThatAreArticles, copiedCssFiles, existingHtmlFiles, cacheBustTimestamp, progress);
 
   // Save the hash cache to .ursa folder in source directory
   if (hashCache.size > 0) {
@@ -729,191 +619,6 @@ export async function generate({
   }
 }
 
-/**
- * Generate automatic index.html files for folders that don't have one
- * @param {string} output - Output directory path
- * @param {string[]} directories - List of source directories
- * @param {string} source - Source directory path
- * @param {object} templates - Template map
- * @param {string} menu - Rendered menu HTML
- * @param {string} footer - Footer HTML
- * @param {string[]} generatedArticles - List of source article paths that were generated
- * @param {Set<string>} copiedCssFiles - Set of CSS files already copied to output
- * @param {Set<string>} existingHtmlFiles - Set of existing HTML files in source (relative paths)
- */
-async function generateAutoIndices(output, directories, source, templates, menu, footer, generatedArticles, copiedCssFiles, existingHtmlFiles) {
-  // Alternate index file names to look for (in priority order)
-  const INDEX_ALTERNATES = ['_index.html', 'home.html', '_home.html'];
-  
-  // Normalize paths (remove trailing slashes for consistent replacement)
-  const sourceNorm = source.replace(/\/+$/, '');
-  const outputNorm = output.replace(/\/+$/, '');
-  
-  // Build set of directories that already have an index.html from a source index.md/txt/yml
-  const dirsWithSourceIndex = new Set();
-  for (const articlePath of generatedArticles) {
-    const base = basename(articlePath, extname(articlePath));
-    if (base === 'index') {
-      const dir = dirname(articlePath);
-      const outputDir = dir.replace(sourceNorm, outputNorm);
-      dirsWithSourceIndex.add(outputDir);
-    }
-  }
-  
-  // Get all output directories (including root)
-  const outputDirs = new Set([outputNorm]);
-  for (const dir of directories) {
-    // Handle both with and without trailing slash in source
-    const outputDir = dir.replace(sourceNorm, outputNorm);
-    outputDirs.add(outputDir);
-  }
-  
-  let generatedCount = 0;
-  let renamedCount = 0;
-  let skippedHtmlCount = 0;
-  
-  for (const dir of outputDirs) {
-    const indexPath = join(dir, 'index.html');
-    
-    // Skip if this directory had a source index.md/txt/yml that was already processed
-    if (dirsWithSourceIndex.has(dir)) {
-      continue;
-    }
-    
-    // Check if there's an existing index.html in the source directory (don't overwrite it)
-    const sourceDir = dir.replace(outputNorm, sourceNorm);
-    const relativeIndexPath = join(sourceDir, 'index.html').replace(sourceNorm + '/', '');
-    if (existingHtmlFiles && existingHtmlFiles.has(relativeIndexPath)) {
-      skippedHtmlCount++;
-      continue; // Don't overwrite existing source HTML
-    }
-    
-    // Skip if index.html already exists in output (e.g., created by previous run)
-    if (existsSync(indexPath)) {
-      continue;
-    }
-    
-    // Get folder name for (foldername).html check
-    const folderName = basename(dir);
-    const folderNameAlternate = `${folderName}.html`;
-    
-    // Check for alternate index files
-    let foundAlternate = null;
-    for (const alt of [...INDEX_ALTERNATES, folderNameAlternate]) {
-      const altPath = join(dir, alt);
-      if (existsSync(altPath)) {
-        foundAlternate = altPath;
-        break;
-      }
-    }
-    
-    if (foundAlternate) {
-      // Rename/copy alternate to index.html
-      try {
-        const content = await readFile(foundAlternate, 'utf8');
-        await outputFile(indexPath, content);
-        renamedCount++;
-        progress.status('Auto-index', `Promoted ${basename(foundAlternate)} → index.html in ${dir.replace(outputNorm, '') || '/'}`);
-      } catch (e) {
-        progress.log(`Error promoting ${foundAlternate} to index.html: ${e.message}`);
-      }
-    } else {
-      // Generate a simple index listing direct children
-      try {
-        const children = await readdir(dir, { withFileTypes: true });
-        
-        // Filter to only include relevant files and folders
-        const items = children
-          .filter(child => {
-            // Skip hidden files and index alternates we just checked
-            if (child.name.startsWith('.')) return false;
-            if (child.name === 'index.html') return false;
-            // Include directories and html files
-            return child.isDirectory() || child.name.endsWith('.html');
-          })
-          .map(child => {
-            const isDir = child.isDirectory();
-            const name = isDir ? child.name : child.name.replace('.html', '');
-            const href = isDir ? `${child.name}/` : child.name;
-            const displayName = toTitleCase(name);
-            const icon = isDir ? '📁' : '📄';
-            return `<li>${icon} <a href="${href}">${displayName}</a></li>`;
-          });
-        
-        if (items.length === 0) {
-          // Empty folder, skip generating index
-          continue;
-        }
-        
-        const folderDisplayName = dir === outputNorm ? 'Home' : toTitleCase(folderName);
-        const indexHtml = `<h1>${folderDisplayName}</h1>\n<ul class="auto-index">\n${items.join('\n')}\n</ul>`;
-        
-        const template = templates["default-template"];
-        if (!template) {
-          progress.log(`Warning: No default template for auto-index in ${dir}`);
-          continue;
-        }
-        
-        // Find nearest style.css for this directory
-        let styleLink = "";
-        try {
-          // Map output dir back to source dir to find style.css
-          const sourceDir = dir.replace(outputNorm, sourceNorm);
-          const cssPath = await findStyleCss(sourceDir);
-          if (cssPath) {
-            // Calculate output path for the CSS file (mirrors source structure)
-            const cssOutputPath = cssPath.replace(sourceNorm, outputNorm);
-            const cssUrlPath = '/' + cssPath.replace(sourceNorm, '');
-            
-            // Copy CSS file if not already copied
-            if (!copiedCssFiles.has(cssPath)) {
-              const cssContent = await readFile(cssPath, 'utf8');
-              await outputFile(cssOutputPath, cssContent);
-              copiedCssFiles.add(cssPath);
-            }
-            
-            // Generate link tag
-            styleLink = `<link rel="stylesheet" href="${cssUrlPath}" />`;
-          }
-        } catch (e) {
-          // ignore CSS lookup errors
-        }
-        
-        let finalHtml = template;
-        const replacements = {
-          "${menu}": menu,
-          "${body}": indexHtml,
-          "${searchIndex}": "[]",
-          "${title}": folderDisplayName,
-          "${meta}": "{}",
-          "${transformedMetadata}": "",
-          "${styleLink}": styleLink,
-          "${footer}": footer
-        };
-        for (const [key, value] of Object.entries(replacements)) {
-          finalHtml = finalHtml.replace(key, value);
-        }
-        
-        await outputFile(indexPath, finalHtml);
-        generatedCount++;
-        progress.status('Auto-index', `Generated index.html for ${dir.replace(outputNorm, '') || '/'}`);
-      } catch (e) {
-        progress.log(`Error generating auto-index for ${dir}: ${e.message}`);
-      }
-    }
-  }
-  
-  if (generatedCount > 0 || renamedCount > 0 || skippedHtmlCount > 0) {
-    let summary = `${generatedCount} generated, ${renamedCount} promoted`;
-    if (skippedHtmlCount > 0) {
-      summary += `, ${skippedHtmlCount} skipped (existing HTML)`;
-    }
-    progress.done('Auto-index', summary);
-  } else {
-    progress.log(`Auto-index: All folders already have index.html`);
-  }
-}
-
 /**
  * Regenerate a single file without scanning the entire source directory.
  * This is much faster for watch mode - only regenerate what changed.
@@ -949,7 +654,7 @@ export async function regenerateSingleFile(changedFile, {
   }
   
   try {
-    const { templates, menu, footer, validPaths, hashCache } = watchModeCache;
+    const { templates, menu, footer, validPaths, hashCache, cacheBustTimestamp } = watchModeCache;
     
     const rawBody = await readFile(changedFile, "utf8");
     const type = parse(changedFile).ext;
@@ -1032,6 +737,9 @@ export async function regenerateSingleFile(changedFile, {
     // Mark broken links
     finalHtml = markInactiveLinks(finalHtml, validPaths, docUrlPath, false);
     
+    // Add cache-busting timestamps to static file references
+    finalHtml = addTimestampToHtmlStaticRefs(finalHtml, cacheBustTimestamp);
+    
     await outputFile(outputFilename, finalHtml);
     
     // JSON output
@@ -1063,176 +771,4 @@ export async function regenerateSingleFile(changedFile, {
   } catch (e) {
     return { success: false, message: `Error: ${e.message}` };
   }
-}
-
-/**
- * gets { [templateName:String]:[templateBody:String] }
- * meta: full path to meta files (default-template.html, etc)
- */
-async function getTemplates(meta) {
-  const allMetaFilenames = await recurse(meta);
-  const allHtmlFilenames = allMetaFilenames.filter((filename) =>
-    filename.match(/\.html/)
-  );
-
-  let templates = {};
-  const templatesArray = await Promise.all(
-    allHtmlFilenames.map(async (filename) => {
-      const { name } = parse(filename);
-      const fileContent = await readFile(filename, "utf8");
-      return [name, fileContent];
-    })
-  );
-  templatesArray.forEach(
-    ([templateName, templateText]) => (templates[templateName] = templateText)
-  );
-
-  return templates;
-}
-
-async function getMenu(allSourceFilenames, source, validPaths) {
-  // todo: handle various incarnations of menu filename
-
-  const menuResult = await getAutomenu(source, validPaths);
-  const menuBody = renderFile({ fileContents: menuResult.html, type: ".md" });
-  return {
-    html: menuBody,
-    menuData: menuResult.menuData
-  };
-}
-
-async function getTransformedMetadata(dirname, metadata) {
-  // console.log("getTransformedMetadata > ", { dirname });
-  // custom transform? else, use default
-  const customTransformFnFilename = join(dirname, "transformMetadata.js");
-  let transformFn = defaultTransformFn;
-  try {
-    const customTransformFn = (await import(customTransformFnFilename)).default;
-    if (typeof customTransformFn === "function")
-      transformFn = customTransformFn;
-  } catch (e) {
-    // console.error(e);
-  }
-  try {
-    return transformFn(metadata);
-  } catch (e) {
-    return "error transforming metadata";
-  }
-
-  function defaultTransformFn(metadata) {
-    return "default transform";
-  }
-}
-
-function addTrailingSlash(somePath) {
-  if (typeof somePath !== "string") return somePath;
-  if (somePath.length < 1) return somePath;
-  if (somePath[somePath.length - 1] == "/") return somePath;
-  return `${somePath}/`;
-}
-
-/**
- * Generate footer HTML from footer.md and package.json
- * @param {string} source - resolved source path with trailing slash
- * @param {string} _source - original source path
- * @param {number} buildId - the current build ID
- */
-async function getFooter(source, _source, buildId) {
-  const footerParts = [];
-  
-  // Try to read footer.md from source root
-  const footerPath = join(source, 'footer.md');
-  try {
-    if (existsSync(footerPath)) {
-      const footerMd = await readFile(footerPath, 'utf8');
-      const footerHtml = renderFile({ fileContents: footerMd, type: '.md' });
-      footerParts.push(`<div class="footer-content">${footerHtml}</div>`);
-    }
-  } catch (e) {
-    console.error(`Error reading footer.md: ${e.message}`);
-  }
-  
-  // Try to read package.json from doc repo (check both source dir and parent)
-  let docPackage = null;
-  const sourceDir = resolve(_source);
-  const packagePaths = [
-    join(sourceDir, 'package.json'),           // In source dir itself
-    join(sourceDir, '..', 'package.json'),     // One level up (if docs is a subfolder)
-  ];
-  
-  for (const packagePath of packagePaths) {
-    try {
-      if (existsSync(packagePath)) {
-        const packageJson = await readFile(packagePath, 'utf8');
-        docPackage = JSON.parse(packageJson);
-        console.log(`Found doc package.json at ${packagePath}`);
-        break;
-      }
-    } catch (e) {
-      // Continue to next path
-    }
-  }
-  
-  // Get ursa version from ursa's own package.json
-  // Use import.meta.url to find the package.json relative to this file
-  let ursaVersion = 'unknown';
-  try {
-    // From src/jobs/generate.js, go up to package root
-    const currentFileUrl = new URL(import.meta.url);
-    const currentDir = dirname(currentFileUrl.pathname);
-    const ursaPackagePath = resolve(currentDir, '..', '..', 'package.json');
-    
-    if (existsSync(ursaPackagePath)) {
-      const ursaPackageJson = await readFile(ursaPackagePath, 'utf8');
-      const ursaPackage = JSON.parse(ursaPackageJson);
-      ursaVersion = ursaPackage.version;
-      console.log(`Found ursa package.json at ${ursaPackagePath}, version: ${ursaVersion}`);
-    }
-  } catch (e) {
-    console.error(`Error reading ursa package.json: ${e.message}`);
-  }
-  
-  // Build meta line: version, build id, timestamp, "generated by ursa"
-  const metaParts = [];
-  if (docPackage?.version) {
-    metaParts.push(`v${docPackage.version}`);
-  }
-  metaParts.push(`build ${buildId}`);
-  
-  // Full date/time in a readable format
-  const now = new Date();
-  const timestamp = now.toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, ' UTC');
-  metaParts.push(timestamp);
-  
-  metaParts.push(`Generated by <a href="https://www.npmjs.com/package/@kenjura/ursa">ursa</a> v${ursaVersion}`);
-  
-  footerParts.push(`<div class="footer-meta">${metaParts.join(' • ')}</div>`);
-  
-  // Copyright line from doc package.json
-  if (docPackage?.copyright) {
-    footerParts.push(`<div class="footer-copyright">${docPackage.copyright}</div>`);
-  } else if (docPackage?.author) {
-    const year = new Date().getFullYear();
-    const author = typeof docPackage.author === 'string' ? docPackage.author : docPackage.author.name;
-    if (author) {
-      footerParts.push(`<div class="footer-copyright">© ${year} ${author}</div>`);
-    }
-  }
-  
-  // Try to get git short hash of doc repo (as HTML comment)
-  try {
-    const { execSync } = await import('child_process');
-    const gitHash = execSync('git rev-parse --short HEAD', {
-      cwd: resolve(_source),
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-    if (gitHash) {
-      footerParts.push(`<!-- git: ${gitHash} -->`);
-    }
-  } catch (e) {
-    // Not a git repo or git not available - silently skip
-  }
-  
-  return footerParts.join('\n');
 }