mnfst-render 0.5.6 → 0.5.9

package/manifest.render.mjs

@@ -150,11 +150,11 @@ async function waitForManifestRenderReady(page, { allLocales, currentLocale, tim
     )
     .catch((e) => ({ ok: false, reason: 'evaluate', message: String(e) }));
 
-  if (!result?.ok) {
-    const parts = [`prerender: render-ready wait incomplete (${result?.reason ?? 'unknown'})`];
-    if (result?.message) parts.push(result.message);
-    process.stdout.write(`${parts.join('; ')}\n`);
-  }
+  // Note: render-ready wait timeouts are silently tolerated.  Earlier versions
+  // logged a warning per path, but it fires on essentially every route in
+  // projects whose data plugins don't dispatch `manifest:render-ready` (i.e.
+  // most of them), drowning the terminal in noise.  The fallback timeout is
+  // intentional and benign — the DOM is still captured.
 }
 
 // --- Config ------------------------------------------------------------------
@@ -246,7 +246,11 @@ function resolveConfig() {
       : [],
     dryRun: !!cli.dryRun,
     debugPrerender: !!cli.debugPrerender,
-    pipelineTimeout: 25000,
+    // Cap on the manifest:render-ready wait.  When the data plugin dispatches
+    // the event, we resolve immediately; when it doesn't (most projects), we
+    // fall back to the timeout.  10s gives slow data plugin pipelines a
+    // chance while bounding worst-case per-path overhead.
+    pipelineTimeout: 10000,
   };
 }
 
@@ -976,8 +980,13 @@ function markPrerenderedManifestComponents(html) {
     // the runtime restoration reinstate the <x-*> tag and the components
     // plugin processes it normally on load.
     if (/\bdata-hydrate\b/i.test(a)) return full;
-    const spacer = /\S/.test(a) ? ' ' : '';
-    return `<${tag}${a}${spacer}data-pre-rendered="1">`;
+    // CRITICAL: always insert a leading space before the injected attribute.
+    // For tags with no existing attributes (e.g. `<x-sidebar>`), `a` is empty
+    // and concatenating directly produces `<x-sidebardata-pre-rendered=...>`,
+    // which mangles the tag name and prevents the components plugin from
+    // recognising it.  The trailing-space normalisation on `a` keeps the
+    // output tidy when there ARE existing attributes.
+    return `<${tag}${a.replace(/\s+$/, '')} data-pre-rendered="1">`;
   });
 }
 
@@ -2024,16 +2033,27 @@ async function runPrerender(config) {
         timeout: Math.min(timeout, 30000),
       });
 
+      // Settle waits.  These give Manifest plugins (especially the components
+      // plugin, which lazy-fetches each component HTML over the network) time
+      // to finish loading and expanding everything before we snapshot.  Each
+      // wait is bounded; large projects with many components need the full
+      // budget on cold runs, but small projects settle long before the cap.
+      //
+      // Lowered from the original "any wait could hold the prerender for ~50s
+      // per path" defaults, but kept generous enough that Playcom-scale sites
+      // (~10 preloaded components, dozens of lazy components) actually finish
+      // expanding before snapshot.  Earlier reductions were too aggressive and
+      // left unexpanded `<x-*>` placeholders in the output.
       await Promise.race([
         page.evaluate(() => {
           return new Promise((resolve) => {
             const done = () => resolve();
-            const t = setTimeout(done, 6000);
+            const t = setTimeout(done, 3000);
             window.addEventListener(
               'manifest:routing-ready',
               () => {
                 clearTimeout(t);
-                setTimeout(done, 2000);
+                setTimeout(done, 1000);
               },
               { once: true }
             );
@@ -2042,13 +2062,14 @@ async function runPrerender(config) {
         new Promise((_, rej) => setTimeout(() => rej(new Error('ready timeout')), timeout)),
       ]).catch(() => { });
 
-      // Ensure manifest.min.js (dynamic loader) has run and injected plugin scripts before snapshot.
-      // Static output still runs the loader and Alpine; we just capture the DOM after they've set up.
+      // Ensure the dynamic loader has injected at least one plugin script.
+      // In practice this happens within ~100ms but allow up to 3s for cold
+      // CDN cache or slow disk.
       await page.evaluate(() => {
         return new Promise((resolve) => {
           const check = () => document.querySelectorAll('script[src*="manifest"]').length >= 2;
           if (check()) return resolve();
-          const deadline = Date.now() + 5000;
+          const deadline = Date.now() + 3000;
           const t = setInterval(() => {
             if (check() || Date.now() >= deadline) {
               clearInterval(t);
@@ -2058,19 +2079,21 @@ async function runPrerender(config) {
         });
       }).catch(() => { });
 
-      await page.waitForNetworkIdle({ idleTime: 1500, timeout: 10000 }).catch(() => { });
+      // Network idle: drain pending fetches (component templates, data sources,
+      // markdown files, icon SVGs).  Larger projects need the full window;
+      // small ones settle in well under 1 second.
+      await page.waitForNetworkIdle({ idleTime: 1000, timeout: 8000 }).catch(() => { });
 
+      // DOM stability after network idle.
       await page.evaluate(() => {
         return new Promise((resolve) => {
           const observer = new MutationObserver(() => {
             clearTimeout(stable);
-            stable = setTimeout(resolve, 800);
+            stable = setTimeout(finish, 500);
           });
           observer.observe(document.documentElement, { childList: true, subtree: true, characterData: true });
-          let stable = setTimeout(() => {
-            observer.disconnect();
-            resolve();
-          }, 800);
+          const finish = () => { observer.disconnect(); resolve(); };
+          let stable = setTimeout(finish, 500);
         });
       }).catch(() => { });
 
@@ -3019,7 +3042,25 @@ async function runPrerender(config) {
 
 }
 
-main().catch((err) => {
-  console.error('prerender:', err);
-  process.exit(1);
-});
+// Only run main() when invoked as the CLI entry point — this lets tests
+// import this module to access internal helpers (e.g.
+// markPrerenderedManifestComponents) without triggering a full prerender.
+const isCliEntry = (() => {
+  try {
+    const invoked = process.argv[1] && new URL('file://' + process.argv[1]).href;
+    return invoked === import.meta.url;
+  } catch {
+    return false;
+  }
+})();
+
+if (isCliEntry) {
+  main().catch((err) => {
+    console.error('prerender:', err);
+    process.exit(1);
+  });
+}
+
+// Exports for unit testing.  These are intentionally not part of any public
+// API — they exist so the e2e harness can directly exercise pure helpers.
+export { markPrerenderedManifestComponents };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mnfst-render",
-  "version": "0.5.6",
+  "version": "0.5.9",
   "description": "Render Manifest sites to static HTML for SEO",
   "type": "module",
   "bin": {