@underpostnet/underpost 2.98.1 → 2.99.0

package/src/cli/secrets.js

@@ -7,7 +7,7 @@
 import dotenv from 'dotenv';
 import { shellExec } from '../server/process.js';
 import fs from 'fs-extra';
-import UnderpostRootEnv from './env.js';
+import Underpost from '../index.js';
 
 dotenv.config();
 
@@ -41,7 +41,7 @@ class UnderpostSecret {
       createFromEnvFile(envPath) {
         const envObj = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
         for (const key of Object.keys(envObj)) {
-          UnderpostSecret.API.docker.set(key, envObj[key]);
+          Underpost.secret.docker.set(key, envObj[key]);
         }
       },
       set(key, value) {
@@ -61,7 +61,7 @@ class UnderpostSecret {
       createFromEnvFile(envPath) {
         const envObj = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
         for (const key of Object.keys(envObj)) {
-          UnderpostRootEnv.API.set(key, envObj[key]);
+          Underpost.env.set(key, envObj[key]);
         }
       },
     },

package/src/cli/ssh.js

@@ -5,11 +5,10 @@
  */
 
 import { generateRandomPasswordSelection } from '../client/components/core/CommonJs.js';
-import Dns from '../server/dns.js';
 import { pbcopy, shellExec } from '../server/process.js';
 import { loggerFactory } from '../server/logger.js';
 import fs from 'fs-extra';
-import UnderpostRootEnv from './env.js';
+import Underpost from '../index.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -252,17 +251,17 @@ EOF`);
 
       // Set defaults
       if (!options.user) options.user = 'root';
-      if (!options.host) options.host = await Dns.getPublicIp();
+      if (!options.host) options.host = await Underpost.dns.getPublicIp();
       if (!options.password) options.password = options.disablePassword ? '' : generateRandomPasswordSelection(16);
       if (!options.groups) options.groups = 'wheel';
       if (!options.port) options.port = 22; // Handle connect uri
 
-      const userHome = UnderpostSSH.API.getUserHome(options.user);
+      const userHome = Underpost.ssh.getUserHome(options.user);
       options.userHome = userHome;
 
       // Load config and override password and host if user exists in config
       if (options.deployId) {
-        const config = UnderpostSSH.API.loadConfigNode(options.deployId);
+        const config = Underpost.ssh.loadConfigNode(options.deployId);
         confNode = config.confNode;
         confNodePath = config.confNodePath;
 
@@ -335,7 +334,7 @@ EOF`);
         // Remove the private key copy folder and update config only if deployId is provided
         if (options.deployId) {
           if (!confNode) {
-            const config = UnderpostSSH.API.loadConfigNode(options.deployId);
+            const config = Underpost.ssh.loadConfigNode(options.deployId);
             confNode = config.confNode;
             confNodePath = config.confNodePath;
           }
@@ -347,7 +346,7 @@ EOF`);
           }
 
           delete confNode.users[options.user];
-          UnderpostSSH.API.saveConfigNode(confNodePath, confNode);
+          Underpost.ssh.saveConfigNode(confNodePath, confNode);
         }
 
         logger.info(`User removed`);
@@ -362,7 +361,7 @@ EOF`);
         // If deployId is provided, check for existing config and backup keys
         if (options.deployId) {
           if (!confNode) {
-            const config = UnderpostSSH.API.loadConfigNode(options.deployId);
+            const config = Underpost.ssh.loadConfigNode(options.deployId);
             confNode = config.confNode;
             confNodePath = config.confNodePath;
           }
@@ -378,14 +377,14 @@ EOF`);
             logger.info(`User ${options.user} already exists in config. Importing existing keys...`);
 
             // Create system user if it doesn't exist
-            const userExists = UnderpostSSH.API.checkUserExists(options.user);
+            const userExists = Underpost.ssh.checkUserExists(options.user);
             if (!userExists) {
-              UnderpostSSH.API.createSystemUser(options.user, options.password, options.groups);
+              Underpost.ssh.createSystemUser(options.user, options.password, options.groups);
             }
 
-            const userHome = UnderpostSSH.API.getUserHome(options.user);
+            const userHome = Underpost.ssh.getUserHome(options.user);
             const sshDir = `${userHome}/.ssh`;
