@koehler8/cms 1.0.0-beta.36 → 1.0.0-beta.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koehler8/cms",
-  "version": "1.0.0-beta.36",
+  "version": "1.0.0-beta.38",
   "description": "Vertex CMS — lightweight, config-driven Vue 3 framework with theming, extensions, and SSG support",
   "license": "MIT",
   "type": "module",

package/scripts/ssg-build/findEmptyRenders.mjs

@@ -0,0 +1,42 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+
+// Detect a page whose root container never mounted any real markup — just
+// Vue's SSR placeholder comment for "nothing rendered here". This is the
+// signature of a rare, silent failure in the onServerPrefetch data-fetch
+// path: @vue/server-renderer's renderComponentVNode gates a component's
+// render on `Promise.all(prefetches).catch(NOOP)` (see server-renderer.cjs.js
+// in any consuming site's node_modules) — if that promise ever rejects, the
+// renderer swallows the error entirely and renders anyway, using whatever
+// default/empty state the component held. No warning, no non-zero exit —
+// just well-formed, blank HTML on disk. A real page from this framework is
+// never legitimately empty (Home.vue always renders at least the skip-link +
+// <main>, DraftGate renders a dialog, 404 renders NotFound), so any match
+// here is unconditionally a bug. Kept in its own module (no side effects on
+// import) so it's unit-testable without tripping index.mjs's top-level
+// main() invocation — see bin/cms-ssg-build.js.
+const EMPTY_ROOT_RE = /<div id="[^"]+"[^>]*>\s*<!---->\s*<\/div>/;
+
+export async function findEmptyRenders(dir) {
+  const empties = [];
+  let entries;
+  try {
+    entries = await fsp.readdir(dir, { recursive: true });
+  } catch {
+    return empties;
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith('index.html')) continue;
+    const full = path.join(dir, entry);
+    let html;
+    try {
+      html = await fsp.readFile(full, 'utf8');
+    } catch {
+      continue;
+    }
+    if (EMPTY_ROOT_RE.test(html)) {
+      empties.push(full);
+    }
+  }
+  return empties;
+}

package/scripts/ssg-build/index.mjs

@@ -26,6 +26,7 @@ import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
+import { findEmptyRenders } from './findEmptyRenders.mjs';
 
 const CWD = process.cwd();
 const TAG = '[cms-ssg-build]';
@@ -157,6 +158,14 @@ async function main() {
     console.log(`${TAG} ~${estRoutes} routes ≤ shard size ${opts.shardSize}: running a single vite-ssg build (no sharding needed).`);
     const r = await runViteSsg({ heap: opts.heap, passthrough: opts.passthrough });
     process.stdout.write(r.out);
+    if (r.code === 0) {
+      const empties = await findEmptyRenders(path.join(CWD, 'dist'));
+      if (empties.length) {
+        console.error(`${TAG} build succeeded but ${empties.length} page(s) rendered with an empty body — a known intermittent SSR race (see findEmptyRenders in this file). Re-run the build:`);
+        for (const f of empties) console.error(`${TAG}   - ${f}`);
+        process.exit(1);
+      }
+    }
     process.exit(r.code);
   }
 
@@ -175,7 +184,20 @@ async function main() {
     const started = Date.now();
     process.stdout.write(`${TAG} shard ${s.k + 1}/${N} rendering…\n`);
     const r = await runViteSsg({ shard: `${s.k}/${N}`, outDir: s.outDir, heap: opts.heap, passthrough: opts.passthrough });
-    process.stdout.write(`${TAG} shard ${s.k + 1}/${N} ${r.code === 0 ? 'ok' : 'FAILED'} (${((Date.now() - started) / 1000).toFixed(1)}s)\n`);
+    let empties = [];
+    if (r.code === 0) {
+      empties = await findEmptyRenders(path.join(CWD, s.outDir));
+    }
+    const ok = r.code === 0 && empties.length === 0;
+    process.stdout.write(`${TAG} shard ${s.k + 1}/${N} ${ok ? 'ok' : 'FAILED'} (${((Date.now() - started) / 1000).toFixed(1)}s)\n`);
+    if (empties.length) {
+      return {
+        ...r,
+        code: 1,
+        out: `${r.out}\n${TAG} ${empties.length} page(s) rendered with an empty body — a known intermittent SSR race (see findEmptyRenders in this file):\n${empties.map((f) => `  - ${f}`).join('\n')}\n`,
+        k: s.k,
+      };
+    }
     return { ...r, k: s.k };
   });
 

package/src/main.js

@@ -135,6 +135,21 @@ export function createCmsApp() {
       };
 
       const extractCurrentRoute = () => {
+        // During SSG, vite-ssg passes the route being pre-rendered as a string
+        // on `ctx.routePath` and only pushes the router AFTER this setup fn runs
+        // — so `router.currentRoute` is still vue-router's START_LOCATION ('/')
+        // here, identically on every page. Resolve `routePath` through the router
+        // (a pure match, no navigation) to recover the real path + `params.locale`.
+        // Without this, `resolveCurrentPageId` sees '/' for every route, so the
+        // payload trim targets the wrong page — or, when '/' is ambiguous, none.
+        const routePath = ctx?.routePath;
+        if (typeof routePath === 'string' && routePath) {
+          try {
+            return router.resolve(routePath);
+          } catch {
+            return { path: routePath, params: {} };
+          }
+        }
         if (ctx?.route) {
           return ctx.route;
         }

package/src/utils/loadConfig.js

@@ -70,8 +70,24 @@ export function resolvePageIdForRoute(config, routePath, localeParam) {
         (typeof p === 'string' ? p : '/').replace(/\/+/g, '/').replace(/\/+$/, '') || '/';
     target = normalize(target);
     const pages = (config && config.pages) || {};
-    const matches = Object.entries(pages).filter(([, data]) => {
-        const pagePath = data && typeof data.path === 'string' && data.path.trim() ? data.path : '/';
+
+    // The SSG pre-renders `/404` from a site's custom `pages/404.json` (mirrors
+    // usePageConfig.selectPage's `/404` → `404` mapping). That page is
+    // conventionally path-less, so it can't be matched by `path` below — map the
+    // route to it directly. It is also deliberately NOT treated as living at `/`
+    // (see the id === '404' guard in the matcher) so it never collides with
+    // `home` there — the collision that otherwise makes `/` ambiguous on any
+    // site shipping a custom 404 page, suppressing the home-page trim.
+    const notFound = pages['404'];
+    const notFoundPathless = notFound && !(typeof notFound.path === 'string' && notFound.path.trim());
+    if (target === '/404' && notFoundPathless) return '404';
+
+    const matches = Object.entries(pages).filter(([id, data]) => {
+        const hasPath = data && typeof data.path === 'string' && data.path.trim();
+        // A page with no explicit `path` conventionally lives at `/` (home). The
+        // SSG-only `404` page is the exception: it is served at `/404`, never `/`.
+        const pagePath = hasPath ? data.path : (id === '404' ? null : '/');
+        if (pagePath === null) return false;
         return normalize(pagePath) === target;
     });
     return matches.length === 1 ? matches[0][0] : null;