@mgks/docmd 0.3.7 → 0.3.8

package/src/commands/live.js

@@ -0,0 +1,145 @@
+// Source file from the docmd project — https://github.com/docmd-io/docmd
+
+const fs = require('../core/fs-utils'); // Native wrapper
+const path = require('path');
+const esbuild = require('esbuild');
+const { processAssets } = require('../core/asset-manager');
+
+async function build() {
+    console.log('📦 Building @docmd/live core...');
+
+    // Resolve paths relative to src/commands/live.js
+    const SRC_DIR = path.resolve(__dirname, '..'); // Points to /src
+    const LIVE_SRC_DIR = path.join(SRC_DIR, 'live');
+    const DIST_DIR = path.resolve(__dirname, '../../dist'); // Points to /dist in root
+
+    // 1. Clean/Create dist
+    if (await fs.exists(DIST_DIR)) {
+        await fs.remove(DIST_DIR);
+    }
+    await fs.ensureDir(DIST_DIR);
+
+    // 2. Generate Shim for Buffer (Browser compatibility)
+    const shimPath = path.join(LIVE_SRC_DIR, 'shims.js');
+    await fs.writeFile(shimPath, `import { Buffer } from 'buffer'; globalThis.Buffer = Buffer;`);
+
+    // 3. Define the Virtual Template Plugin
+    // This reads EJS files from disk and bundles them as a JSON object string
+    const templatePlugin = {
+        name: 'docmd-templates',
+        setup(build) {
+            build.onResolve({ filter: /^virtual:docmd-templates$/ }, args => ({
+                path: args.path,
+                namespace: 'docmd-templates-ns',
+            }));
+
+            build.onLoad({ filter: /.*/, namespace: 'docmd-templates-ns' }, async () => {
+                const templatesDir = path.join(SRC_DIR, 'templates');
+                const files = await fs.readdir(templatesDir);
+                const templates = {};
+
+                for (const file of files) {
+                    if (file.endsWith('.ejs')) {
+                        const content = await fs.readFile(path.join(templatesDir, file), 'utf8');
+                        templates[file] = content;
+                    }
+                }
+
+                return {
+                    contents: `module.exports = ${JSON.stringify(templates)};`,
+                    loader: 'js',
+                };
+            });
+        },
+    };
+
+    // 4. Define Node Modules Shim Plugin
+    // Stubs out fs/path requires so the browser bundle doesn't crash
+    const nodeShimPlugin = {
+        name: 'node-deps-shim',
+        setup(build) {
+            build.onResolve({ filter: /^(node:)?path$/ }, args => ({ path: args.path, namespace: 'path-shim' }));
+            build.onLoad({ filter: /.*/, namespace: 'path-shim' }, () => ({
+                contents: `
+                    module.exports = {
+                        join: (...args) => args.filter(Boolean).join('/'),
+                        resolve: (...args) => '/' + args.filter(Boolean).join('/'),
+                        basename: (p) => p ? p.split(/[\\\\/]/).pop() : '',
+                        dirname: (p) => p ? p.split(/[\\\\/]/).slice(0, -1).join('/') || '.' : '.',
+                        extname: (p) => { if (!p) return ''; const parts = p.split('.'); return parts.length > 1 ? '.' + parts.pop() : ''; },
+                        isAbsolute: (p) => p.startsWith('/'),
+                        normalize: (p) => p,
+                        sep: '/'
+                    };
+                `,
+                loader: 'js'
+            }));
+
+            build.onResolve({ filter: /^(node:)?fs(\/promises)?|fs-extra$/ }, args => ({ path: args.path, namespace: 'fs-shim' }));
+            build.onLoad({ filter: /.*/, namespace: 'fs-shim' }, () => ({
+                contents: `
+                    module.exports = {
+                        existsSync: () => false,
+                        readFileSync: () => '',
+                        statSync: () => ({ isFile: () => true, isDirectory: () => false }),
+                        constants: { F_OK: 0, R_OK: 4 },
+                        promises: {}
+                    };
+                `, 
+                loader: 'js'
+            }));
+        }
+    };
+
+    // 5. Bundle JS
+    console.log('⚡ Bundling & Compressing JS...');
+    try {
+        await esbuild.build({
+            entryPoints: [path.join(LIVE_SRC_DIR, 'core.js')],
+            bundle: true,
+            outfile: path.join(DIST_DIR, 'docmd-live.js'),
+            platform: 'browser',
+            format: 'iife',
+            globalName: 'docmd',
+            minify: true,
+            define: { 'process.env.NODE_ENV': '"production"' },
+            inject: [shimPath],
+            plugins: [templatePlugin, nodeShimPlugin]
+        });
+
+        // 6. Copy & Minify Static Assets using Universal Manager
+        console.log('📂 Processing static assets...');
+        const assetsSrc = path.join(SRC_DIR, 'assets');
+        const assetsDest = path.join(DIST_DIR, 'assets');
+        
+        if (await fs.exists(assetsSrc)) {
+            await processAssets(assetsSrc, assetsDest, { minify: true });
+        }
+
+        // 7. Copy HTML Wrapper & Minify Live CSS
+        await fs.copy(path.join(LIVE_SRC_DIR, 'index.html'), path.join(DIST_DIR, 'index.html'));
+        
+        const liveCss = await fs.readFile(path.join(LIVE_SRC_DIR, 'live.css'), 'utf8');
+        const minifiedLiveCss = await esbuild.transform(liveCss, { loader: 'css', minify: true });
+        await fs.writeFile(path.join(DIST_DIR, 'live.css'), minifiedLiveCss.code);
+
+        // 8. Copy Favicon to Root
+        const internalFavicon = path.join(assetsSrc, 'favicon.ico');
+        if (await fs.exists(internalFavicon)) {
+            await fs.copy(internalFavicon, path.join(DIST_DIR, 'favicon.ico'));
+        }
+
+        console.log('✅ Live Editor build complete!');
+
+    } catch (e) {
+        console.error('❌ Build failed:', e);
+        process.exit(1);
+    }
+}
+
+// Allow direct execution (via scripts/failsafe.js)
+if (require.main === module) {
+    build();
+}
+
+module.exports = { build };

