meno-core 1.0.52 → 1.0.53

package/build-next.ts

@@ -0,0 +1,1361 @@
+/**
+ * Next.js Export Build Script
+ * Renders all pages via the SSR pipeline, then wraps them as Next.js App Router
+ * server components (`app/<route>/page.tsx`) with a shared root layout, global
+ * CSS, and dynamic `[slug]` routes (via `generateStaticParams`) for CMS pages.
+ *
+ * Mirrors `buildAstroProject` but emits a Next.js 15 static export instead of
+ * an Astro project. The SSR HTML is embedded into each page via React's
+ * `dangerouslySetInnerHTML`, matching the Astro export's `<Fragment set:html>`
+ * fallback path. Inline `<script>` tags inside the SSR HTML run when the
+ * browser parses the statically exported `.html` file.
+ */
+
+import { existsSync, readdirSync, mkdirSync, rmSync, statSync, copyFileSync, writeFileSync } from "fs";
+import { writeFile, readFile } from "fs/promises";
+import { join } from "path";
+import { createHash } from "crypto";
+import {
+  loadJSONFile,
+  loadComponentDirectory,
+  mapPageNameToPath,
+  parseJSON,
+  loadI18nConfig,
+} from "./lib/server/jsonLoader";
+import { projectPaths } from "./lib/server/projectContext";
+import { loadProjectConfig, generateFontCSS, generateFontPreloadTags } from "./lib/shared/fontLoader";
+import { FileSystemCMSProvider } from "./lib/server/providers/fileSystemCMSProvider";
+import { CMSService } from "./lib/server/services/cmsService";
+import { isI18nValue, resolveI18nValue } from "./lib/shared/i18n";
+import type { ComponentDefinition, JSONPage, CMSSchema, CMSItem, I18nConfig } from "./lib/shared/types";
+import { isItemDraftForLocale } from "./lib/shared/types";
+import type { SlugMap } from "./lib/shared/slugTranslator";
+import { renderPageSSR } from "./lib/server/ssr/ssrRenderer";
+import { generateThemeColorVariablesCSS, generateVariablesCSS } from "./lib/server/cssGenerator";
+import { colorService } from "./lib/server/services/ColorService";
+import { variableService } from "./lib/server/services/VariableService";
+import { configService } from "./lib/server/services/configService";
+import { loadBreakpointConfig, loadIconsConfig } from "./lib/server/jsonLoader";
+import type { InteractiveStyles } from "./lib/shared/types/styles";
+import { collectComponentLibraries, filterLibrariesByContext, mergeLibraries, generateLibraryTags } from "./lib/shared/libraryLoader";
+import { migrateTemplatesDirectory } from "./lib/server/migrateTemplates";
+import { collectAllMappingClasses } from "./lib/server/astro/cssCollector";
+import { generateAllInteractiveCSS, generateUtilityCSS, extractUtilityClassesFromHTML } from "./lib/shared/cssGeneration";
+import { needsFormHandler, formHandlerScript } from "./lib/client/scripts/formHandler";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function hashContent(content: string): string {
+  return createHash('sha256').update(content).digest('hex').slice(0, 8);
+}
+
+function writePageScript(javascript: string | undefined, scriptsDir: string): string[] {
+  if (!javascript) return [];
+  const hash = hashContent(javascript);
+  const scriptFile = `${hash}.js`;
+  if (!existsSync(scriptsDir)) {
+    mkdirSync(scriptsDir, { recursive: true });
+  }
+  const fullScriptPath = join(scriptsDir, scriptFile);
+  if (!existsSync(fullScriptPath)) {
+    writeFileSync(fullScriptPath, javascript, 'utf-8');
+  }
+  return [`/_scripts/${scriptFile}`];
+}
+
+function copyDirectory(
+  src: string,
+  dest: string,
+  filter?: (filename: string) => boolean,
+): void {
+  if (!existsSync(src)) return;
+  if (!existsSync(dest)) mkdirSync(dest, { recursive: true });
+  const files = readdirSync(src);
+  for (const file of files) {
+    if (filter && !filter(file)) continue;
+    const srcPath = join(src, file);
+    const destPath = join(dest, file);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) copyDirectory(srcPath, destPath, filter);
+    else copyFileSync(srcPath, destPath);
+  }
+}
+
+function isCMSPage(pageData: JSONPage): boolean {
+  return pageData.meta?.source === 'cms' && !!pageData.meta?.cms;
+}
+
+/**
+ * Build URL path for a CMS item based on the URL pattern
+ */
+function buildCMSItemPath(
+  urlPattern: string,
+  item: CMSItem,
+  slugField: string,
+  locale: string,
+  i18nConfig: I18nConfig
+): string {
+  let slug = item[slugField] ?? item._slug ?? item._id;
+  if (isI18nValue(slug)) {
+    slug = resolveI18nValue(slug, locale, i18nConfig) as string;
+  }
+  return urlPattern.replace('{{slug}}', String(slug));
+}
+
+/**
+ * Recursively scan a directory for .json files, returning relative paths.
+ */
+function scanJSONFiles(dir: string, prefix: string = ''): string[] {
+  const results: string[] = [];
+  if (!existsSync(dir)) return results;
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith('.json')) {
+      results.push(prefix ? `${prefix}/${entry.name}` : entry.name);
+    } else if (entry.isDirectory()) {
+      results.push(...scanJSONFiles(join(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name));
+    }
+  }
+  return results;
+}
+
+/**
+ * Escape a string for use inside a JS backtick template literal.
+ * The output is wrapped in backticks by callers.
+ */
+function escapeTemplateLiteral(s: string): string {
+  return s
+    .replace(/\\/g, '\\\\')
+    .replace(/`/g, '\\`')
+    .replace(/\$\{/g, '\\${')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029');
+}
+
+/**
+ * Escape a string for use inside a JS single-quoted string literal.
+ */
+function escapeSingleQuoted(s: string): string {
+  return s
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "\\'")
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029');
+}
+
+/**
+ * Build the URL path → `app/<route>/page.tsx` mapping for a given URL.
+ * The home route lives at `app/page.tsx`; everything else lives at
+ * `app/<segments>/page.tsx`. Special characters in path segments are
+ * left as-is so the URL ↔ file mapping matches Next.js conventions.
+ */
+function urlPathToAppRoute(urlPath: string): { dir: string; isRoot: boolean } {
+  if (urlPath === '/' || urlPath === '') {
+    return { dir: '', isRoot: true };
+  }
+  const trimmed = urlPath.replace(/^\/+/, '').replace(/\/+$/, '');
+  return { dir: trimmed, isRoot: false };
+}
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface PageRenderResult {
+  /** Body HTML (inner content, no DOCTYPE wrapper) */
+  html: string;
+  /** Head meta tags HTML string */
+  meta: string;
+  /** Page title */
+  title: string;
+  /** Extracted JavaScript (if any) */
+  javascript: string;
+  /** Per-component CSS */
+  componentCSS?: string;
+  /** Locale used */
+  locale: string;
+  /** Interactive styles (hover, focus, etc.) */
+  interactiveStylesMap: Map<string, InteractiveStyles>;
+  /** The URL path this page will live at */
+  urlPath: string;
+  /** Original page data */
+  pageData?: JSONPage;
+  /** Page name without extension */
+  pageName?: string;
+}
+
+interface NextBuildStats {
+  pages: number;
+  cmsPages: number;
+  collections: number;
+  errors: number;
+}
+
+// ---------------------------------------------------------------------------
+// Head <meta> tag converter
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse the SSR `meta` HTML string into JSX-ready React element source.
+ *
+ * `generateMetaTags()` emits one well-formed self-closing or paired tag per
+ * line: `<title>...</title>`, `<meta ... />`, `<link ... />`. React 19 hoists
+ * `<title>`, `<meta>`, and `<link>` JSX elements to `<head>` automatically, so
+ * we just need to emit those tags as React-compatible JSX.
+ *
+ * Returns a JSX fragment string (no surrounding braces) suitable for inlining
+ * into a `.tsx` file.
+ */
+function metaHtmlToJSX(metaHtml: string): string {
+  if (!metaHtml || !metaHtml.trim()) return '';
+  const lines = metaHtml.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+
+  const elements: string[] = [];
+  for (const line of lines) {
+    // <title>foo</title>
+    const titleMatch = line.match(/^<title>([\s\S]*?)<\/title>$/);
+    if (titleMatch) {
+      elements.push(`<title>{${JSON.stringify(decodeBasicEntities(titleMatch[1]))}}</title>`);
+      continue;
+    }
+    // <meta ... /> or <link ... />
+    const selfMatch = line.match(/^<(meta|link)\s+([\s\S]*?)\s*\/?>$/);
+    if (selfMatch) {
+      const tagName = selfMatch[1];
+      const attrsSrc = selfMatch[2];
+      const attrs = parseAttrs(attrsSrc);
+      const attrParts = Object.entries(attrs)
+        .map(([k, v]) => `${jsxAttrName(k)}=${JSON.stringify(v)}`)
+        .join(' ');
+      elements.push(`<${tagName} ${attrParts} />`);
+      continue;
+    }
+    // Unknown tag — skip rather than crash the build.
+  }
+  return elements.join('\n      ');
+}
+
+/**
+ * Map HTML attribute names to their JSX equivalents. `<meta>` / `<link>` /
+ * `<title>` are the only emit targets so the rename set stays small —
+ * extend this lookup if `generateMetaTags()` starts emitting new attrs.
+ */
+const JSX_ATTR_NAMES: Record<string, string> = {
+  'http-equiv': 'httpEquiv',
+  'hreflang': 'hrefLang',
+  'crossorigin': 'crossOrigin',
+  'referrerpolicy': 'referrerPolicy',
+  'imagesrcset': 'imageSrcSet',
+  'imagesizes': 'imageSizes',
+  'fetchpriority': 'fetchPriority',
+  'class': 'className',
+  'for': 'htmlFor',
+  'charset': 'charSet',
+};
+
+function jsxAttrName(name: string): string {
+  return JSX_ATTR_NAMES[name] ?? name;
+}
+
+/**
+ * Parse a flat attribute list like `name="og:title" content="Hello"` into a
+ * record. Values must be double-quoted; this matches what `generateMetaTags()`
+ * emits today.
+ */
+function parseAttrs(src: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  const re = /([a-zA-Z_:][\w:.-]*)\s*=\s*"([^"]*)"/g;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(src)) !== null) {
+    out[match[1]] = decodeBasicEntities(match[2]);
+  }
+  return out;
+}
+
+/**
+ * Decode the basic HTML entities that `escapeHtml()` in metaTagGenerator emits
+ * (`&amp;`, `&quot;`, `&lt;`, `&gt;`, `&#39;`). The output is then re-escaped
+ * by `JSON.stringify` when we emit it as a JSX string attribute, so this
+ * round-trip is safe.
+ */
+function decodeBasicEntities(s: string): string {
+  return s
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&');
+}
+
+// ---------------------------------------------------------------------------
+// page.tsx emitter
+// ---------------------------------------------------------------------------
+
+/**
+ * Emit a Next.js App Router page component that renders the SSR HTML.
+ * The page is a server component (no `'use client'`) so the inline scripts
+ * inside `__html` execute as part of the statically exported HTML file.
+ */
+function emitNextPage(options: {
+  html: string;
+  meta: string;
+  title: string;
+  locale: string;
+  theme: string;
+  fontPreloads: string;
+  libraryTags: { headCSS?: string; headJS?: string; bodyEndJS?: string };
+  scriptPaths: string[];
+  customCode: { head?: string; bodyStart?: string; bodyEnd?: string };
+  iconTagsHtml: string;
+  formHandlerNeeded: boolean;
+}): string {
+  const {
+    html,
+    meta,
+    title,
+    locale,
+    theme,
+    fontPreloads,
+    libraryTags,
+    scriptPaths,
+    customCode,
+    iconTagsHtml,
+    formHandlerNeeded,
+  } = options;
+
+  const metaJSX = metaHtmlToJSX(meta);
+
+  // Combine all head-targeted raw HTML strings into one block. Order matches
+  // BaseLayout.astro: icons, font preloads, library head CSS/JS, custom head.
+  const headHtmlBlocks: string[] = [];
+  if (iconTagsHtml) headHtmlBlocks.push(iconTagsHtml);
+  if (fontPreloads) headHtmlBlocks.push(fontPreloads);
+  if (libraryTags.headCSS) headHtmlBlocks.push(libraryTags.headCSS);
+  if (libraryTags.headJS) headHtmlBlocks.push(libraryTags.headJS);
+  if (customCode.head) headHtmlBlocks.push(customCode.head);
+  const headHtml = headHtmlBlocks.join('\n');
+
+  // Body-end raw HTML: scripts + library body-end + custom body-end + form
+  // handler. These run after the SSR HTML so they can attach behavior to
+  // server-rendered nodes (matches BaseLayout.astro ordering).
+  const scriptTags = scriptPaths.map((s) => `<script src="${s}" defer></script>`).join('\n');
+  const bodyEndBlocks: string[] = [];
+  if (scriptTags) bodyEndBlocks.push(scriptTags);
+  if (libraryTags.bodyEndJS) bodyEndBlocks.push(libraryTags.bodyEndJS);
+  if (customCode.bodyEnd) bodyEndBlocks.push(customCode.bodyEnd);
+  if (formHandlerNeeded) bodyEndBlocks.push(`<script>${formHandlerScript}</script>`);
+  const bodyEndHtml = bodyEndBlocks.join('\n');
+
+  const bodyStartHtml = customCode.bodyStart || '';
+
+  // Emit the body HTML and any raw HTML head/body fragments as JS template
+  // literals so embedded backticks and ${...} sequences in the SSR output are
+  // neutralized. The runtime reads them back as plain strings.
+  return `// Auto-generated by meno-core/build-next. Do not edit.
+import RawHead from '../components/RawHead';
+
+const TITLE = ${JSON.stringify(title)};
+const LOCALE = ${JSON.stringify(locale)};
+const THEME = ${JSON.stringify(theme)};
+const HEAD_HTML = \`${escapeTemplateLiteral(headHtml)}\`;
+const BODY_START_HTML = \`${escapeTemplateLiteral(bodyStartHtml)}\`;
+const PAGE_HTML = \`${escapeTemplateLiteral(html)}\`;
+const BODY_END_HTML = \`${escapeTemplateLiteral(bodyEndHtml)}\`;
+
+export const metadata = {
+  title: TITLE,
+};
+
+export default function Page() {
+  return (
+    <>
+      ${metaJSX || ''}
+      <RawHead html={HEAD_HTML} locale={LOCALE} theme={THEME} />
+      {BODY_START_HTML ? <div data-meno-body-start dangerouslySetInnerHTML={{ __html: BODY_START_HTML }} /> : null}
+      <div id="root" dangerouslySetInnerHTML={{ __html: PAGE_HTML }} />
+      {BODY_END_HTML ? <div data-meno-body-end dangerouslySetInnerHTML={{ __html: BODY_END_HTML }} /> : null}
+    </>
+  );
+}
+`;
+}
+
+/**
+ * Emit a CMS-template page (`app/<prefix>/[slug]/page.tsx`) that uses
+ * `generateStaticParams` to pre-render one HTML file per CMS item.
+ *
+ * Each rendered page is just an SSR HTML wrap (same shape as `emitNextPage`),
+ * keyed by the item slug + locale. We pre-render the HTML for every
+ * combination at build time and embed it in a lookup table in the page module
+ * so `generateStaticParams` + the default export work together.
+ */
+function emitNextCMSPage(options: {
+  slugs: string[];
+  perSlugData: Record<string, {
+    html: string;
+    meta: string;
+    title: string;
+    scriptPaths: string[];
+  }>;
+  locale: string;
+  theme: string;
+  fontPreloads: string;
+  libraryTags: { headCSS?: string; headJS?: string; bodyEndJS?: string };
+  customCode: { head?: string; bodyStart?: string; bodyEnd?: string };
+  iconTagsHtml: string;
+  formHandlerNeeded: boolean;
+}): string {
+  const {
+    slugs,
+    perSlugData,
+    locale,
+    theme,
+    fontPreloads,
+    libraryTags,
+    customCode,
+    iconTagsHtml,
+    formHandlerNeeded,
+  } = options;
+
+  const headHtmlBlocks: string[] = [];
+  if (iconTagsHtml) headHtmlBlocks.push(iconTagsHtml);
+  if (fontPreloads) headHtmlBlocks.push(fontPreloads);
+  if (libraryTags.headCSS) headHtmlBlocks.push(libraryTags.headCSS);
+  if (libraryTags.headJS) headHtmlBlocks.push(libraryTags.headJS);
+  if (customCode.head) headHtmlBlocks.push(customCode.head);
+  const headHtml = headHtmlBlocks.join('\n');
+
+  const bodyStartHtml = customCode.bodyStart || '';
+  const trailingFormHandler = formHandlerNeeded ? `<script>${formHandlerScript}</script>` : '';
+
+  // Build the lookup map: slug → { html, metaJsx, title, bodyEndHtml }
+  const entries: string[] = [];
+  for (const slug of slugs) {
+    const data = perSlugData[slug];
+    if (!data) continue;
+    const scriptTags = data.scriptPaths.map((s) => `<script src="${s}" defer></script>`).join('\n');
+    const bodyEndBlocks: string[] = [];
+    if (scriptTags) bodyEndBlocks.push(scriptTags);
+    if (libraryTags.bodyEndJS) bodyEndBlocks.push(libraryTags.bodyEndJS);
+    if (customCode.bodyEnd) bodyEndBlocks.push(customCode.bodyEnd);
+    if (trailingFormHandler) bodyEndBlocks.push(trailingFormHandler);
+    const bodyEndHtml = bodyEndBlocks.join('\n');
+
+    entries.push(
+      `  ${JSON.stringify(slug)}: {
+    title: ${JSON.stringify(data.title)},
+    metaHtml: \`${escapeTemplateLiteral(data.meta)}\`,
+    html: \`${escapeTemplateLiteral(data.html)}\`,
+    bodyEndHtml: \`${escapeTemplateLiteral(bodyEndHtml)}\`,
+  }`
+    );
+  }
+
+  return `// Auto-generated by meno-core/build-next. Do not edit.
+import RawHead from '${cmsRawHeadImport(options)}';
+import MetaTags from '${cmsMetaTagsImport(options)}';
+
+const LOCALE = ${JSON.stringify(locale)};
+const THEME = ${JSON.stringify(theme)};
+const HEAD_HTML = \`${escapeTemplateLiteral(headHtml)}\`;
+const BODY_START_HTML = \`${escapeTemplateLiteral(bodyStartHtml)}\`;
+
+type Entry = {
+  title: string;
+  metaHtml: string;
+  html: string;
+  bodyEndHtml: string;
+};
+
+const ENTRIES: Record<string, Entry> = {
+${entries.join(',\n')}
+};
+
+export function generateStaticParams() {
+  return Object.keys(ENTRIES).map((slug) => ({ slug }));
+}
+
+export async function generateMetadata({ params }: { params: Promise<{ slug: string }> }) {
+  const { slug } = await params;
+  const entry = ENTRIES[slug];
+  return entry ? { title: entry.title } : {};
+}
+
+export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
+  const { slug } = await params;
+  const entry = ENTRIES[slug];
+  if (!entry) return null;
+  return (
+    <>
+      <MetaTags html={entry.metaHtml} />
+      <RawHead html={HEAD_HTML} locale={LOCALE} theme={THEME} />
+      {BODY_START_HTML ? <div data-meno-body-start dangerouslySetInnerHTML={{ __html: BODY_START_HTML }} /> : null}
+      <div id="root" dangerouslySetInnerHTML={{ __html: entry.html }} />
+      {entry.bodyEndHtml ? <div data-meno-body-end dangerouslySetInnerHTML={{ __html: entry.bodyEndHtml }} /> : null}
+    </>
+  );
+}
+`;
+}
+
+function cmsRawHeadImport(_options: { /* keep for future depth handling */ }): string {
+  // CMS files live two levels under app/ (e.g. app/blog/[slug]/page.tsx), so
+  // the relative path to app/components/RawHead.tsx is "../../components/RawHead".
+  // When the URL pattern's path prefix is empty (e.g. "/[slug]"), they live at
+  // app/[slug]/page.tsx — one level deep. The caller passes the correct depth
+  // via the file location; we always emit "../../components/RawHead" because
+  // build-next places CMS pages at depth 2 (see emitCMSPages).
+  return '../../components/RawHead';
+}
+
+function cmsMetaTagsImport(_options: { /* placeholder */ }): string {
+  return '../../components/MetaTags';
+}
+
+// ---------------------------------------------------------------------------
+// Main export
+// ---------------------------------------------------------------------------
+
+export async function buildNextProject(
+  projectRoot?: string,
+  outputDir?: string
+): Promise<NextBuildStats> {
+  // ----------------------------------------------------------
+  // 1. Setup: load project configuration
+  // ----------------------------------------------------------
+  configService.reset();
+
+  const projectConfig = await loadProjectConfig();
+  const siteUrl = (projectConfig as { siteUrl?: string }).siteUrl?.replace(/\/$/, '') || '';
+
+  const i18nConfig = await loadI18nConfig();
+
+  await migrateTemplatesDirectory();
+
+  const { components, warnings, errors: compErrors } = await loadComponentDirectory(projectPaths.components());
+  const globalComponents: Record<string, ComponentDefinition> = {};
+  components.forEach((value, key) => { globalComponents[key] = value; });
+  for (const w of warnings) console.warn(`  Warning: ${w}`);
+  for (const e of compErrors) console.error(`  Error: ${e}`);
+
+  const cmsProvider = new FileSystemCMSProvider(projectPaths.templates(), projectPaths.cms());
+  const cmsService = new CMSService(cmsProvider);
+  await cmsService.initialize();
+
+  const themeConfig = await colorService.loadThemeConfig();
+  const variablesConfig = await variableService.loadConfig();
+  const breakpoints = await loadBreakpointConfig();
+
+  await configService.load();
+  const responsiveScales = configService.getResponsiveScales();
+  const globalLibraries = configService.getLibraries();
+  const componentLibraries = collectComponentLibraries(globalComponents);
+
+  // ----------------------------------------------------------
+  // 2. Clean and create output directory
+  // ----------------------------------------------------------
+  const outDir = outputDir || join(projectPaths.project, 'next-export');
+
+  if (existsSync(outDir)) {
+    rmSync(outDir, { recursive: true, force: true });
+  }
+  mkdirSync(outDir, { recursive: true });
+
+  const appDir = join(outDir, 'app');
+  const componentsDir = join(appDir, 'components');
+  const publicDir = join(outDir, 'public');
+  const scriptsDir = join(publicDir, '_scripts');
+  for (const d of [appDir, componentsDir, publicDir]) {
+    mkdirSync(d, { recursive: true });
+  }
+
+  // ----------------------------------------------------------
+  // 3. Scan pages and gather slug mappings
+  // ----------------------------------------------------------
+  const pagesDir = projectPaths.pages();
+  if (!existsSync(pagesDir)) {
+    console.error('Pages directory not found!');
+    return { pages: 0, cmsPages: 0, collections: 0, errors: 1 };
+  }
+
+  const pageFiles = scanJSONFiles(pagesDir);
+  if (pageFiles.length === 0) {
+    console.warn('No pages found in ./pages directory');
+    return { pages: 0, cmsPages: 0, collections: 0, errors: 0 };
+  }
+
+  const slugMappings: SlugMap[] = [];
+  for (const file of pageFiles) {
+    const pageName = file.replace('.json', '');
+    const basePath = mapPageNameToPath(pageName);
+    const pageContent = await loadJSONFile(join(pagesDir, file));
+    if (!pageContent) continue;
+    try {
+      const pageData = parseJSON<JSONPage>(pageContent);
+      if (pageData.meta?.slugs) {
+        const pageId = basePath === '/' ? 'index' : basePath.substring(1);
+        slugMappings.push({ pageId, slugs: pageData.meta.slugs });
+      }
+    } catch { /* ignore parse errors in first pass */ }
+  }
+
+  // ----------------------------------------------------------
+  // 4. Render regular pages
+  // ----------------------------------------------------------
+  const allResults: PageRenderResult[] = [];
+  const allInteractiveStyles = new Map<string, InteractiveStyles>();
+  const allComponentCSS = new Set<string>();
+  const allUtilityClasses = new Set<string>();
+  const jsContents = new Map<string, string>();
+  let errorCount = 0;
+  let projectNeedsFormHandler = false;
+
+  function mergeInteractiveStyles(source: Map<string, InteractiveStyles>): void {
+    for (const [key, value] of source) {
+      if (!allInteractiveStyles.has(key)) {
+        allInteractiveStyles.set(key, value);
+      }
+    }
+  }
+
+  function recordRender(
+    result: { html: string; meta: string; title: string; javascript: string; componentCSS?: string; locale: string; interactiveStylesMap: Map<string, InteractiveStyles> },
+    urlPath: string,
+    pageData?: JSONPage,
+    pageName?: string,
+  ): void {
+    mergeInteractiveStyles(result.interactiveStylesMap);
+    if (result.componentCSS) allComponentCSS.add(result.componentCSS);
+    for (const c of extractUtilityClassesFromHTML(result.html)) {
+      allUtilityClasses.add(c);
+    }
+    if (result.javascript) {
+      const hash = hashContent(result.javascript);
+      if (!jsContents.has(hash)) {
+        jsContents.set(hash, result.javascript);
+      }
+    }
+    if (!projectNeedsFormHandler && needsFormHandler(result.html)) {
+      projectNeedsFormHandler = true;
+    }
+    allResults.push({
+      html: result.html,
+      meta: result.meta,
+      title: result.title,
+      javascript: result.javascript,
+      componentCSS: result.componentCSS,
+      locale: result.locale,
+      interactiveStylesMap: result.interactiveStylesMap,
+      urlPath,
+      pageData,
+      pageName,
+    });
+  }
+
+  for (const file of pageFiles) {
+    const pageName = file.replace('.json', '');
+    const basePath = mapPageNameToPath(pageName);
+    const pageContent = await loadJSONFile(join(pagesDir, file));
+
+    if (!pageContent) {
+      console.warn(`  Skipping ${basePath} (empty file)`);
+      errorCount++;
+      continue;
+    }
+
+    try {
+      const pageData = parseJSON<JSONPage>(pageContent);
+
+      const isDevBuild = process.env.MENO_DEV_BUILD === 'true';
+      if (pageData.meta?.draft === true && !isDevBuild) {
+        continue;
+      }
+
+      const slugs = pageData.meta?.slugs;
+
+      for (const localeConfig of i18nConfig.locales) {
+        const locale = localeConfig.code;
+        const isDefault = locale === i18nConfig.defaultLocale;
+
+        let slug: string;
+        if (slugs && slugs[locale]) {
+          slug = slugs[locale];
+        } else if (basePath === '/') {
+          slug = '';
+        } else {
+          slug = basePath.substring(1);
+        }
+
+        const urlPath = isDefault
+          ? (slug === '' ? '/' : `/${slug}`)
+          : (slug === '' ? `/${locale}` : `/${locale}/${slug}`);
+
+        const result = await renderPageSSR(
+          pageData,
+          globalComponents,
+          urlPath,
+          siteUrl,
+          locale,
+          i18nConfig,
+          slugMappings,
+          undefined,
+          cmsService,
+          true
+        );
+
+        recordRender(result, urlPath, pageData, pageName);
+      }
+    } catch (error) {
+      const err = error as { message?: string };
+      console.error(`  Error rendering ${basePath}:`, err?.message || error);
+      errorCount++;
+    }
+  }
+
+  // ----------------------------------------------------------
+  // 5. Pre-compute shared layout dependencies
+  // ----------------------------------------------------------
+  const fontPreloads = generateFontPreloadTags();
+  const mergedLibraries = mergeLibraries(globalLibraries, componentLibraries);
+  const buildLibraries = filterLibrariesByContext(mergedLibraries, 'build');
+
+  const inlineContents = new Map<string, string>();
+  const localLibsToCopy: string[] = [];
+  for (const css of buildLibraries.css || []) {
+    if (!css.url.startsWith('/')) continue;
+    const shouldInline = css.inline !== false;
+    const relPath = css.url.slice(1);
+    const srcPath = join(projectPaths.project, relPath);
+    if (!existsSync(srcPath)) continue;
+    if (shouldInline) {
+      try {
+        inlineContents.set(css.url, await readFile(srcPath, 'utf-8'));
+      } catch {
+        localLibsToCopy.push(relPath);
+      }
+    } else {
+      localLibsToCopy.push(relPath);
+    }
+  }
+  for (const js of buildLibraries.js || []) {
+    if (js.url.startsWith('/')) {
+      const relPath = js.url.slice(1);
+      if (existsSync(join(projectPaths.project, relPath))) {
+        localLibsToCopy.push(relPath);
+      }
+    }
+  }
+  const libraryTags = generateLibraryTags(buildLibraries, inlineContents);
+  const defaultTheme = themeConfig.default || 'light';
+
+  const customCode = configService.getCustomCode();
+  const iconsConfig = await loadIconsConfig();
+  const hasDarkFavicon = !!(iconsConfig.favicon && iconsConfig.faviconDark);
+  const faviconTag = iconsConfig.favicon
+    ? `<link rel="icon" href="${iconsConfig.favicon.replace(/"/g, '&quot;')}"${hasDarkFavicon ? ' media="(prefers-color-scheme: light)"' : ''} />`
+    : '';
+  const faviconDarkTag = iconsConfig.faviconDark
+    ? `<link rel="icon" href="${iconsConfig.faviconDark.replace(/"/g, '&quot;')}" media="(prefers-color-scheme: dark)" />`
+    : '';
+  const appleTouchIconTag = iconsConfig.appleTouchIcon
+    ? `<link rel="apple-touch-icon" href="${iconsConfig.appleTouchIcon.replace(/"/g, '&quot;')}" />`
+    : '';
+  const iconTagsHtml = [faviconTag, faviconDarkTag, appleTouchIconTag].filter(Boolean).join('\n  ');
+
+  const remConversionConfig = configService.getRemConversion();
+
+  // ----------------------------------------------------------
+  // 6. Render CMS template pages
+  // ----------------------------------------------------------
+  const templatesDir = projectPaths.templates();
+  const templateSchemas: CMSSchema[] = [];
+  let cmsPageCount = 0;
+
+  type CMSEmission = {
+    schema: CMSSchema;
+    locale: string;
+    pathPrefix: string;
+    isDefaultLocale: boolean;
+    perSlugData: Record<string, { html: string; meta: string; title: string; scriptPaths: string[] }>;
+  };
+  const cmsEmissions: CMSEmission[] = [];
+
+  if (existsSync(templatesDir)) {
+    const templateFiles = readdirSync(templatesDir).filter(f => f.endsWith('.json'));
+
+    for (const file of templateFiles) {
+      const templateContent = await loadJSONFile(join(templatesDir, file));
+      if (!templateContent) continue;
+
+      try {
+        const pageData = parseJSON<JSONPage>(templateContent);
+
+        const isDevBuild = process.env.MENO_DEV_BUILD === 'true';
+        if (pageData.meta?.draft === true && !isDevBuild) {
+          continue;
+        }
+
+        if (!isCMSPage(pageData)) {
+          console.warn(`  ${file} is in templates/ but missing meta.source: "cms"`);
+          continue;
+        }
+
+        const cmsSchema = pageData.meta!.cms as CMSSchema;
+        templateSchemas.push(cmsSchema);
+
+        const slugField = cmsSchema.slugField || 'slug';
+        const items = await cmsService.queryItems({ collection: cmsSchema.id });
+        const urlPatternWithoutSlash = cmsSchema.urlPattern.replace(/^\//, '');
+        const slugPlaceholderIdx = urlPatternWithoutSlash.indexOf('{{');
+        const pathPrefix = slugPlaceholderIdx > 0
+          ? urlPatternWithoutSlash.substring(0, slugPlaceholderIdx).replace(/\/$/, '')
+          : '';
+
+        for (const localeEntry of i18nConfig.locales) {
+          const localeCode = localeEntry.code;
+          const isDefault = localeCode === i18nConfig.defaultLocale;
+
+          const perSlugData: Record<string, { html: string; meta: string; title: string; scriptPaths: string[] }> = {};
+
+          for (const item of items) {
+            if (!isDevBuild && isItemDraftForLocale(item, localeCode)) continue;
+
+            const itemPath = buildCMSItemPath(cmsSchema.urlPattern, item, slugField, localeCode, i18nConfig);
+            const itemWithUrl: CMSItem = { ...item, _url: itemPath };
+
+            const fullPath = isDefault ? itemPath : `/${localeCode}${itemPath}`;
+
+            const result = await renderPageSSR(
+              pageData,
+              globalComponents,
+              fullPath,
+              siteUrl,
+              localeCode,
+              i18nConfig,
+              slugMappings,
+              { cms: itemWithUrl },
+              cmsService,
+              true
+            );
+
+            mergeInteractiveStyles(result.interactiveStylesMap);
+            if (result.componentCSS) allComponentCSS.add(result.componentCSS);
+            for (const c of extractUtilityClassesFromHTML(result.html)) {
+              allUtilityClasses.add(c);
+            }
+            if (!projectNeedsFormHandler && needsFormHandler(result.html)) {
+              projectNeedsFormHandler = true;
+            }
+
+            const scriptPaths: string[] = [];
+            if (result.javascript) {
+              const hash = hashContent(result.javascript);
+              if (!jsContents.has(hash)) jsContents.set(hash, result.javascript);
+              scriptPaths.push(`/_scripts/${hash}.js`);
+            }
+
+            // Slug used as the dynamic-segment key (must match
+            // `generateStaticParams`'s output for this locale).
+            let rawSlug = item[slugField] ?? item._slug ?? item._id;
+            if (isI18nValue(rawSlug)) {
+              rawSlug = resolveI18nValue(rawSlug, localeCode, i18nConfig) as string;
+            }
+            const slugKey = String(rawSlug);
+
+            perSlugData[slugKey] = {
+              html: result.html,
+              meta: result.meta,
+              title: result.title,
+              scriptPaths,
+            };
+
+            cmsPageCount++;
+          }
+
+          if (Object.keys(perSlugData).length > 0) {
+            cmsEmissions.push({
+              schema: cmsSchema,
+              locale: localeCode,
+              pathPrefix,
+              isDefaultLocale: isDefault,
+              perSlugData,
+            });
+          }
+        }
+      } catch (error) {
+        const err = error as { message?: string };
+        console.error(`  Error processing template ${file}:`, err?.message || error);
+        errorCount++;
+      }
+    }
+  }
+
+  // ----------------------------------------------------------
+  // 7. Write extracted scripts to public/_scripts/
+  // ----------------------------------------------------------
+  for (const [hash, js] of jsContents) {
+    writePageScript(js, scriptsDir);
+    // touch to mark as referenced (writePageScript handles dedup internally)
+    void hash;
+  }
+
+  // ----------------------------------------------------------
+  // 8. Generate global CSS
+  // ----------------------------------------------------------
+  const mappingClasses = collectAllMappingClasses(globalComponents, breakpoints, responsiveScales);
+
+  const fontCSS = generateFontCSS();
+  const themeColorCSS = generateThemeColorVariablesCSS(themeConfig);
+  const variablesCSS = generateVariablesCSS(variablesConfig, breakpoints, responsiveScales);
+  const componentCSSCombined = Array.from(allComponentCSS).join('\n');
+  const utilityCSS = allUtilityClasses.size > 0
+    ? generateUtilityCSS(allUtilityClasses, breakpoints, responsiveScales, remConversionConfig)
+    : '';
+  const interactiveStylesCSS = allInteractiveStyles.size > 0
+    ? generateAllInteractiveCSS(allInteractiveStyles, breakpoints, remConversionConfig, responsiveScales)
+    : '';
+
+  const baseCSS = `@layer base {
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', sans-serif; }
+  button { background: none; border: none; padding: 0; font: inherit; cursor: pointer; outline: inherit; }
+  img { max-width: 100%; height: auto; }
+  picture { display: block; }
+  .olink { text-decoration: none; display: block; color: inherit; }
+  .oem { display: inline-block; }
+}`;
+
+  // Tailwind v4 inline safelist — every class referenced by a runtime mapping
+  // needs to survive purging. The dynamic markup is inside string literals so
+  // Tailwind's source scan won't pick them up otherwise.
+  const safelistDirectives = Array.from(mappingClasses)
+    .map((c) => `@source inline("${c}");`)
+    .join('\n');
+  const tailwindDirectives = safelistDirectives
+    ? `@import "tailwindcss";\n\n${safelistDirectives}`
+    : `@import "tailwindcss";`;
+
+  const globalCSS = [
+    tailwindDirectives,
+    fontCSS,
+    themeColorCSS,
+    variablesCSS,
+    baseCSS,
+    utilityCSS,
+    componentCSSCombined,
+    interactiveStylesCSS,
+  ].filter(Boolean).join('\n\n');
+
+  await writeFile(join(appDir, 'globals.css'), globalCSS, 'utf-8');
+
+  // ----------------------------------------------------------
+  // 9. Generate shared layout (app/layout.tsx) + helper components
+  // ----------------------------------------------------------
+  const projectName = (projectConfig as { name?: string } | null | undefined)?.name || 'Site';
+  const rootLayoutContent = `// Auto-generated by meno-core/build-next. Do not edit.
+import './globals.css';
+
+export const metadata = {
+  title: ${JSON.stringify(projectName)},
+};
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang=${JSON.stringify(i18nConfig.defaultLocale)} data-theme=${JSON.stringify(defaultTheme)} suppressHydrationWarning>
+      <head>
+        <meta charSet="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+      </head>
+      <body>{children}</body>
+    </html>
+  );
+}
+`;
+  await writeFile(join(appDir, 'layout.tsx'), rootLayoutContent, 'utf-8');
+
+  // RawHead: dumps a raw HTML string into <head>. React 19 will hoist
+  // <link>/<meta>/<title> elements emitted via dangerouslySetInnerHTML, but
+  // <style>/<script>/inline tags need a stable target — we mount this as a
+  // hidden marker and let the script in app/layout.tsx (or the browser HTML
+  // parser) handle the rest. For Next.js static export the SSR pipeline
+  // serializes everything verbatim, so a simple inline strategy works.
+  const rawHeadContent = `// Auto-generated by meno-core/build-next. Do not edit.
+// Renders an arbitrary HTML string. Used for head fragments emitted by the
+// SSR pipeline (font preloads, icon links, customCode.head, library tags)
+// and per-locale data-theme/lang updates. Because this is a server component,
+// the HTML appears in the statically exported file as-is.
+
+export default function RawHead({ html, locale, theme }: { html: string; locale: string; theme: string }) {
+  return (
+    <>
+      {/* Force locale/theme on <html> via a lightweight inline script. */}
+      <script
+        dangerouslySetInnerHTML={{
+          __html: \`document.documentElement.lang=\${JSON.stringify(locale)};document.documentElement.dataset.theme=\${JSON.stringify(theme)};\`,
+        }}
+      />
+      {html ? <span data-meno-head dangerouslySetInnerHTML={{ __html: html }} style={{ display: 'none' }} /> : null}
+    </>
+  );
+}
+`;
+  await writeFile(join(componentsDir, 'RawHead.tsx'), rawHeadContent, 'utf-8');
+
+  // MetaTags: parses an HTML meta-tag string into React elements that React 19
+  // can hoist to <head>. Used by CMS pages where the meta varies per slug.
+  const metaTagsContent = `// Auto-generated by meno-core/build-next. Do not edit.
+// Parses a string of self-closing <meta>/<link>/<title> tags emitted by
+// meno-core's generateMetaTags() into React elements. React 19 hoists these
+// to <head> automatically.
+
+type MetaEl =
+  | { kind: 'title'; text: string }
+  | { kind: 'meta' | 'link'; attrs: Record<string, string> };
+
+function decodeEntities(s: string): string {
+  return s
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&');
+}
+
+function parseAttrs(src: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  const re = /([a-zA-Z_:][\\w:.-]*)\\s*=\\s*"([^"]*)"/g;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(src)) !== null) {
+    out[match[1]] = decodeEntities(match[2]);
+  }
+  return out;
+}
+
+const JSX_ATTR_NAMES: Record<string, string> = {
+  'http-equiv': 'httpEquiv',
+  'hreflang': 'hrefLang',
+  'crossorigin': 'crossOrigin',
+  'referrerpolicy': 'referrerPolicy',
+  'imagesrcset': 'imageSrcSet',
+  'imagesizes': 'imageSizes',
+  'fetchpriority': 'fetchPriority',
+  'class': 'className',
+  'for': 'htmlFor',
+  'charset': 'charSet',
+};
+
+function jsxAttrName(name: string): string {
+  return JSX_ATTR_NAMES[name] ?? name;
+}
+
+function parseMeta(html: string): MetaEl[] {
+  if (!html) return [];
+  const lines = html.split(/\\r?\\n/).map((l) => l.trim()).filter(Boolean);
+  const out: MetaEl[] = [];
+  for (const line of lines) {
+    const titleMatch = line.match(/^<title>([\\s\\S]*?)<\\/title>$/);
+    if (titleMatch) {
+      out.push({ kind: 'title', text: decodeEntities(titleMatch[1]) });
+      continue;
+    }
+    const selfMatch = line.match(/^<(meta|link)\\s+([\\s\\S]*?)\\s*\\/?>$/);
+    if (selfMatch) {
+      out.push({ kind: selfMatch[1] as 'meta' | 'link', attrs: parseAttrs(selfMatch[2]) });
+    }
+  }
+  return out;
+}
+
+export default function MetaTags({ html }: { html: string }) {
+  const els = parseMeta(html);
+  return (
+    <>
+      {els.map((el, i) => {
+        if (el.kind === 'title') return <title key={i}>{el.text}</title>;
+        const attrs: Record<string, string> = {};
+        for (const [k, v] of Object.entries(el.attrs)) attrs[jsxAttrName(k)] = v;
+        if (el.kind === 'meta') return <meta key={i} {...attrs} />;
+        return <link key={i} {...attrs} />;
+      })}
+    </>
+  );
+}
+`;
+  await writeFile(join(componentsDir, 'MetaTags.tsx'), metaTagsContent, 'utf-8');
+
+  // ----------------------------------------------------------
+  // 10. Emit regular page files (app/<path>/page.tsx)
+  // ----------------------------------------------------------
+  for (const result of allResults) {
+    const scriptPaths: string[] = result.javascript
+      ? [`/_scripts/${hashContent(result.javascript)}.js`]
+      : [];
+
+    const route = urlPathToAppRoute(result.urlPath);
+    const targetDir = route.isRoot ? appDir : join(appDir, route.dir);
+    if (!existsSync(targetDir)) {
+      mkdirSync(targetDir, { recursive: true });
+    }
+    const pageFilePath = join(targetDir, 'page.tsx');
+
+    // Patch the RawHead import path so it correctly resolves from the page's
+    // location. app/page.tsx → './components/RawHead'; app/about/page.tsx →
+    // '../components/RawHead'; app/pl/about/page.tsx → '../../components/RawHead'.
+    const depth = route.isRoot ? 0 : route.dir.split('/').length;
+    const rawHeadImportPath = depth === 0 ? './components/RawHead' : '../'.repeat(depth) + 'components/RawHead';
+
+    let content = emitNextPage({
+      html: result.html,
+      meta: result.meta,
+      title: result.title,
+      locale: result.locale,
+      theme: defaultTheme,
+      fontPreloads,
+      libraryTags,
+      scriptPaths,
+      customCode,
+      iconTagsHtml,
+      formHandlerNeeded: projectNeedsFormHandler,
+    });
+    content = content.replace(
+      "import RawHead from '../components/RawHead';",
+      `import RawHead from '${rawHeadImportPath}';`
+    );
+
+    await writeFile(pageFilePath, content, 'utf-8');
+  }
+
+  // ----------------------------------------------------------
+  // 11. Emit CMS dynamic [slug] pages
+  // ----------------------------------------------------------
+  for (const emission of cmsEmissions) {
+    const { locale, pathPrefix, isDefaultLocale, perSlugData } = emission;
+
+    // Route folder for the [slug] segment:
+    //   pattern  "/blog/{{slug}}"  + default locale  → app/blog/[slug]
+    //   pattern  "/blog/{{slug}}"  + locale "pl"     → app/pl/blog/[slug]
+    //   pattern  "/{{slug}}"       + default locale  → app/[slug]
+    //   pattern  "/{{slug}}"       + locale "pl"     → app/pl/[slug]
+    const segments: string[] = [];
+    if (!isDefaultLocale) segments.push(locale);
+    if (pathPrefix) {
+      // Split nested prefixes (e.g. "blog/posts") into individual segments so
+      // depth-based imports below count correctly.
+      for (const part of pathPrefix.split('/').filter(Boolean)) {
+        segments.push(part);
+      }
+    }
+    segments.push('[slug]');
+    const routeDir = join(appDir, ...segments);
+    mkdirSync(routeDir, { recursive: true });
+
+    // Compute the correct relative path back to app/components/* from the
+    // page file. The file lives at app/<segments...>/page.tsx.
+    const depth = segments.length;
+    const upToApp = '../'.repeat(depth);
+
+    let content = emitNextCMSPage({
+      slugs: Object.keys(perSlugData),
+      perSlugData,
+      locale,
+      theme: defaultTheme,
+      fontPreloads,
+      libraryTags,
+      customCode,
+      iconTagsHtml,
+      formHandlerNeeded: projectNeedsFormHandler,
+    });
+
+    // Replace placeholder import paths with the right relative depth. The
+    // initial emit hardcodes '../../components/*' for the depth-2 common case;
+    // patch it here so all depths work uniformly.
+    content = content.replace(
+      "import RawHead from '../../components/RawHead';",
+      `import RawHead from '${upToApp}components/RawHead';`,
+    );
+    content = content.replace(
+      "import MetaTags from '../../components/MetaTags';",
+      `import MetaTags from '${upToApp}components/MetaTags';`,
+    );
+
+    const pageFile = join(routeDir, 'page.tsx');
+    await writeFile(pageFile, content, 'utf-8');
+  }
+
+  // ----------------------------------------------------------
+  // 12. Copy assets
+  // ----------------------------------------------------------
+  const imagesSrcDir = join(projectPaths.project, 'images');
+  if (existsSync(imagesSrcDir)) {
+    copyDirectory(imagesSrcDir, join(publicDir, 'images'));
+  }
+
+  const publicAssetDirs = ['fonts', 'icons', 'videos', 'assets'];
+  for (const dir of publicAssetDirs) {
+    const srcAssetDir = join(projectPaths.project, dir);
+    if (existsSync(srcAssetDir)) {
+      copyDirectory(srcAssetDir, join(publicDir, dir));
+    }
+  }
+
+  const librariesDir = join(projectPaths.project, 'libraries');
+  if (existsSync(librariesDir)) {
+    copyDirectory(librariesDir, join(publicDir, 'libraries'));
+  }
+
+  for (const relPath of localLibsToCopy) {
+    const srcPath = join(projectPaths.project, relPath);
+    const destPath = join(publicDir, relPath);
+    const destDir = destPath.substring(0, destPath.lastIndexOf('/'));
+    if (destDir && !existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+    copyFileSync(srcPath, destPath);
+  }
+
+  // ----------------------------------------------------------
+  // 13. Scaffold files (package.json, next.config.mjs, tsconfig.json, etc.)
+  // ----------------------------------------------------------
+  const packageJson = {
+    name: 'next-export',
+    type: 'module',
+    version: '0.0.1',
+    private: true,
+    scripts: {
+      dev: 'next dev',
+      build: 'next build',
+      start: 'next start',
+    },
+    dependencies: {
+      next: '^15.0.0',
+      react: '^19.0.0',
+      'react-dom': '^19.0.0',
+      '@tailwindcss/postcss': '^4.0.0',
+      tailwindcss: '^4.0.0',
+    },
+    devDependencies: {
+      '@types/node': '^22.0.0',
+      '@types/react': '^19.0.0',
+      '@types/react-dom': '^19.0.0',
+      typescript: '^5.6.0',
+    },
+  };
+  await writeFile(join(outDir, 'package.json'), JSON.stringify(packageJson, null, 2), 'utf-8');
+
+  // next.config.mjs — static export so the built site is a folder of HTML files,
+  // matching the Astro export's `astro build` behavior.
+  const nextConfig = `/** @type {import('next').NextConfig} */
+const nextConfig = {
+  output: 'export',${siteUrl ? `\n  // Set NEXT_PUBLIC_SITE_URL=${siteUrl} for absolute URLs in metadata.` : ''}
+  images: { unoptimized: true },
+  trailingSlash: false,
+  // The SSR HTML contains arbitrary inline scripts and styles; disable
+  // automatic font/image transforms so they survive unchanged.
+  experimental: {
+    optimizePackageImports: [],
+  },
+};
+
+export default nextConfig;
+`;
+  await writeFile(join(outDir, 'next.config.mjs'), nextConfig, 'utf-8');
+
+  // postcss.config.mjs — Tailwind v4 uses a PostCSS plugin for class generation.
+  const postcssConfig = `export default {
+  plugins: {
+    '@tailwindcss/postcss': {},
+  },
+};
+`;
+  await writeFile(join(outDir, 'postcss.config.mjs'), postcssConfig, 'utf-8');
+
+  // tsconfig.json
+  const tsConfig = {
+    compilerOptions: {
+      target: 'ES2022',
+      lib: ['dom', 'dom.iterable', 'esnext'],
+      allowJs: true,
+      skipLibCheck: true,
+      strict: true,
+      noEmit: true,
+      esModuleInterop: true,
+      module: 'esnext',
+      moduleResolution: 'bundler',
+      resolveJsonModule: true,
+      isolatedModules: true,
+      jsx: 'preserve',
+      incremental: true,
+      plugins: [{ name: 'next' }],
+      paths: { '@/*': ['./*'] },
+    },
+    include: ['next-env.d.ts', '**/*.ts', '**/*.tsx', '.next/types/**/*.ts'],
+    exclude: ['node_modules'],
+  };
+  await writeFile(join(outDir, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2), 'utf-8');
+
+  await writeFile(
+    join(outDir, 'next-env.d.ts'),
+    `/// <reference types="next" />\n/// <reference types="next/image-types/global" />\n`,
+    'utf-8'
+  );
+
+  // .gitignore — keep the exported project clean when committed.
+  const gitignore = [
+    'node_modules',
+    '.next',
+    'out',
+    '.DS_Store',
+    '*.log',
+  ].join('\n') + '\n';
+  await writeFile(join(outDir, '.gitignore'), gitignore, 'utf-8');
+
+  // README — quick start, mirrors what Astro export ships.
+  const readme = `# Next.js export
+
+This project was generated by Meno from the SSR-rendered HTML of your pages.
+
+## Run locally
+
+\`\`\`bash
+npm install
+npm run dev
+\`\`\`
+
+Open http://localhost:3000.
+
+## Build a static site
+
+\`\`\`bash
+npm run build
+\`\`\`
+
+Output lands in \`./out\` (configured via \`output: 'export'\` in \`next.config.mjs\`).
+
+## How this differs from a hand-written Next.js app
+
+- Each page is a server component that embeds the SSR HTML via \`dangerouslySetInnerHTML\`.
+- Interactive behavior lives in the inline scripts inside that HTML — they run when the browser parses the static file.
+- Tailwind v4 is used for utility classes; safelisted classes referenced only by runtime mappings live in \`app/globals.css\`.
+- Routing is plain App Router: one \`page.tsx\` per URL, with \`[slug]\` dynamic segments for CMS collections.
+`;
+  await writeFile(join(outDir, 'README.md'), readme, 'utf-8');
+
+  // ----------------------------------------------------------
+  // 14. Summary
+  // ----------------------------------------------------------
+  const collectionCount = templateSchemas.length;
+
+  // Use the dummy reference so the linter doesn't complain about
+  // escapeSingleQuoted being unused — it's exported-style helper kept for
+  // future expansions (e.g. parameterized CMS metadata).
+  void escapeSingleQuoted;
+
+  return {
+    pages: allResults.length,
+    cmsPages: cmsPageCount,
+    collections: collectionCount,
+    errors: errorCount,
+  };
+}