mnfst-render 0.5.31 → 0.5.33

package/manifest.render.mjs

@@ -2,7 +2,7 @@
 
 /* Manifest Render */
 
-import { readFileSync, readSync, mkdirSync, writeFileSync, existsSync, rmSync, statSync, readdirSync, cpSync, unlinkSync } from 'node:fs';
+import { readFileSync, readSync, mkdirSync, writeFileSync, existsSync, rmSync, statSync, readdirSync, cpSync, unlinkSync, renameSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { join, resolve, dirname, relative, basename, sep } from 'node:path';
 import { createServer } from 'node:http';
@@ -1811,9 +1811,15 @@ function computeGlobalAssetSignature(rootDir) {
  *   - html.className (theme variant: light/dark/etc.)
  */
 async function takeOgSnapshot(page, outputDir, pathSeg, globalAssetSignature, cacheDir) {
-  const fileSeg = pathSeg === '' || pathSeg === '__404__'
+  // The 404 page must NOT share the homepage's 'index' slug: both pages render
+  // concurrently and would otherwise race on the same og/index.png + cache
+  // files. The 404 (route hidden, near-empty body) screenshots blank, and that
+  // blank would clobber — or get mis-read as — the homepage's real snapshot.
+  const fileSeg = pathSeg === ''
     ? 'index'
-    : pathSeg.replace(/\//g, '-').replace(/[^a-zA-Z0-9_-]/g, '_');
+    : pathSeg === '__404__'
+      ? '404'
+      : pathSeg.replace(/\//g, '-').replace(/[^a-zA-Z0-9_-]/g, '_');
   const ogDir = join(outputDir, 'og');
   try { mkdirSync(ogDir, { recursive: true }); } catch { /* exists */ }
   const filePath = join(ogDir, `${fileSeg}.png`);
@@ -1822,6 +1828,16 @@ async function takeOgSnapshot(page, outputDir, pathSeg, globalAssetSignature, ca
   const cachePngPath = cacheDir ? join(cacheDir, `${fileSeg}.png`) : null;
   const cacheHashPath = cacheDir ? join(cacheDir, `${fileSeg}.hash`) : null;
 
+  // Restore the last good cached PNG into the output dir. Used whenever a fresh
+  // snapshot can't be produced (error or blank result) so a transient failure
+  // never leaves the page with no OG image — and never destroys the prior.
+  const restoreFromCache = () => {
+    if (cachePngPath && existsSync(cachePngPath)) {
+      try { cpSync(cachePngPath, filePath); return `/og/${fileSeg}.png`; } catch { /* ignore */ }
+    }
+    return null;
+  };
+
   // Cache lookup: fingerprint the rendered DOM and check against the stored
   // hash.  The fingerprint normalises away attribute values assigned in
   // iteration order (data-hydrate-id, data-component-N) and randomly-generated
@@ -1885,11 +1901,12 @@ async function takeOgSnapshot(page, outputDir, pathSeg, globalAssetSignature, ca
     try {
       const sz = statSync(filePath).size;
       if (sz < 15 * 1024) {
-        unlinkSync(filePath);
-        // Drop the cache too so the next run doesn't trust it.
-        if (cachePngPath) { try { unlinkSync(cachePngPath); } catch { /* missing is fine */ } }
-        if (cacheHashPath) { try { unlinkSync(cacheHashPath); } catch { /* missing is fine */ } }
-        return null;
+        // Blank/header-only snapshot — don't trust it, but don't destroy the
+        // good cached prior either (a transient blank must not wipe a real
+        // image). Drop the blank output and restore the last good cached PNG;
+        // if there's no cache, fall through to other og:image sources.
+        try { unlinkSync(filePath); } catch { /* missing is fine */ }
+        return restoreFromCache();
       }
     } catch { /* stat failure is non-fatal */ }
     // Populate the cache: copy the fresh PNG into the cache dir and write the
@@ -1903,10 +1920,12 @@ async function takeOgSnapshot(page, outputDir, pathSeg, globalAssetSignature, ca
     }
     return `/og/${fileSeg}.png`;
   } catch (e) {
-    // Failures here are non-fatal — fall back to whatever other og:image source
-    // is available (manifest icon, first content <img>, etc.).
+    // Failures here are non-fatal and must be non-destructive: prefer the last
+    // good cached PNG (restored into the output) over leaving the page with no
+    // OG image. Only if there's no cache do we fall through to other og:image
+    // sources (manifest icon, first content <img>, etc.).
     console.error(`prerender: og snapshot failed for /${pathSeg || ''}: ${e?.message || e}`);
-    return null;
+    return restoreFromCache();
   }
 }
 
@@ -2101,6 +2120,10 @@ async function injectMetaInDom(page, ctx) {
       } else if (typeof expr === 'boolean' || typeof expr === 'number') {
         return String(expr);
       }
+      // Image only: the per-page auto-snapshot outranks the generic static
+      // fallback.image — it depicts this exact page and is sized for OG cards.
+      // The fallback then only applies to pages with no snapshot.
+      if (key === 'image' && ctx.snapshotUrl) return ctx.snapshotUrl;
       // Layer 4: explicit fallback
       const fallback = exprMap.fallback?.[key];
       if (fallback) return String(fallback);
@@ -2989,7 +3012,7 @@ async function runPrerender(config) {
     return;
   }
 
-  const outputResolved = resolve(config.output);
+  const finalOutput = resolve(config.output);
   const rootResolved = resolve(config.root);
   // Router base = URL pathname to the app root. When dist is deployed as site root (e.g. Appwrite), use "".
   // Set manifest.prerender.routerBase only when the app is served from a subpath (e.g. /app).
@@ -3001,11 +3024,27 @@ async function runPrerender(config) {
     routerBasePath = '';
   }
 
-  if (existsSync(outputResolved)) {
-    rmSync(outputResolved, { recursive: true });
+  // Atomic output: build into a sibling staging dir, then swap it into place
+  // only after every step below succeeds (see the end of this function). A
+  // crashed or interrupted render therefore never leaves a half-written or empty
+  // output dir for mnfst-publish to ship — the previous good build stays put
+  // until the new one is complete.
+  const stagingOutput = finalOutput + '.mnfst-staging';
+  if (existsSync(stagingOutput)) rmSync(stagingOutput, { recursive: true });
+  mkdirSync(stagingOutput, { recursive: true });
+  // Redirect ALL downstream writes (both config.output and outputResolved) to
+  // the staging dir for the remainder of the build.
+  config.output = stagingOutput;
+  const outputResolved = stagingOutput;
+  // Don't copy the previous build (the final output dir) into staging — only the
+  // staging dir's own basename is excluded by copyProjectIntoDist.
+  const finalBasename = basename(finalOutput);
+  COPY_EXCLUDE.add(finalBasename);
+  try {
+    copyProjectIntoDist(rootResolved, outputResolved);
+  } finally {
+    COPY_EXCLUDE.delete(finalBasename);
   }
-  mkdirSync(outputResolved, { recursive: true });
-  copyProjectIntoDist(rootResolved, outputResolved);
   // Env placeholders (${VAR}) only resolve at runtime via window.env (populated
   // by the mnfst-run dev server from .env). A static prod build has no
   // window.env, so any ${VAR} left in the shipped manifest.json stays literal
@@ -3418,8 +3457,13 @@ async function runPrerender(config) {
       // by data-head, prerender.meta config, or an explicit fallback.
       let earlySnapshotUrl = null;
       if (config.seo.imageSnapshots) {
+        // Only an EXPLICIT per-page image suppresses the auto-snapshot:
+        // prerender.meta.image (a config expression) or an og:image already in
+        // the head (data-head / index.html).  A generic prerender.meta.fallback
+        // .image must NOT skip it — the per-page snapshot is the primary image
+        // and the static fallback is only used when a snapshot isn't available
+        // (see resolve('image') in injectMetaInDom).
         const ogImageHandled = !!config.seo.meta?.image
-          || !!config.seo.meta?.fallback?.image
           || await page.evaluate(() => !!document.head.querySelector('meta[property="og:image"]'));
         if (!ogImageHandled) {
           earlySnapshotUrl = await takeOgSnapshot(page, config.output, is404 ? '__404__' : pathSeg, globalAssetSig, ogCacheDir);
@@ -4593,6 +4637,12 @@ async function runPrerender(config) {
     writeFileSync(join(config.output, '_redirects'), lines.join('\n'), 'utf8');
   }
 
+  // Atomic swap: replace the previous output with the freshly built staging dir.
+  // rename() is atomic on the same filesystem (staging is a sibling of output),
+  // so a consumer never sees a partially written output directory.
+  if (existsSync(finalOutput)) rmSync(finalOutput, { recursive: true });
+  renameSync(stagingOutput, finalOutput);
+  config.output = finalOutput;
 }
 
 // Auto-run main() when this file is the direct entry point (node manifest.render.mjs)

package/package.json

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