package/src/core/asset-manager.js

@@ -0,0 +1,72 @@
+// Source file from the docmd project — https://github.com/docmd-io/docmd
+
+const path = require('path');
+const fs = require('./fs-utils');
+const esbuild = require('esbuild');
+
+const DOCMD_HEADER = `/*! Source file from the docmd project — https://github.com/docmd-io/docmd */\n\n`;
+
+/**
+ * Recursively copies assets from src to dest.
+ * Minifies CSS/JS files and adds docmd header.
+ * 
+ * @param {string} srcDir - Source directory
+ * @param {string} destDir - Destination directory
+ * @param {object} options - { minify: boolean }
+ */
+async function processAssets(srcDir, destDir, options = { minify: true }) {
+  // Ensure source exists
+  if (!await fs.exists(srcDir)) return;
+
+  // Ensure dest exists
+  await fs.ensureDir(destDir);
+
+  const entries = await fs.readdir(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      await processAssets(srcPath, destPath, options);
+    } else {
+      const ext = path.extname(entry.name).toLowerCase();
+      
+      // Handle CSS & JS: Minify + docmd Header
+      if (ext === '.css' || ext === '.js') {
+        try {
+          const content = await fs.readFile(srcPath, 'utf8');
+          
+          if (options.minify) {
+            // Minify using esbuild
+            const result = await esbuild.transform(content, {
+              loader: ext.slice(1), // 'css' or 'js'
+              minify: true,
+              banner: ext === '.css' || ext === '.js' ? DOCMD_HEADER : ''
+            });
+            await fs.writeFile(destPath, result.code);
+          } else {
+            // Just add banner if not minifying (Dev mode)
+            const contentWithBanner = `${DOCMD_HEADER}\n${content}`;
+            await fs.writeFile(destPath, contentWithBanner);
+          }
+        } catch (e) {
+          console.warn(`⚠️ Processing failed for ${entry.name}, copying original.`);
+          await fs.copy(srcPath, destPath);
+        }
+      } 
+      // Handle HTML Files (if any in assets): HTML Comment Header
+      else if (ext === '.html') {
+        const content = await fs.readFile(srcPath, 'utf8');
+        const htmlBanner = `<!-- Generated by docmd - https://docmd.io -->\n\n`;
+        await fs.writeFile(destPath, htmlBanner + content);
+      }
+      // Everything else (Images, Fonts): Direct Copy
+      else {
+        await fs.copy(srcPath, destPath);
+      }
+    }
+  }
+}
+
+module.exports = { processAssets, DOCMD_HEADER };