-            UnderpostSSH.API.ensureSSHDirectory(sshDir);
+            Underpost.ssh.ensureSSHDirectory(sshDir);
 
             const userKeyPath = `${sshDir}/id_rsa`;
             const userPubKeyPath = `${sshDir}/id_rsa.pub`;
@@ -394,10 +393,10 @@ EOF`);
             fs.copyFileSync(privateKeyPath, userKeyPath);
             fs.copyFileSync(publicKeyPath, userPubKeyPath);
 
-            UnderpostSSH.API.configureAuthorizedKeys(sshDir, userPubKeyPath, options.disablePassword);
-            UnderpostSSH.API.configureSudoAccess(options.user, options.password, options.disablePassword);
-            UnderpostSSH.API.configureKnownHosts(sshDir, options.port, options.host);
-            UnderpostSSH.API.setSSHFilePermissions(sshDir, options.user, userKeyPath, userPubKeyPath);
+            Underpost.ssh.configureAuthorizedKeys(sshDir, userPubKeyPath, options.disablePassword);
+            Underpost.ssh.configureSudoAccess(options.user, options.password, options.disablePassword);
+            Underpost.ssh.configureKnownHosts(sshDir, options.port, options.host);
+            Underpost.ssh.setSSHFilePermissions(sshDir, options.user, userKeyPath, userPubKeyPath);
 
             logger.info(`Keys imported from ${privateCopyDir} to ${sshDir}`);
             logger.info(`User added with existing keys`);
@@ -406,11 +405,11 @@ EOF`);
         }
 
         // New user or no existing keys - create new user and generate keys
-        UnderpostSSH.API.createSystemUser(options.user, options.password, options.groups);
+        Underpost.ssh.createSystemUser(options.user, options.password, options.groups);
 
-        const userHome = UnderpostSSH.API.getUserHome(options.user);
+        const userHome = Underpost.ssh.getUserHome(options.user);
         const sshDir = `${userHome}/.ssh`;
-        UnderpostSSH.API.ensureSSHDirectory(sshDir);
+        Underpost.ssh.ensureSSHDirectory(sshDir);
 
         const keyPath = `${sshDir}/id_rsa`;
         const pubKeyPath = `${sshDir}/id_rsa.pub`;
@@ -421,10 +420,10 @@ EOF`);
           );
         }
 
-        UnderpostSSH.API.configureAuthorizedKeys(sshDir, pubKeyPath, options.disablePassword);
-        UnderpostSSH.API.configureSudoAccess(options.user, options.password, options.disablePassword);
-        UnderpostSSH.API.configureKnownHosts(sshDir, options.port, options.host);
-        UnderpostSSH.API.setSSHFilePermissions(sshDir, options.user, keyPath, pubKeyPath);
+        Underpost.ssh.configureAuthorizedKeys(sshDir, pubKeyPath, options.disablePassword);
+        Underpost.ssh.configureSudoAccess(options.user, options.password, options.disablePassword);
+        Underpost.ssh.configureKnownHosts(sshDir, options.port, options.host);
+        Underpost.ssh.setSSHFilePermissions(sshDir, options.user, keyPath, pubKeyPath);
 
         // Save a copy of the keys to the private folder only if deployId is provided
         if (options.deployId) {
@@ -447,7 +446,7 @@ EOF`);
             privateKeyCopyPath,
             publicKeyCopyPath,
           };
-          UnderpostSSH.API.saveConfigNode(confNodePath, confNode);
+          Underpost.ssh.saveConfigNode(confNodePath, confNode);
         }
 
         logger.info(`User added`);
@@ -457,7 +456,7 @@ EOF`);
       // Handle config user listing (only with deployId)
       if (options.deployId) {
         if (!confNode) {
-          const config = UnderpostSSH.API.loadConfigNode(options.deployId);
+          const config = Underpost.ssh.loadConfigNode(options.deployId);
           confNode = config.confNode;
           confNodePath = config.confNodePath;
         }
@@ -472,7 +471,7 @@ EOF`);
 
       // Handle generate root keys
       if (options.generate)
-        UnderpostSSH.API.generateKeys({ user: options.user, password: options.password, host: options.host });
+        Underpost.ssh.generateKeys({ user: options.user, password: options.password, host: options.host });
 
       // Handle list operations
       if (options.keysList) shellExec(`cat ${userHome}/.ssh/authorized_keys`);
