mnfst-render 0.5.7 → 0.5.10

package/bin/mnfst-render.js

@@ -1,2 +1,7 @@
 #!/usr/bin/env node
-import '../manifest.render.mjs';
+import { main } from '../manifest.render.mjs';
+
+main().catch((err) => {
+  console.error('prerender:', err);
+  process.exit(1);
+});

package/manifest.render.mjs

@@ -248,9 +248,9 @@ function resolveConfig() {
     debugPrerender: !!cli.debugPrerender,
     // 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.  Lowered from 25000 — the earlier settle
-    // waits already give plugins enough time to finish.
-    pipelineTimeout: 6000,
+    // fall back to the timeout.  10s gives slow data plugin pipelines a
+    // chance while bounding worst-case per-path overhead.
+    pipelineTimeout: 10000,
   };
 }
 
@@ -980,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">`;
   });
 }
 
@@ -2028,21 +2033,27 @@ async function runPrerender(config) {
         timeout: Math.min(timeout, 30000),
       });
 
-      // Belt-and-suspenders settle waits.  Each one is bounded short because
-      // the authoritative `manifest:render-ready` wait below is what we really
-      // rely on.  These earlier waits exist as fallbacks for projects whose
-      // data plugins don't dispatch the modern signal — but they shouldn't
-      // dominate per-path runtime when they DO time out.
+      // 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, 1500); // was 6000
+            const t = setTimeout(done, 3000);
             window.addEventListener(
               'manifest:routing-ready',
               () => {
                 clearTimeout(t);
-                setTimeout(done, 500); // was 2000
+                setTimeout(done, 1000);
               },
               { once: true }
             );
@@ -2052,12 +2063,13 @@ async function runPrerender(config) {
       ]).catch(() => { });
 
       // Ensure the dynamic loader has injected at least one plugin script.
-      // In practice this happens within ~100ms; the 1500ms cap is generous.
+      // 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() + 1500; // was 5000
+          const deadline = Date.now() + 3000;
           const t = setInterval(() => {
             if (check() || Date.now() >= deadline) {
               clearInterval(t);
@@ -2067,21 +2079,21 @@ async function runPrerender(config) {
         });
       }).catch(() => { });
 
-      // Network idle: shorter idle window + shorter cap.  Most plugin scripts
-      // and data fetches complete in under 2s on a healthy local server.
-      await page.waitForNetworkIdle({ idleTime: 800, timeout: 4000 }).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: 300ms quiet window is plenty after networkIdle has
-      // already drained pending fetches.
+      // DOM stability after network idle.
       await page.evaluate(() => {
         return new Promise((resolve) => {
           const observer = new MutationObserver(() => {
             clearTimeout(stable);
-            stable = setTimeout(finish, 300); // was 800
+            stable = setTimeout(finish, 500);
           });
           observer.observe(document.documentElement, { childList: true, subtree: true, characterData: true });
           const finish = () => { observer.disconnect(); resolve(); };
-          let stable = setTimeout(finish, 300); // was 800
+          let stable = setTimeout(finish, 500);
         });
       }).catch(() => { });
 
@@ -3030,7 +3042,24 @@ async function runPrerender(config) {
 
 }
 
-main().catch((err) => {
-  console.error('prerender:', err);
-  process.exit(1);
-});
+// Auto-run main() when this file is the direct entry point (node manifest.render.mjs)
+// but NOT when imported by the bin wrapper or test harness.  The bin wrapper
+// calls main() explicitly; test harnesses only need the exported helpers.
+const _isDirectEntry = (() => {
+  try {
+    const arg1 = process.argv[1];
+    if (!arg1) return false;
+    const invoked = String(new URL('file://' + resolve(arg1)));
+    return invoked === import.meta.url;
+  } catch { return false; }
+})();
+
+if (_isDirectEntry) {
+  main().catch((err) => {
+    console.error('prerender:', err);
+    process.exit(1);
+  });
+}
+
+// Exports for the CLI bin script and for unit testing.
+export { main, markPrerenderedManifestComponents };

package/package.json

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