package/src/core/config-loader.js

@@ -1,7 +1,7 @@
-// Source file from the docmd project — https://github.com/mgks/docmd
+// Source file from the docmd project — https://github.com/docmd-io/docmd
 
 const path = require('path');
-const fs = require('fs-extra');
+const fs = require('./fs-utils');
 const { validateConfig } = require('./config-validator');
 
 async function loadConfig(configPath) {

package/src/core/config-validator.js

@@ -1,4 +1,4 @@
-// Source file from the docmd project — https://github.com/mgks/docmd
+// Source file from the docmd project — https://github.com/docmd-io/docmd
 
 const chalk = require('chalk');
 

package/src/core/file-processor.js

@@ -1,14 +1,18 @@
-// Source file from the docmd project — https://github.com/mgks/docmd
+// Source file from the docmd project — https://github.com/docmd-io/docmd
 
-const fs = require('fs-extra');
+const fs = require('./fs-utils');
 const path = require('path');
 const matter = require('gray-matter');
 const { createMarkdownItInstance } = require('./markdown/setup');
-const striptags = require('striptags');
 
 function decodeHtmlEntities(html) {
     return html.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"').replace(/'/g, "'").replace(/ /g, ' ');
 }
+
+function stripHtmlTags(str) {
+  if (!str) return '';
+  return str.replace(/<[^>]*>?/gm, '');
+}
   
 function extractHeadingsFromHtml(htmlContent) {
     const headings = [];
@@ -65,12 +69,12 @@ function processMarkdownContent(rawContent, md, config, filePath = 'memory') {
 
     let searchData = null;
     if (!frontmatter.noindex) {
-        const rawText = decodeHtmlEntities(striptags(htmlContent));
-        searchData = {
-            title: frontmatter.title || 'Untitled',
-            content: rawText.slice(0, 5000), // Safety cap to prevent massive JSON
-            headings: headings.map(h => h.text)
-        };
+      const rawText = decodeHtmlEntities(stripHtmlTags(htmlContent));
+      searchData = {
+          title: frontmatter.title || 'Untitled',
+          content: rawText.slice(0, 5000), // Safety cap to prevent massive JSON
+          headings: headings.map(h => h.text)
+      };
     }
   
     return { frontmatter, htmlContent, headings, searchData };

package/src/core/fs-utils.js

@@ -0,0 +1,40 @@
+// Source file from the docmd project — https://github.com/docmd-io/docmd
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+async function remove(dirPath) {
+  await fs.rm(dirPath, { recursive: true, force: true });
+}
+
+async function copy(src, dest) {
+  await fs.cp(src, dest, { recursive: true });
+}
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function writeJson(file, object, options = {}) {
+  const content = JSON.stringify(object, null, options.spaces || 2);
+  await fs.writeFile(file, content, 'utf8');
+}
+
+module.exports = {
+  ...fs,
+  ensureDir,
+  remove,
+  copy,
+  pathExists: exists,
+  exists,
+  writeJson
+};

package/src/core/html-formatter.js

@@ -0,0 +1,97 @@
+// Source file from the docmd project — https://github.com/docmd-io/docmd
+
+// Tags that don't have a closing tag (void elements)
+const VOID_TAGS = new Set([
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 
+    'link', 'meta', 'param', 'source', 'track', 'wbr', '!doctype'
+]);
+
+// Tags where whitespace should be preserved exactly
+const PRESERVE_TAGS = new Set(['pre', 'script', 'style', 'textarea']);
+
+function formatHtml(html) {
+    if (!html) return '';
+
+    const lines = html.split(/\r?\n/);
+    let formatted = [];
+    let indentLevel = 0;
+    const indentSize = 4; // 4 spaces per level
+    
+    // State tracking
+    let inPreserveBlock = false;
+    let preserveTagName = '';
+
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i].trim(); // Start with a clean slate for this line
+
+        if (!line) continue; // Skip empty lines
+
+        // --- 1. Handle Preserve Blocks (pre/script/style) ---
+        if (inPreserveBlock) {
+            // Check if this line ends the block
+            if (line.toLowerCase().includes(`</${preserveTagName}>`)) {
+                inPreserveBlock = false;
+            } else {
+                // If inside preserve block, add raw line (no trim) from original
+                formatted.push(lines[i]); 
+                continue;
+            }
+        }
+
+        // Check if this line STARTS a preserve block
+        for (const tag of PRESERVE_TAGS) {
+            if (line.toLowerCase().startsWith(`<${tag}`)) {
+                inPreserveBlock = true;
+                preserveTagName = tag;
+                // If it's a one-liner (e.g. <script>...</script>), handle it immediately
+                if (line.toLowerCase().includes(`</${tag}>`)) {
+                    inPreserveBlock = false;
+                }
+                break;
+            }
+        }
+
+        // --- 2. Calculate Indentation ---
+        
+        // Detect closing tags at the start of the line (e.g. </div> or -->)
+        const isClosing = /^<\//.test(line) || /^-->/.test(line);
+        
+        if (isClosing && indentLevel > 0) {
+            indentLevel--;
+        }
+
+        // Apply indentation
+        const spaces = ' '.repeat(indentLevel * indentSize);
+        formatted.push(spaces + line);
+
+        // --- 3. Adjust Indent for Next Line ---
+        
+        // Detect opening tags
+        // Logic: Starts with <, not </, not <!, not void tag, and not self-closing />
+        const isOpening = /^<[\w]+/.test(line) 
+            && !/^<\//.test(line) 
+            && !/\/>$/.test(line); // Ends with />
+
+        if (isOpening) {
+            // Extract tag name to check if it's void
+            const tagNameMatch = line.match(/^<([\w-]+)/);
+            if (tagNameMatch) {
+                const tagName = tagNameMatch[1].toLowerCase();
+                if (!VOID_TAGS.has(tagName)) {
+                    // Check if it's a one-liner: <div>Content</div>
+                    // Logic: count opening vs closing tags in this line
+                    // Simple heuristic: if line contains </tagName>, it's closed
+                    const hasClosingPair = new RegExp(`</${tagName}>`, 'i').test(line);
+                    
+                    if (!hasClosingPair) {
+                        indentLevel++;
+                    }
+                }
+            }
+        }
+    }
+
+    return formatted.join('\n');
+}
+
+module.exports = { formatHtml };

package/src/core/html-generator.js

@@ -1,70 +1,73 @@
-// Source file from the docmd project — https://github.com/mgks/docmd
+// Source file from the docmd project — https://github.com/docmd-io/docmd
 
 const ejs = require('ejs');
 const path = require('path');
-const fs = require('fs-extra');
+const fs = require('../core/fs-utils');
 const { createMarkdownItInstance } = require('./file-processor');
 const { generateSeoMetaTags } = require('../plugins/seo');
 const { generateAnalyticsScripts } = require('../plugins/analytics');
 const { renderIcon } = require('./icon-renderer');
+const { formatHtml } = require('./html-formatter');
 
 let mdInstance = null;
 let themeInitScript = '';
 
+// Load the theme initialization script into memory once to avoid repeated disk I/O
 (async () => {
-    if (typeof __dirname !== 'undefined') {
+    try {
         const themeInitPath = path.join(__dirname, '..', 'templates', 'partials', 'theme-init.js');
-        if (await fs.pathExists(themeInitPath)) {
+        if (await fs.exists(themeInitPath)) {
             const scriptContent = await fs.readFile(themeInitPath, 'utf8');
-            themeInitScript = `<script>${scriptContent}</script>`;
+            themeInitScript = `<script>\n${scriptContent}\n</script>`;
         }
-    }
+    } catch (e) { /* ignore */ }
 })();
 
-// Helper to handle link rewriting based on build mode
+// Removes excessive whitespace and blank lines from the generated HTML
+function cleanupHtml(html) {
+    if (!html) return '';
+    return html
+        .replace(/^[ \t]+$/gm, '')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+
+// Rewrites links based on build mode (Offline/File protocol vs Web Server)
 function fixHtmlLinks(htmlContent, relativePathToRoot, isOfflineMode) {
     if (!htmlContent) return '';
     const root = relativePathToRoot || './';
 
-    // Regex matches hrefs starting with /, ./, or ../
     return htmlContent.replace(/href="((?:\/|\.\/|\.\.\/)[^"]*)"/g, (match, href) => {
         let finalPath = href;
-
-        // 1. Convert Absolute to Relative
+        
+        // Convert absolute project paths to relative
         if (href.startsWith('/')) {
             finalPath = root + href.substring(1);
         }
         
-        // 2. Logic based on Mode
+        // Handle offline mode (force index.html for directories)
         if (isOfflineMode) {
-            // Offline Mode: Force index.html for directories
             const cleanPath = finalPath.split('#')[0].split('?')[0];
-            // If it has no extension (like .html, .css, .png), treat as directory
             if (!path.extname(cleanPath)) {
                 if (finalPath.includes('#')) {
-                    // Handle anchors: ./foo/#bar -> ./foo/index.html#bar
                     const parts = finalPath.split('#');
                     const prefix = parts[0].endsWith('/') ? parts[0] : parts[0] + '/';
                     finalPath = prefix + 'index.html#' + parts[1];
                 } else {
-                    if (finalPath.endsWith('/')) {
-                        finalPath += 'index.html';
-                    } else {
-                        finalPath += '/index.html';
-                    }
+                    finalPath += (finalPath.endsWith('/') ? '' : '/') + 'index.html';
                 }
             }
         } else {
-            // Online/Dev Mode: Strip index.html for clean URLs
+            // Web mode (strip index.html for clean URLs)
             if (finalPath.endsWith('/index.html')) {
                 finalPath = finalPath.substring(0, finalPath.length - 10);
             }
         }
-        
         return `href="${finalPath}"`;
     });
 }
 