@@ -489,8 +488,8 @@ EOF`);
 
       // Handle start server
       if (options.start) {
-        UnderpostSSH.API.chmod({ user: options.user });
-        UnderpostSSH.API.initService({ port: options.port });
+        Underpost.ssh.chmod({ user: options.user });
+        Underpost.ssh.initService({ port: options.port });
       }
 
       // Handle status server
@@ -512,10 +511,10 @@ EOF`);
       if (fs.existsSync(confNodePath)) {
         const { users } = JSON.parse(fs.readFileSync(confNodePath, 'utf8'));
         const { user, host, keyPath, port } = users[options.user];
-        UnderpostRootEnv.API.set('DEFAULT_SSH_USER', user);
-        UnderpostRootEnv.API.set('DEFAULT_SSH_HOST', host);
-        UnderpostRootEnv.API.set('DEFAULT_SSH_KEY_PATH', keyPath);
-        UnderpostRootEnv.API.set('DEFAULT_SSH_PORT', port);
+        Underpost.env.set('DEFAULT_SSH_USER', user);
+        Underpost.env.set('DEFAULT_SSH_HOST', host);
+        Underpost.env.set('DEFAULT_SSH_KEY_PATH', keyPath);
+        Underpost.env.set('DEFAULT_SSH_PORT', port);
       } else logger.warn(`No SSH config found at ${confNodePath}`);
     },
 

package/src/cli/static.js

