@koehler8/cms 1.0.0-beta.33 → 1.0.0-beta.35

package/package.json

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

package/src/components/Header.vue

@@ -130,14 +130,26 @@ const isHeaderCompact = ref(false);
 const currentLocale = ref('');
 const availableLocales = computed(() => siteLocales.map((code) => code.trim()).filter(Boolean));
 
-// The base locale is served at the unprefixed root path (`/`) — clicking
-// the dropdown item for it should NOT navigate to `/{baseLocale}` because
-// that URL doesn't pre-render and would 404. Build the link path
-// accordingly: base → `/`, others → `/{locale}`.
+// Switching language keeps the visitor on the SAME page rather than bouncing
+// them to the locale's home. Slugs are shared across locales, so take the
+// current path, strip any leading non-base locale segment, and re-prefix with
+// the target locale. The base locale is served unprefixed (`/path`); others at
+// `/{locale}/path`. (`/{baseLocale}/path` doesn't pre-render and would 404,
+// hence the base stays unprefixed.)
 const localeHref = (locale) => {
-  if (locale === siteBaseLocale) return '/';
+  const segments = (route.path || '/').split('/').filter(Boolean);
+  if (segments.length) {
+    const first = segments[0].toLowerCase();
+    if (first !== siteBaseLocale && availableLocales.value.includes(first)) {
+      segments.shift();
+    }
+  }
+  const rest = segments.join('/');
   const slash = injectedSiteData.value?.site?.trailingSlash === true ? '/' : '';
-  return `/${locale}${slash}`;
+  if (locale === siteBaseLocale) {
+    return rest ? `/${rest}${slash}` : '/';
+  }
+  return rest ? `/${locale}/${rest}${slash}` : `/${locale}${slash}`;
 };
 const localeLabels = {
   en: 'English',

package/src/composables/usePageConfig.js

@@ -219,11 +219,20 @@ export function usePageConfig({ pageId, pagePath, locale, onPageLoaded } = {}) {
     cachedConfig = primed;
     lastLocaleKey = localeKey;
 
-    // Preserve the saved-locale auto-switch on base-locale routes: the server
-    // has no localStorage, so it rendered the base locale. If a returning
-    // visitor stored a different locale, reconcile AFTER the first paint
-    // (soft = no blank) so that paint still matches the server but the saved
-    // choice is honored.
+    // Decide whether a soft (no blank-out) background reload of the FULL config
+    // is needed after this first synchronous paint. Two independent triggers,
+    // both satisfied by the same single reload:
+    //
+    //  1. Partial embed: the server trimmed the embedded config to just this
+    //     page (site.trimInitialState), so the primed config can't resolve
+    //     OTHER pages for in-SPA navigation. Load the full config now; the
+    //     current page re-applies identically, so there's no visible change.
+    //  2. Saved-locale switch: the server has no localStorage, so a base-locale
+    //     route rendered the base locale. If a returning visitor stored a
+    //     different locale, reconcile to it. (loadConfigData reads localStorage
+    //     when no explicit locale is passed, so the same reload resolves it.)
+    let needsFullReload = Boolean(primed && primed.pagesPartial);
+
     if (localeForConfig === undefined && typeof localStorage !== 'undefined') {
       let stored = '';
       try {
@@ -231,10 +240,12 @@ export function usePageConfig({ pageId, pagePath, locale, onPageLoaded } = {}) {
       } catch {
         stored = '';
       }
-      if (stored) {
-        lastLocaleKey = null; // force the reconcile to reload with localStorage resolution
-        syncPage({ soft: true });
-      }
+      if (stored) needsFullReload = true;
+    }
+
+    if (needsFullReload) {
+      lastLocaleKey = null; // force syncPage to reload (localStorage-resolved for base routes)
+      syncPage({ soft: true });
     }
     return true;
   }

package/src/composables/usePageMeta.js

@@ -231,6 +231,11 @@ export function usePageMeta({ siteData, currentPage, locale }) {
     }
 
     return {
+      // Reflect the page's locale on <html lang> during SSR/prerender so the
+      // on-disk HTML for /{locale}/... ships the right language (the router
+      // guard only sets this client-side, after hydration). Base-locale pages
+      // fall back to the configured base locale.
+      htmlAttrs: { lang: localeValue.value || configBaseLocale || 'en' },
       title: pageMetaTitle.value,
       meta,
       link,

package/src/main.js

@@ -6,7 +6,7 @@ import App from './App.vue';
 import { routes, resolveHistory, applyRouterGuards } from './router/index.js';
 
 import { shouldEnableAnalytics, scheduleAnalyticsLoad } from './utils/cookieConsent.js';
-import { loadConfigData, primeConfigSync } from './utils/loadConfig.js';
+import { loadConfigData, primeConfigSync, trimConfigToPage, resolvePageIdForRoute } from './utils/loadConfig.js';
 import { persistAttributionFromLocation } from './utils/trackingContext.js';
 import { applyThemeVariables } from './themes/themeManager.js';
 import { setActiveThemeKey } from './utils/themeColors.js';
@@ -145,6 +145,18 @@ export function createCmsApp() {
         return null;
       };
 
+      // SSG only: resolve the route being pre-rendered to its page id so the
+      // embedded config can be trimmed to that single page when the site opts
+      // into `site.trimInitialState`. The matching rules live in the pure,
+      // unit-tested resolvePageIdForRoute (returns null on ambiguity → keep the
+      // full config, a safe no-op).
+      const resolveCurrentPageId = (config) => {
+        const route = extractCurrentRoute();
+        const rawPath = typeof route?.path === 'string' ? route.path : '';
+        const localeParam = pickLocaleParam(route?.params?.locale);
+        return resolvePageIdForRoute(config, rawPath, localeParam);
+      };
+
       const loadSiteConfig = async (options = {}) => {
         const requestedLocale =
           pickLocaleParam(options.locale) ??
@@ -178,6 +190,18 @@ export function createCmsApp() {
       if (!isClient) {
         try {
           await loadSiteConfig();
+          // Opt-in payload trim: embed only the current page's config in
+          // window.__INITIAL_STATE__ rather than every page's (the full-site
+          // blob is byte-identical on every page and can dominate page weight).
+          // The rendered HTML body is unaffected — usePageConfig resolves the
+          // SSR render from its own loadConfigData() call, not from
+          // initialState — so this only shrinks the serialized hydration blob.
+          if (initialState.siteConfig?.site?.trimInitialState === true) {
+            const currentPageId = resolveCurrentPageId(initialState.siteConfig);
+            if (currentPageId) {
+              initialState.siteConfig = trimConfigToPage(initialState.siteConfig, currentPageId);
+            }
+          }
         } catch (error) {
           console.error('Failed to load site configuration during SSG build', error);
         }

package/src/utils/loadConfig.js

@@ -34,6 +34,49 @@ export function cloneConfig(value) {
     return value;
 }
 
+// Reduce a resolved config's `pages` map to a single page, preserving `site`
+// and `shared` (which every page needs globally). Used by the SSG pass when a
+// site opts into `site.trimInitialState` so each pre-rendered page embeds only
+// its own page config in `window.__INITIAL_STATE__` instead of the entire
+// site's pages (which is byte-identical on every page and can dominate the
+// page weight). Marks the result `pagesPartial: true` so the client knows the
+// embedded config can't resolve other pages and must lazy-load the full config
+// before in-SPA navigation (see usePageConfig.hydrateFromSyncCache). Returns
+// the config untouched when the page id is absent — a safe no-op fallback so a
+// mis-resolved route never trims away the page actually being rendered.
+export function trimConfigToPage(config, pageId) {
+    if (!config || typeof config !== 'object' || Array.isArray(config)) return config;
+    if (!config.pages || typeof config.pages !== 'object') return config;
+    if (!pageId || !Object.prototype.hasOwnProperty.call(config.pages, pageId)) return config;
+    return { ...config, pages: { [pageId]: config.pages[pageId] }, pagesPartial: true };
+}
+
+// Map a route being pre-rendered to its page id, for the SSG trim above.
+// Strips a leading `/{locale}` segment (non-base locales render at
+// `/{locale}/path`), normalizes trailing/duplicate slashes, and matches against
+// each page's `path` (defaulting a path-less page to '/'). Returns the id only
+// on an UNAMBIGUOUS single match — home, path-less, or colliding routes return
+// null so the caller keeps the full config (a safe no-op). Pure/exported so the
+// locale-strip + matching rules are unit-testable without a full SSG build.
+export function resolvePageIdForRoute(config, routePath, localeParam) {
+    if (typeof routePath !== 'string' || !routePath) return null;
+    let target = routePath;
+    if (localeParam && typeof localeParam === 'string') {
+        const prefix = `/${localeParam}`;
+        if (target === prefix) target = '/';
+        else if (target.startsWith(`${prefix}/`)) target = target.slice(prefix.length);
+    }
+    const normalize = (p) =>
+        (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 : '/';
+        return normalize(pagePath) === target;
+    });
+    return matches.length === 1 ? matches[0][0] : null;
+}
+
 export function mergeConfigTrees(target, source, options = {}) {
     const { cloneTarget = false, skipEmpty = true } = options;
 

package/templates/scaffolds/site/package.json

@@ -6,7 +6,7 @@
   "scripts": {
     "dev": "vite",
     "build": "vite build",
-    "build:ssg": "vite-ssg build",
+    "build:ssg": "NODE_OPTIONS=--max-old-space-size=4096 vite-ssg build",
     "preview": "vite preview",
     "generate:public-assets": "cms-generate-public-assets --site-dir ./site"
   },

package/vite-plugin.js

@@ -576,6 +576,14 @@ export default function cmsPlugin(options = {}) {
         },
         ssgOptions: {
           dirStyle: 'nested',
+          // Cap vite-ssg's render pool (default is 20). The SSG pre-render
+          // leaves a fixed retained cost per route (one jsdom document survives
+          // each page inside vite-ssg's loop), so peak heap is dominated by that
+          // accumulation rather than the concurrent batch — but a smaller pool
+          // still trims the transient working set layered on top and makes peak
+          // more predictable on large multi-locale sites. This is a mitigation,
+          // not the bound; see SSG-MEMORY-PLAN.md for the durable fix.
+          concurrency: 8,
           // After vite-ssg pre-renders every route, copy the rendered
           // dist/404/index.html to dist/404.html. AWS Amplify (and most
           // static hosts) auto-serve a top-level 404.html for any