+// aggregates HTML snippets from various plugins (SEO, Analytics, etc.)
 async function processPluginHooks(config, pageData, relativePathToRoot) {
     let metaTagsHtml = '';
     let faviconLinkHtml = '';
@@ -74,19 +77,17 @@ async function processPluginHooks(config, pageData, relativePathToRoot) {
     let pluginBodyScriptsHtml = '';
 
     const safeRoot = relativePathToRoot || './';
+    const indent = '    '; // 4 spaces for cleaner output
 
-    // Favicon
     if (config.favicon) {
         const cleanFaviconPath = config.favicon.startsWith('/') ? config.favicon.substring(1) : config.favicon;
         const finalFaviconHref = `${safeRoot}${cleanFaviconPath}`;
-        
-        faviconLinkHtml = `  <link rel="icon" href="${finalFaviconHref}" type="image/x-icon" sizes="any">\n`;
-        faviconLinkHtml += `  <link rel="shortcut icon" href="${finalFaviconHref}" type="image/x-icon">\n`;
+        faviconLinkHtml = `${indent}<link rel="icon" href="${finalFaviconHref}" type="image/x-icon" sizes="any">\n${indent}<link rel="shortcut icon" href="${finalFaviconHref}" type="image/x-icon">`;
     }
 
     if (config.theme && config.theme.name && config.theme.name !== 'default') {
         const themeCssPath = `assets/css/docmd-theme-${config.theme.name}.css`;
-        themeCssLinkHtml = `  <link rel="stylesheet" href="${safeRoot}${themeCssPath}">\n`;
+        themeCssLinkHtml = `${indent}<link rel="stylesheet" href="${safeRoot}${themeCssPath}">`;
     }
 
     if (config.plugins?.seo) {
@@ -102,91 +103,86 @@ async function processPluginHooks(config, pageData, relativePathToRoot) {
     return { metaTagsHtml, faviconLinkHtml, themeCssLinkHtml, pluginStylesHtml, pluginHeadScriptsHtml, pluginBodyScriptsHtml };
 }
 
+// Main function to assemble the page data and render the EJS template
 async function generateHtmlPage(templateData, isOfflineMode = false) {
-    let { content, siteTitle, navigationHtml, relativePathToRoot, config, frontmatter, outputPath, prevPage, nextPage, currentPagePath, headings } = templateData;
+    let { content, frontmatter, outputPath, headings, config } = templateData;
+    const { currentPagePath, prevPage, nextPage, relativePathToRoot, navigationHtml, siteTitle } = templateData;
     const pageTitle = frontmatter.title;
 
-    if (!relativePathToRoot) relativePathToRoot = './';
+    if (!relativePathToRoot) templateData.relativePathToRoot = './';
 
-    // Fix Content Links based on mode
-    content = fixHtmlLinks(content, relativePathToRoot, isOfflineMode);
-
-    const pluginOutputs = await processPluginHooks(config, { frontmatter, outputPath }, relativePathToRoot);
+    // Process content links and generate plugin assets
+    content = fixHtmlLinks(content, templateData.relativePathToRoot, isOfflineMode);
+    const pluginOutputs = await processPluginHooks(config, { frontmatter, outputPath }, templateData.relativePathToRoot);
 
+    // Process footer markdown if present
     let footerHtml = '';
     if (config.footer) {
         if (!mdInstance) mdInstance = createMarkdownItInstance(config);
         footerHtml = mdInstance.renderInline(config.footer);
-        // Fix Footer Links based on mode
-        footerHtml = fixHtmlLinks(footerHtml, relativePathToRoot, isOfflineMode);
-    }
-
-    let templateName = 'layout.ejs';
-    if (frontmatter.noStyle === true) {
-        templateName = 'no-style.ejs';
+        footerHtml = fixHtmlLinks(footerHtml, templateData.relativePathToRoot, isOfflineMode);
     }
 
+    // Determine which template to use
+    let templateName = frontmatter.noStyle === true ? 'no-style.ejs' : 'layout.ejs';
     const layoutTemplatePath = path.join(__dirname, '..', 'templates', templateName);
-    if (!await fs.pathExists(layoutTemplatePath)) {
-        throw new Error(`Template not found: ${layoutTemplatePath}`);
-    }
+    if (!await fs.exists(layoutTemplatePath)) throw new Error(`Template not found: ${layoutTemplatePath}`);
     const layoutTemplate = await fs.readFile(layoutTemplatePath, 'utf8');
 
     const isActivePage = currentPagePath && content && content.trim().length > 0;
 
+    // Build the "Edit this page" link
     let editUrl = null;
     let editLinkText = 'Edit this page';
     if (config.editLink && config.editLink.enabled && config.editLink.baseUrl) {
-         editUrl = `${config.editLink.baseUrl.replace(/\/$/, '')}/${outputPath.replace(/\/index\.html$/, '.md').replace(/\\/g, '/')}`;
+         editUrl = `${config.editLink.baseUrl.replace(/\/$/, '')}/${outputPath.replace(/\/index\.html$/, '.md')}`;
          if (outputPath.endsWith('index.html') && outputPath !== 'index.html') editUrl = editUrl.replace('.md', '/index.md'); 
          if (outputPath === 'index.html') editUrl = `${config.editLink.baseUrl.replace(/\/$/, '')}/index.md`;
          editLinkText = config.editLink.text || editLinkText;
     }
 
+    // Prepare complete data object for EJS
     const ejsData = {
-        content, pageTitle, themeInitScript, description: frontmatter.description, siteTitle, navigationHtml,
-        editUrl, editLinkText, defaultMode: config.theme?.defaultMode || 'light', relativePathToRoot,
+        ...templateData,
+        description: frontmatter.description || '', // Fix for reference error
+        footerHtml, editUrl, editLinkText, isActivePage,
+        defaultMode: config.theme?.defaultMode || 'light',
         logo: config.logo, sidebarConfig: config.sidebar || {}, theme: config.theme,
         customCssFiles: config.theme?.customCss || [], customJsFiles: config.customJs || [],
-        sponsor: config.sponsor, footer: config.footer, footerHtml, renderIcon,
-        prevPage, nextPage, currentPagePath, headings: frontmatter.toc !== false ? (headings || []) : [],
-        isActivePage, frontmatter, config, ...pluginOutputs,
+        sponsor: config.sponsor, footer: config.footer, renderIcon, themeInitScript,
+        headings: frontmatter.toc !== false ? (headings || []) : [],
+        ...pluginOutputs,
         isOfflineMode 
     };
 
-    return renderHtmlPage(layoutTemplate, ejsData, layoutTemplatePath);
+    // Render and format
+    const rawHtml = renderHtmlPage(layoutTemplate, ejsData, layoutTemplatePath);
+    const pkgVersion = require('../../package.json').version;
+    const brandingComment = `<!-- Generated by docmd (v${pkgVersion}) - https://docmd.io -->\n`;
+    
+    // Apply smart formatting to the final HTML string
+    return brandingComment + formatHtml(rawHtml);
 }
 
 function renderHtmlPage(templateContent, ejsData, filename = 'template.ejs', options = {}) {
     try {
-        return ejs.render(templateContent, ejsData, {
-            filename: filename,
-            ...options
-        });
+        return ejs.render(templateContent, ejsData, { filename: filename, ...options });
     } catch (e) {
         console.error(`❌ Error rendering EJS template: ${e.message}`);
         throw e;
     }
 }
 
-// FIX: Added isOfflineMode parameter
+// Generate the sidebar navigation HTML separately
 async function generateNavigationHtml(navItems, currentPagePath, relativePathToRoot, config, isOfflineMode = false) {
     const navTemplatePath = path.join(__dirname, '..', 'templates', 'navigation.ejs');
-    if (!await fs.pathExists(navTemplatePath)) {
-        throw new Error(`Navigation template not found: ${navTemplatePath}`);
-    }
+    if (!await fs.exists(navTemplatePath)) throw new Error(`Navigation template not found: ${navTemplatePath}`);
     const navTemplate = await fs.readFile(navTemplatePath, 'utf8');
-    const ejsHelpers = { renderIcon };
-    
     const safeRoot = relativePathToRoot || './';
 
+    // We render raw here; the main page formatter will clean this up later
     return ejs.render(navTemplate, { 
-        navItems, 
-        currentPagePath, 
-        relativePathToRoot: safeRoot, 
-        config, 
-        isOfflineMode, // <--- Passing the variable here
-        ...ejsHelpers 
+        navItems, currentPagePath, relativePathToRoot: safeRoot, config, isOfflineMode, renderIcon 
     }, { filename: navTemplatePath });
 }
 

package/src/core/icon-renderer.js

@@ -1,4 +1,4 @@
-// Source file from the docmd project — https://github.com/mgks/docmd
+// Source file from the docmd project — https://github.com/docmd-io/docmd
 
 const lucideStatic = require('lucide-static');