@@ -412,7 +412,7 @@ class UnderpostStatic {
       // Handle config template generation
       if (options.generateConfig) {
         const configPath = typeof options.generateConfig === 'string' ? options.generateConfig : './static-config.json';
-        return UnderpostStatic.API.generateConfigTemplate(configPath);
+        return Underpost.static.generateConfigTemplate(configPath);
       }
 
       // Parse comma-separated options

package/src/cli/test.js

@@ -9,8 +9,7 @@ import { MariaDB } from '../db/mariadb/MariaDB.js';
 import { getNpmRootPath } from '../server/conf.js';
 import { actionInitLog, loggerFactory, setUpInfo } from '../server/logger.js';
 import { pbcopy, shellExec } from '../server/process.js';
-import UnderpostDeploy from './deploy.js';
-
+import Underpost from '../index.js';
 const logger = loggerFactory(import.meta);
 
 /**
@@ -67,10 +66,10 @@ class UnderpostTest {
         options.podStatus &&
         typeof options.podStatus === 'string'
       )
-        return await UnderpostTest.API.statusMonitor(options.podName, options.podStatus, options.kindType);
+        return await Underpost.test.statusMonitor(options.podName, options.podStatus, options.kindType);
 
       if (options.sh === true || options.logs === true) {
-        const [pod] = UnderpostDeploy.API.get(deployList);
+        const [pod] = Underpost.deploy.get(deployList);
         if (pod) {
           if (options.sh) return pbcopy(`sudo kubectl exec -it ${pod.NAME} -- sh`);
           if (options.logs) return shellExec(`sudo kubectl logs -f ${pod.NAME}`);
@@ -104,7 +103,7 @@ class UnderpostTest {
                 break;
             }
           else {
-            const pods = UnderpostDeploy.API.get(deployId);
+            const pods = Underpost.deploy.get(deployId);
             if (pods.length > 0)
               for (const deployData of pods) {
                 const { NAME } = deployData;
@@ -115,7 +114,7 @@ class UnderpostTest {
             else logger.warn(`Couldn't find pods in deployment`, { deployId });
           }
         }
-      } else return UnderpostTest.API.run();
+      } else return Underpost.test.run();
     },
     /**
      * @method statusMonitor
@@ -134,7 +133,7 @@ class UnderpostTest {
         logger.info(`Loading instance`, { podName, status, kindType, deltaMs, maxAttempts });
         const _monitor = async () => {
           await timer(deltaMs);
-          const pods = UnderpostDeploy.API.get(podName, kindType);
+          const pods = Underpost.deploy.get(podName, kindType);
           let result = pods.find((p) => p.STATUS === status || (status === 'Running' && p.STATUS === 'Completed'));
           logger.info(
             `Testing pod ${podName}... ${result ? 1 : 0}/1 - elapsed time ${deltaMs * (index + 1)}s - attempt ${

package/src/client/components/core/Content.js

@@ -8,50 +8,50 @@ import { DocumentService } from '../../services/document/document.service.js';
 import { CoreService, getApiBaseUrl, headersFactory } from '../../services/core/core.service.js';
 import { loggerFactory } from './Logger.js';
 import { imageShimmer, renderChessPattern, renderCssAttr, styleFactory } from './Css.js';
-import { getQueryParams } from './Router.js';
+import { getQueryParams, setPath } from './Router.js';
 
 const logger = loggerFactory(import.meta);
 
 const attachMarkdownLinkHandlers = (containerSelector) => {
-  const links = sa(`${containerSelector} a[href]`);
-  links.forEach((link) => {
-    link.addEventListener('click', async (e) => {
-      e.preventDefault();
-      const href = link.getAttribute('href');
-
-      // Check if link is external
-      const isExternal = href.startsWith('http://') || href.startsWith('https://');
-
-      if (isExternal) {
-        // Show warning modal for external links
-        const result = await Modal.RenderConfirm({
-          id: `external-link-${s4()}`,
-          html: async () => html`
-            <div class="in section-mp" style="text-align: center; padding: 20px;">
-              <p>${Translate.Render('external-link-warning')}</p>
-              <p style="word-break: break-all; margin-top: 10px;"><strong>${href}</strong></p>
-            </div>
-          `,
-          icon: html`<i class="fas fa-external-link-alt"></i>`,
-          style: {
-            width: '350px',
-            height: '500px',
-            overflow: 'auto',
-            'z-index': '11',
-            resize: 'none',
-          },
-        });
-
-        // Only open link if user confirmed (not cancelled or closed)
-        if (result && result.status === 'confirm') {
-          window.open(href, '_blank', 'noopener,noreferrer');
-        }
-        // If cancelled, do nothing - don't navigate
-      } else {
-        // Internal link - navigate normally
-        window.location.href = href;
+  const container = s(containerSelector);
+  if (!container || container.dataset.mdLinkHandler) return;
+  container.dataset.mdLinkHandler = 'true';
+
+  container.addEventListener('click', async (e) => {
+    const link = e.target.closest('.markdown-content a[href]');
+    if (!link) return;
+
+    const href = link.getAttribute('href');
+    if (!href || href.startsWith('#')) return;
+
+    e.preventDefault();
+    const isExternal = href.startsWith('http://') || href.startsWith('https://');
+
+    if (isExternal) {
+      const result = await Modal.RenderConfirm({
+        id: `external-link-${s4()}`,
+        html: async () => html`
+          <div class="in section-mp" style="text-align: center; padding: 20px;">
+            <p>${Translate.Render('external-link-warning')}</p>
+            <p style="word-break: break-all; margin-top: 10px;"><strong>${href}</strong></p>
+          </div>
+        `,
+        icon: html`<i class="fas fa-external-link-alt"></i>`,
+        style: {
+          width: '350px',
+          height: '500px',
+          overflow: 'auto',
+          'z-index': '11',
+          resize: 'none',
+        },
+      });
+
+      if (result && result.status === 'confirm') {
+        window.open(href, '_blank', 'noopener,noreferrer');
       }
-    });
+    } else {
+      setPath(href);
+    }
   });
 };
 
@@ -214,7 +214,9 @@ const Content = {
         case 'md':
           {
             const content = await Content.getFileContent(file, options);
-            render += html`<div class="${options.class}" ${styleFactory(options.style)}>${marked.parse(content)}</div>`;
+            render += html`<div class="${options.class} markdown-content" ${styleFactory(options.style)}>
+              ${marked.parse(content)}
+            </div>`;
           }
           break;
 

package/src/client/components/core/FullScreen.js

@@ -1,31 +1,224 @@
+/**
+ * Utility module for fullscreen mode management with cross-browser and PWA compatibility.
+ * Provides robust fullscreen detection, event handling, and UI synchronization.
+ * @module src/client/components/core/FullScreen.js
+ * @namespace FullScreenClient
+ */
+
 import { Responsive } from './Responsive.js';
 import { ToggleSwitch } from './ToggleSwitch.js';
 import { Translate } from './Translate.js';
 import { checkFullScreen, fullScreenIn, fullScreenOut, s } from './VanillaJs.js';
 
+/**
+ * Manages fullscreen mode state, event handling, and UI synchronization.
+ * Supports all major browsers and PWA/Nativefier environments with comprehensive
+ * vendor-prefixed API detection.
+ * @memberof FullScreenClient
+ */
 const FullScreen = {
+  /**
+   * Internal state flag tracking the intended fullscreen mode.
+   * @type {boolean}
+   * @private
+   */
+  _fullScreenSwitch: false,
+
+  /**
+   * Flag indicating whether event listeners have been attached.
+   * Prevents duplicate event listener registration.
+   * @type {boolean}
+   * @private
+   */
+  _eventListenersAdded: false,
+
+  /**
+   * Flag preventing concurrent sync operations.
+   * Ensures state synchronization happens sequentially.
+   * @type {boolean}
+   * @private
+   */
+  _syncInProgress: false,
+
+  /**
+   * Checks if the browser is currently in fullscreen mode.
+   * Supports all vendor-prefixed fullscreen APIs for maximum compatibility:
+   * - Standard Fullscreen API
+   * - Webkit (Chrome, Safari, Opera)
+   * - Mozilla (Firefox)
+   * - Microsoft (IE/Edge)
+   * @private
+   * @memberof FullScreenClient.FullScreen
+   * @returns {boolean} True if currently in fullscreen mode, false otherwise.
+   */
+  _isFullScreen: function () {
+    return !!(
+      document.fullscreenElement ||
+      document.webkitFullscreenElement ||
+      document.mozFullScreenElement ||
+      document.msFullscreenElement ||
+      document.fullscreen ||
+      document.webkitIsFullScreen ||
+      document.mozFullScreen
+    );
+  },
+
+  /**
+   * Synchronizes the toggle switch UI state with the actual fullscreen state.
+   * Prevents race conditions using the _syncInProgress flag.
+   * Updates the toggle switch only if there's a mismatch between UI and actual state.
+   * @private
+   * @memberof FullScreenClient.FullScreen
+   * @returns {void}
+   */
+  _syncToggleState: function () {
+    if (this._syncInProgress) return;
+    this._syncInProgress = true;
+
+    const actualFullScreen = this._isFullScreen();
+
+    // Only update if there's a mismatch
+    if (this._fullScreenSwitch !== actualFullScreen) {
+      this._fullScreenSwitch = actualFullScreen;
+
+      // Update toggle switch UI if it exists
+      const toggle = s('.fullscreen');
+      if (toggle && ToggleSwitch.Tokens[`fullscreen`]) {
+        const switchState = ToggleSwitch.Tokens[`fullscreen`].checked;
+        if (switchState !== actualFullScreen) {
+          ToggleSwitch.Tokens[`fullscreen`].click();
+        }
+      }
+    }
+
+    setTimeout(() => {
+      this._syncInProgress = false;
+    }, 100);
+  },
+
+  /**
+   * Event handler for fullscreen change events.
+   * Triggers UI state synchronization when fullscreen mode changes.
+   * @private
+   * @memberof FullScreenClient.FullScreen
+   * @returns {void}
+   */
+  _handleFullScreenChange: function () {
+    this._syncToggleState();
+  },
+
+  /**
+   * Attaches all necessary event listeners for fullscreen mode detection.
+   * Handles multiple scenarios:
+   * - Vendor-prefixed fullscreen change events (Chrome, Firefox, IE/Edge)
+   * - Window resize events (for PWA/Nativefier compatibility)
+   * - ESC key detection (fallback for manual fullscreen exit)
+   * Only attaches listeners once to prevent duplicates.
+   * @private
+   * @memberof FullScreenClient.FullScreen
+   * @returns {void}
+   */
+  _addEventListeners: function () {
+    if (this._eventListenersAdded) return;
+
+    const events = ['fullscreenchange', 'webkitfullscreenchange', 'mozfullscreenchange', 'MSFullscreenChange'];
+
+    events.forEach((eventName) => {
+      document.addEventListener(eventName, () => this._handleFullScreenChange(), false);
+    });
+
+    // Additional check for PWA/Nativefier window resize events
+    window.addEventListener(
+      'resize',
+      () => {
+        setTimeout(() => this._syncToggleState(), 150);
+      },
+      false,
+    );
+
+    // ESC key detection fallback
+    document.addEventListener(
+      'keydown',
+      (e) => {
+        if (e.key === 'Escape' || e.keyCode === 27) {
+          setTimeout(() => this._syncToggleState(), 100);
+        }
+      },
+      false,
+    );
+
+    this._eventListenersAdded = true;
+  },
+
+  /**
+   * Enters fullscreen mode if not already in fullscreen.
+   * Updates internal state and triggers fullscreen API.
+   * Verifies the state change after a delay to ensure synchronization.
+   * @private
+   * @memberof FullScreenClient.FullScreen
+   * @returns {void}
+   */
+  _enterFullScreen: function () {
+    if (this._isFullScreen()) return;
+
+    this._fullScreenSwitch = true;
+    fullScreenIn();
+
+    // Verify after attempt
+    setTimeout(() => this._syncToggleState(), 300);
+  },
+
+  /**
+   * Exits fullscreen mode if currently in fullscreen.
+   * Updates internal state and triggers fullscreen exit API.
+   * Verifies the state change after a delay to ensure synchronization.
+   * @private
+   * @memberof FullScreenClient.FullScreen
+   * @returns {void}
+   */
+  _exitFullScreen: function () {
+    if (!this._isFullScreen()) return;
+
+    this._fullScreenSwitch = false;
+    fullScreenOut();
+
+    // Verify after attempt
+    setTimeout(() => this._syncToggleState(), 300);
+  },
+
+  /**
+   * Renders the fullscreen toggle setting UI component.
+   * Initializes fullscreen state detection, sets up event listeners,
+   * and creates a toggle switch for user interaction.
+   * Integrates with the Responsive system for dynamic updates.
+   * @memberof FullScreenClient.FullScreen
+   * @returns {Promise<string>} A promise resolving to the HTML string for the fullscreen setting component.
+   */
   RenderSetting: async function () {
-    let fullScreenSwitch = checkFullScreen();
+    // Initialize state from actual fullscreen status
+    this._fullScreenSwitch = this._isFullScreen();
+
+    // Setup event listeners once
+    this._addEventListeners();
+
+    // Update responsive event
     Responsive.Event['full-screen-settings'] = () => {
-      let fullScreenMode = checkFullScreen();
-      if ((fullScreenSwitch && !fullScreenMode) || (!fullScreenSwitch && fullScreenMode))
-        if (s('.fullscreen')) ToggleSwitch.Tokens[`fullscreen`].click();
+      this._syncToggleState();
     };
+
     return html`<div class="in section-mp">
       ${await ToggleSwitch.Render({
         wrapper: true,
         wrapperLabel: html`<i class="fa-solid fa-expand"></i> ${Translate.Render('fullscreen')}`,
         id: 'fullscreen',
         disabledOnClick: true,
-        checked: fullScreenSwitch,
+        checked: this._fullScreenSwitch,
         on: {
           unchecked: () => {
-            fullScreenSwitch = false;
-            if (checkFullScreen()) fullScreenOut();
+            this._exitFullScreen();
           },
           checked: () => {
-            fullScreenSwitch = true;
-            if (!checkFullScreen()) fullScreenIn();
+            this._enterFullScreen();
           },
         },
       })}

package/src/client/components/core/PanelForm.js

@@ -455,7 +455,9 @@ const PanelForm = {
 
             const baseNewDoc = newInstance(data);
             baseNewDoc.tags = tags.filter((t) => !prefixTags.includes(t));
-            baseNewDoc.mdFileId = hasMdContent ? marked.parse(data.mdFileId) : null;
+            baseNewDoc.mdFileId = hasMdContent
+              ? `<div class="markdown-content">${marked.parse(data.mdFileId)}</div>`
+              : null;
             baseNewDoc.userId = Elements.Data.user?.main?.model?.user?._id;
 
             // Ensure profileImageId is properly formatted as object with _id property
@@ -677,7 +679,7 @@ const PanelForm = {
                     mdPlain = await blobArray[0].text();
                     // Parse markdown with proper error handling
                     try {
-                      parsedMarkdown = mdPlain ? marked.parse(mdPlain) : '';
+                      parsedMarkdown = mdPlain ? `<div class="markdown-content">${marked.parse(mdPlain)}</div>` : '';
                     } catch (parseError) {
                       logger.error('Error parsing markdown for document:', documentObject._id, parseError);
                       parsedMarkdown = `<p><strong>Error rendering markdown:</strong> ${parseError.message}</p>`;