meno-core 1.0.38 → 1.0.39

package/build-astro.ts

@@ -0,0 +1,914 @@
+/**
+ * Astro Export Build Script
+ * Renders all pages via the SSR pipeline, then wraps them as Astro page files
+ * with a shared layout, global CSS, and optional CMS content collections.
+ */
+
+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 { inspect, minifyJS as runtimeMinifyJS } from './lib/server/runtime';
+import {
+  loadJSONFile,
+  loadComponentDirectory,
+  mapPageNameToPath,
+  parseJSON,
+  loadI18nConfig
+} from "./lib/server/jsonLoader";
+import { generateSSRHTML } from "./lib/server/ssrRenderer";
+import type { SSRHTMLResult } from "./lib/server/ssr/htmlGenerator";
+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 type { CMSFieldDefinition } from "./lib/shared/types/cms";
+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 { generateAllInteractiveCSS } from "./lib/shared/cssGeneration";
+import { colorService } from "./lib/server/services/ColorService";
+import { variableService } from "./lib/server/services/VariableService";
+import { configService } from "./lib/server/services/configService";
+import { loadBreakpointConfig, loadResponsiveScalesConfig } 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 { emitAstroComponent } from "./lib/server/astro/componentEmitter";
+import { emitAstroPage } from "./lib/server/astro/pageEmitter";
+import { collectAllMappingClasses } from "./lib/server/astro/cssCollector";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function hashContent(content: string): string {
+  return createHash('sha256').update(content).digest('hex').slice(0, 8);
+}
+
+function copyDirectory(src: string, dest: string): void {
+  if (!existsSync(src)) return;
+  if (!existsSync(dest)) mkdirSync(dest, { recursive: true });
+  const files = readdirSync(src);
+  for (const file of files) {
+    const srcPath = join(src, file);
+    const destPath = join(dest, file);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) copyDirectory(srcPath, destPath);
+    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;
+}
+
+/**
+ * Compute the relative import path from a file at `fromDepth` levels under src/pages/
+ * back to src/layouts/BaseLayout.astro.
+ */
+function layoutImportPath(fileDepth: number): string {
+  // fileDepth = 0 means file is at src/pages/index.astro -> ../layouts/BaseLayout.astro
+  // fileDepth = 1 means src/pages/en/index.astro -> ../../layouts/BaseLayout.astro
+  const ups = '../'.repeat(fileDepth + 1);
+  return `${ups}layouts/BaseLayout.astro`;
+}
+
+/**
+ * Escape a string for use inside a JS template literal (backtick string).
+ */
+function escapeTemplateLiteral(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+
+/**
+ * Map a CMS field type to a Zod schema string for the Astro content config.
+ */
+function cmsFieldToZod(field: CMSFieldDefinition): string {
+  switch (field.type) {
+    case 'string':
+    case 'text':
+    case 'rich-text':
+      return 'z.string()';
+    case 'number':
+      return 'z.number()';
+    case 'boolean':
+      return 'z.boolean()';
+    case 'date':
+      return 'z.coerce.date()';
+    case 'select':
+      if (field.options && field.options.length > 0) {
+        const opts = field.options.map(o => `'${o.replace(/'/g, "\\'")}'`).join(', ');
+        return `z.enum([${opts}])`;
+      }
+      return 'z.string()';
+    case 'image':
+    case 'file':
+      return 'z.string()';
+    case 'reference':
+      return 'z.string()';
+    default:
+      return 'z.string()';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 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;
+  /** File depth relative to src/pages/ (0 = root, 1 = one dir deep, etc.) */
+  fileDepth: number;
+  /** Relative file path within src/pages/ */
+  astroFilePath: string;
+  /** Original page data (for Pass 2 component-structured emission) */
+  pageData?: JSONPage;
+  /** Page name without extension */
+  pageName?: string;
+  /** Whether this is a CMS template page */
+  isCMSPage?: boolean;
+}
+
+interface AstroBuildStats {
+  pages: number;
+  cmsPages: number;
+  collections: number;
+  errors: number;
+}
+
+// ---------------------------------------------------------------------------
+// SSR Fallback page builder (used for CMS pages and error fallback)
+// ---------------------------------------------------------------------------
+
+function buildSSRFallbackPage(
+  result: PageRenderResult,
+  importPath: string,
+  fontPreloads: string,
+  libraryTags: { headCSS?: string; headJS?: string; bodyEndJS?: string },
+  defaultTheme: string,
+  scriptPaths: string[]
+): string {
+  const escapedMeta = escapeTemplateLiteral(result.meta);
+  const escapedHTML = escapeTemplateLiteral(result.html);
+  const escapedFontPreloads = escapeTemplateLiteral(fontPreloads);
+
+  const scriptsArrayLiteral = scriptPaths.length > 0
+    ? `[${scriptPaths.map(s => `"${s}"`).join(', ')}]`
+    : '[]';
+
+  const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral(libraryTags.headCSS || '')}\`, headJS: \`${escapeTemplateLiteral(libraryTags.headJS || '')}\`, bodyEndJS: \`${escapeTemplateLiteral(libraryTags.bodyEndJS || '')}\` }`;
+
+  return `---
+import BaseLayout from '${importPath}';
+---
+<BaseLayout
+  title="${result.title.replace(/"/g, '&quot;')}"
+  meta={\`${escapedMeta}\`}
+  scripts={${scriptsArrayLiteral}}
+  locale="${result.locale}"
+  theme="${defaultTheme}"
+  fontPreloads={\`${escapedFontPreloads}\`}
+  libraryTags={${libraryTagsLiteral}}
+>
+  <Fragment set:html={\`<div id="root">${escapedHTML}</div>\`} />
+</BaseLayout>
+`;
+}
+
+// ---------------------------------------------------------------------------
+// Main export
+// ---------------------------------------------------------------------------
+
+export async function buildAstroProject(
+  projectRoot?: string,
+  outputDir?: string
+): Promise<AstroBuildStats> {
+  const startTime = Date.now();
+
+  console.log('🏗️  Building Astro export...\n');
+
+  // ----------------------------------------------------------
+  // 1. Setup: load project configuration
+  // ----------------------------------------------------------
+  configService.reset();
+
+  const projectConfig = await loadProjectConfig();
+  const siteUrl = (projectConfig as { siteUrl?: string }).siteUrl?.replace(/\/$/, '') || '';
+
+  const i18nConfig = await loadI18nConfig();
+  console.log(`🌐 Locales: ${i18nConfig.locales.map(l => l.code).join(', ')} (default: ${i18nConfig.defaultLocale})\n`);
+
+  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}`);
+  console.log(`Loaded ${components.size} global component(s)\n`);
+
+  const cmsProvider = new FileSystemCMSProvider(projectPaths.templates(), projectPaths.cms());
+  const cmsService = new CMSService(cmsProvider);
+  await cmsService.initialize();
+  console.log('CMS service initialized\n');
+
+  const themeConfig = await colorService.loadThemeConfig();
+  const variablesConfig = await variableService.loadConfig();
+  const breakpoints = await loadBreakpointConfig();
+  const responsiveScales = await loadResponsiveScalesConfig();
+
+  // Libraries (global + component)
+  await configService.load();
+  const globalLibraries = configService.getLibraries();
+  const componentLibraries = collectComponentLibraries(globalComponents);
+
+  // ----------------------------------------------------------
+  // 2. Clean and create output directory
+  // ----------------------------------------------------------
+  const outDir = outputDir || join(projectPaths.project, 'astro-export');
+
+  if (existsSync(outDir)) {
+    rmSync(outDir, { recursive: true, force: true });
+  }
+  mkdirSync(outDir, { recursive: true });
+
+  // Create directory structure
+  const srcDir = join(outDir, 'src');
+  const pagesOutDir = join(srcDir, 'pages');
+  const layoutsDir = join(srcDir, 'layouts');
+  const stylesDir = join(srcDir, 'styles');
+  const componentsOutDir = join(srcDir, 'components');
+  const publicDir = join(outDir, 'public');
+  const scriptsDir = join(publicDir, '_scripts');
+  for (const d of [srcDir, pagesOutDir, layoutsDir, stylesDir, componentsOutDir, publicDir]) {
+    mkdirSync(d, { recursive: true });
+  }
+
+  // ----------------------------------------------------------
+  // 3. Scan pages
+  // ----------------------------------------------------------
+  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 };
+  }
+
+  console.log(`Found ${pageFiles.length} page(s) to process\n`);
+
+  // Collect slug mappings (first pass)
+  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 & 5. Render all pages (regular + CMS templates)
+  // ----------------------------------------------------------
+  const allResults: PageRenderResult[] = [];
+  const allInteractiveStyles = new Map<string, InteractiveStyles>();
+  const allComponentCSS = new Set<string>();
+  const jsContents = new Map<string, string>(); // hash -> JS content
+  let errorCount = 0;
+
+  // Helper to merge interactive styles maps
+  function mergeInteractiveStyles(source: Map<string, InteractiveStyles>): void {
+    for (const [key, value] of source) {
+      if (!allInteractiveStyles.has(key)) {
+        allInteractiveStyles.set(key, value);
+      }
+    }
+  }
+
+  // Helper to process a render result
+  function processRenderResult(
+    result: { html: string; meta: string; title: string; javascript: string; componentCSS?: string; locale: string; interactiveStylesMap: Map<string, InteractiveStyles>; preloadImages: any[]; neededCollections: Set<string> },
+    urlPath: string,
+    astroFilePath: string,
+    fileDepth: number,
+    pageData?: JSONPage,
+    pageName?: string,
+    isCMSPage?: boolean
+  ): void {
+    // Collect interactive styles
+    mergeInteractiveStyles(result.interactiveStylesMap);
+
+    // Collect component CSS
+    if (result.componentCSS) {
+      allComponentCSS.add(result.componentCSS);
+    }
+
+    // Deduplicate JavaScript by content hash
+    if (result.javascript) {
+      const hash = hashContent(result.javascript);
+      if (!jsContents.has(hash)) {
+        jsContents.set(hash, result.javascript);
+      }
+    }
+
+    allResults.push({
+      html: result.html,
+      meta: result.meta,
+      title: result.title,
+      javascript: result.javascript,
+      componentCSS: result.componentCSS,
+      locale: result.locale,
+      interactiveStylesMap: result.interactiveStylesMap,
+      urlPath,
+      fileDepth,
+      astroFilePath,
+      pageData,
+      pageName,
+      isCMSPage,
+    });
+  }
+
+  // ---------- Regular pages ----------
+  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);
+
+      // Skip draft pages in production
+      const isDevBuild = process.env.MENO_DEV_BUILD === 'true';
+      if (pageData.meta?.draft === true && !isDevBuild) {
+        console.log(`  Skipping draft: ${basePath}`);
+        continue;
+      }
+
+      const slugs = pageData.meta?.slugs;
+
+      for (const localeConfig of i18nConfig.locales) {
+        const locale = localeConfig.code;
+        const isDefault = locale === i18nConfig.defaultLocale;
+
+        // Compute URL path
+        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}`);
+
+        // Determine .astro file path relative to src/pages/
+        const astroFileName = slug === '' ? 'index.astro' : `${slug}.astro`;
+        const astroFilePath = isDefault ? astroFileName : `${locale}/${astroFileName}`;
+        const fileDepth = astroFilePath.split('/').length - 1;
+
+        const result = await renderPageSSR(
+          pageData,
+          globalComponents,
+          urlPath,
+          siteUrl,
+          locale,
+          i18nConfig,
+          slugMappings,
+          undefined, // cmsContext
+          cmsService,
+          true // isProductionBuild
+        );
+
+        processRenderResult(result, urlPath, astroFilePath, fileDepth, pageData, pageName, false);
+        console.log(`  Rendered: ${urlPath}`);
+      }
+    } catch (error: any) {
+      console.error(`  Error rendering ${basePath}:`, error?.message || error);
+      errorCount++;
+    }
+  }
+
+  // ---------- CMS template pages ----------
+  const templatesDir = projectPaths.templates();
+  const templateSchemas: CMSSchema[] = [];
+  let cmsPageCount = 0;
+
+  if (existsSync(templatesDir)) {
+    const templateFiles = readdirSync(templatesDir).filter(f => f.endsWith('.json'));
+
+    if (templateFiles.length > 0) {
+      console.log(`\nProcessing ${templateFiles.length} CMS template(s)...\n`);
+    }
+
+    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) {
+          console.log(`  Skipping draft template: ${file}`);
+          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);
+        console.log(`  CMS Collection: ${cmsSchema.id}`);
+
+        const items = await cmsService.queryItems({ collection: cmsSchema.id });
+        if (items.length === 0) {
+          console.log(`    No items found in cms/${cmsSchema.id}/`);
+          continue;
+        }
+
+        console.log(`    Found ${items.length} item(s)`);
+
+        for (const item of items) {
+          for (const localeConfig of i18nConfig.locales) {
+            const locale = localeConfig.code;
+            const isDefault = locale === i18nConfig.defaultLocale;
+
+            const isDevBuild = process.env.MENO_DEV_BUILD === 'true';
+            if (!isDevBuild && isItemDraftForLocale(item, locale)) {
+              continue;
+            }
+
+            const itemPath = buildCMSItemPath(cmsSchema.urlPattern, item, cmsSchema.slugField, locale, i18nConfig);
+            const itemWithUrl: CMSItem = { ...item, _url: itemPath };
+
+            const result = await renderPageSSR(
+              pageData,
+              globalComponents,
+              itemPath,
+              siteUrl,
+              locale,
+              i18nConfig,
+              slugMappings,
+              { cms: itemWithUrl },
+              cmsService,
+              true
+            );
+
+            // Determine .astro file path: strip leading slash, add .astro
+            const pathWithoutSlash = itemPath.startsWith('/') ? itemPath.substring(1) : itemPath;
+            const astroFilePath = isDefault
+              ? `${pathWithoutSlash}.astro`
+              : `${locale}/${pathWithoutSlash}.astro`;
+            const fileDepth = astroFilePath.split('/').length - 1;
+
+            const urlPath = isDefault ? itemPath : `/${locale}${itemPath}`;
+
+            processRenderResult(result, urlPath, astroFilePath, fileDepth, pageData, file.replace('.json', ''), true);
+            console.log(`    Rendered: ${urlPath}`);
+            cmsPageCount++;
+          }
+        }
+      } catch (error: any) {
+        console.error(`  Error processing template ${file}:`, error?.message || error);
+        errorCount++;
+      }
+    }
+  }
+
+  // ----------------------------------------------------------
+  // 6. Generate global CSS (Tailwind + theme + interactive styles)
+  // ----------------------------------------------------------
+  // Collect Tailwind safelist classes from mapping variants
+  const mappingClasses = collectAllMappingClasses(globalComponents, breakpoints);
+
+  const fontCSS = generateFontCSS();
+  const themeColorCSS = generateThemeColorVariablesCSS(themeConfig);
+  const variablesCSS = generateVariablesCSS(variablesConfig, breakpoints, responsiveScales);
+  const interactiveCSS = generateAllInteractiveCSS(allInteractiveStyles, breakpoints);
+  const componentCSSCombined = Array.from(allComponentCSS).join('\n');
+
+  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 { display: block; width: 100%; height: 100%; }
+  picture { display: block; }
+  .olink { text-decoration: none; display: block; }
+  .oem { display: inline-block; }
+}`;
+
+  const tailwindDirectives = `@tailwind base;
+@tailwind components;
+@tailwind utilities;`;
+
+  const globalCSS = [tailwindDirectives, fontCSS, themeColorCSS, variablesCSS, baseCSS, componentCSSCombined, interactiveCSS]
+    .filter(Boolean)
+    .join('\n\n');
+
+  await writeFile(join(stylesDir, 'global.css'), globalCSS, 'utf-8');
+  console.log(`\nGenerated global.css (${(globalCSS.length / 1024).toFixed(1)} KB)`);
+
+  // ----------------------------------------------------------
+  // 7. Generate BaseLayout.astro
+  // ----------------------------------------------------------
+  const fontPreloads = generateFontPreloadTags();
+
+  // Merge global + component libraries for the layout
+  const mergedLibraries = mergeLibraries(globalLibraries, componentLibraries);
+  const buildLibraries = filterLibrariesByContext(mergedLibraries, 'build');
+  const libraryTags = generateLibraryTags(buildLibraries);
+
+  const baseLayoutContent = `---
+import '../styles/global.css';
+
+interface Props {
+  title: string;
+  meta?: string;
+  scripts?: string[];
+  locale?: string;
+  theme?: string;
+  fontPreloads?: string;
+  libraryTags?: { headCSS?: string; headJS?: string; bodyEndJS?: string };
+}
+
+const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.default || 'light'}', fontPreloads = '', libraryTags = {} } = Astro.props;
+---
+<!DOCTYPE html>
+<html lang={locale} data-theme={theme}>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <Fragment set:html={fontPreloads} />
+  <Fragment set:html={libraryTags.headCSS || ''} />
+  <Fragment set:html={libraryTags.headJS || ''} />
+  <Fragment set:html={meta} />
+  <title>{title}</title>
+</head>
+<body>
+  <slot />
+  {scripts.map((s) => <script src={s} />)}
+  <Fragment set:html={libraryTags.bodyEndJS || ''} />
+</body>
+</html>
+`;
+
+  await writeFile(join(layoutsDir, 'BaseLayout.astro'), baseLayoutContent, 'utf-8');
+  console.log('Generated BaseLayout.astro');
+
+  // ----------------------------------------------------------
+  // 7.5. Generate component .astro files
+  // ----------------------------------------------------------
+  let componentFileCount = 0;
+  for (const [compName, compDef] of Object.entries(globalComponents)) {
+    try {
+      const astroContent = emitAstroComponent(compName, compDef, globalComponents, breakpoints);
+      await writeFile(join(componentsOutDir, `${compName}.astro`), astroContent, 'utf-8');
+      componentFileCount++;
+    } catch (error: any) {
+      console.warn(`  Warning: could not generate component ${compName}: ${error?.message}`);
+    }
+  }
+  console.log(`Generated ${componentFileCount} component .astro file(s)`);
+
+  // ----------------------------------------------------------
+  // 8. Generate .astro page files (component-structured)
+  // ----------------------------------------------------------
+  const defaultTheme = themeConfig.default || 'light';
+
+  for (const result of allResults) {
+    const importPath = layoutImportPath(result.fileDepth);
+
+    // Write JavaScript to public/_scripts/ if present
+    const scriptPaths: string[] = [];
+    if (result.javascript) {
+      const hash = hashContent(result.javascript);
+      const scriptFile = `${hash}.js`;
+      const scriptPublicPath = `/_scripts/${scriptFile}`;
+
+      if (!existsSync(scriptsDir)) {
+        mkdirSync(scriptsDir, { recursive: true });
+      }
+
+      const fullScriptPath = join(scriptsDir, scriptFile);
+      if (!existsSync(fullScriptPath)) {
+        await writeFile(fullScriptPath, result.javascript, 'utf-8');
+      }
+      scriptPaths.push(scriptPublicPath);
+    }
+
+    let astroContent: string;
+
+    // Use component-structured emission for regular pages with page data
+    // CMS template pages keep the SSR fallback approach
+    if (result.pageData && !result.isCMSPage) {
+      try {
+        astroContent = emitAstroPage({
+          pageData: result.pageData,
+          globalComponents,
+          title: result.title,
+          meta: result.meta,
+          locale: result.locale,
+          theme: defaultTheme,
+          fontPreloads,
+          libraryTags,
+          scriptPaths,
+          layoutImportPath: importPath,
+          fileDepth: result.fileDepth,
+          ssrFallbacks: new Map(), // SSR fallbacks for complex nodes
+          pageName: result.pageName || 'index',
+          breakpoints,
+        });
+      } catch (error: any) {
+        // Fallback to SSR HTML if component emission fails
+        console.warn(`  Warning: component emission failed for ${result.urlPath}, using SSR fallback: ${error?.message}`);
+        astroContent = buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths);
+      }
+    } else {
+      // CMS pages and pages without pageData: use SSR fallback
+      astroContent = buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths);
+    }
+
+    const astroFileFull = join(pagesOutDir, result.astroFilePath);
+    const astroFileDir = astroFileFull.substring(0, astroFileFull.lastIndexOf('/'));
+    if (!existsSync(astroFileDir)) {
+      mkdirSync(astroFileDir, { recursive: true });
+    }
+
+    await writeFile(astroFileFull, astroContent, 'utf-8');
+  }
+
+  console.log(`Generated ${allResults.length} .astro page file(s)`);
+
+  // ----------------------------------------------------------
+  // 9. Generate CMS content collections (if templates exist)
+  // ----------------------------------------------------------
+  let collectionCount = 0;
+
+  if (templateSchemas.length > 0) {
+    const contentDir = join(srcDir, 'content');
+    mkdirSync(contentDir, { recursive: true });
+
+    const collectionDefs: string[] = [];
+
+    for (const schema of templateSchemas) {
+      const collectionDir = join(contentDir, schema.id);
+      mkdirSync(collectionDir, { recursive: true });
+
+      // Copy CMS item JSON files, resolving i18n values to default locale
+      const cmsItemsDir = join(projectPaths.cms(), schema.id);
+      if (existsSync(cmsItemsDir)) {
+        const itemFiles = readdirSync(cmsItemsDir).filter(f => f.endsWith('.json'));
+
+        for (const itemFile of itemFiles) {
+          try {
+            const rawContent = await readFile(join(cmsItemsDir, itemFile), 'utf-8');
+            const item = JSON.parse(rawContent) as CMSItem;
+
+            // Resolve i18n values to the default locale
+            const resolved: Record<string, unknown> = {};
+            for (const [key, value] of Object.entries(item)) {
+              if (isI18nValue(value)) {
+                resolved[key] = resolveI18nValue(value, i18nConfig.defaultLocale, i18nConfig);
+              } else {
+                resolved[key] = value;
+              }
+            }
+
+            await writeFile(
+              join(collectionDir, itemFile),
+              JSON.stringify(resolved, null, 2),
+              'utf-8'
+            );
+          } catch (err: any) {
+            console.warn(`    Warning: could not process CMS item ${itemFile}: ${err?.message}`);
+          }
+        }
+      }
+
+      // Build Zod schema for this collection
+      const fieldDefs: string[] = [];
+      if (schema.fields) {
+        for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+          const zodType = cmsFieldToZod(fieldDef);
+          const optional = fieldDef.required ? '' : '.optional()';
+          fieldDefs.push(`    ${fieldName}: ${zodType}${optional}`);
+        }
+      }
+
+      collectionDefs.push(`  '${schema.id}': defineCollection({
+    type: 'data',
+    schema: z.object({
+${fieldDefs.join(',\n')}
+    })
+  })`);
+
+      collectionCount++;
+    }
+
+    // Write src/content/config.ts
+    const configContent = `import { z, defineCollection } from 'astro:content';
+
+const collections = {
+${collectionDefs.join(',\n')}
+};
+
+export { collections };
+`;
+
+    await writeFile(join(contentDir, 'config.ts'), configContent, 'utf-8');
+    console.log(`Generated ${collectionCount} content collection(s) with config.ts`);
+  }
+
+  // ----------------------------------------------------------
+  // 10. Copy assets to public/
+  // ----------------------------------------------------------
+  const assetDirs = ['fonts', 'images', 'icons', 'videos', 'assets'];
+  let copiedAssets = 0;
+
+  for (const dir of assetDirs) {
+    const srcAssetDir = join(projectPaths.project, dir);
+    if (existsSync(srcAssetDir)) {
+      copyDirectory(srcAssetDir, join(publicDir, dir));
+      copiedAssets++;
+    }
+  }
+
+  // Copy libraries folder if it exists
+  const librariesDir = join(projectPaths.project, 'libraries');
+  if (existsSync(librariesDir)) {
+    copyDirectory(librariesDir, join(publicDir, 'libraries'));
+    copiedAssets++;
+  }
+
+  if (copiedAssets > 0) {
+    console.log(`Copied ${copiedAssets} asset director${copiedAssets === 1 ? 'y' : 'ies'} to public/`);
+  }
+
+  // ----------------------------------------------------------
+  // 11. Generate scaffold files
+  // ----------------------------------------------------------
+
+  // package.json
+  const packageJson = {
+    name: 'astro-export',
+    type: 'module',
+    version: '0.0.1',
+    private: true,
+    scripts: {
+      dev: 'astro dev',
+      start: 'astro dev',
+      build: 'astro build',
+      preview: 'astro preview',
+    },
+    dependencies: {
+      'astro': '^4.0.0',
+      '@astrojs/sitemap': '^3.0.0',
+      '@astrojs/tailwind': '^5.0.0',
+      'tailwindcss': '^3.4.0',
+    },
+  };
+
+  await writeFile(join(outDir, 'package.json'), JSON.stringify(packageJson, null, 2), 'utf-8');
+
+  // astro.config.mjs
+  const astroConfig = `import { defineConfig } from 'astro/config';
+import sitemap from '@astrojs/sitemap';
+import tailwind from '@astrojs/tailwind';
+
+export default defineConfig({${siteUrl ? `\n  site: '${siteUrl}',` : ''}
+  integrations: [sitemap(), tailwind({ applyBaseStyles: false })],
+});
+`;
+
+  // tailwind.config.mjs
+  const safelistArray = Array.from(mappingClasses);
+  const safelistLiteral = safelistArray.length > 0
+    ? `\n  safelist: [\n${safelistArray.map(c => `    '${c}'`).join(',\n')}\n  ],`
+    : '';
+
+  const tailwindConfig = `/** @type {import('tailwindcss').Config} */
+export default {
+  content: ['./src/**/*.{astro,html,js,jsx,md,mdx,svelte,ts,tsx,vue}'],${safelistLiteral}
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+};
+`;
+
+  await writeFile(join(outDir, 'tailwind.config.mjs'), tailwindConfig, 'utf-8');
+
+  await writeFile(join(outDir, 'astro.config.mjs'), astroConfig, 'utf-8');
+
+  // tsconfig.json
+  const tsConfig = {
+    extends: 'astro/tsconfigs/strict',
+  };
+
+  await writeFile(join(outDir, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2), 'utf-8');
+
+  console.log('Generated package.json, astro.config.mjs, tailwind.config.mjs, tsconfig.json');
+
+  // ----------------------------------------------------------
+  // 12. Summary
+  // ----------------------------------------------------------
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+  const totalPages = allResults.length;
+
+  console.log('\n' + '='.repeat(50));
+  console.log('Astro export complete!');
+  console.log(`  Pages: ${totalPages - cmsPageCount}`);
+  if (cmsPageCount > 0) {
+    console.log(`  CMS pages: ${cmsPageCount}`);
+  }
+  if (collectionCount > 0) {
+    console.log(`  Content collections: ${collectionCount}`);
+  }
+  if (errorCount > 0) {
+    console.log(`  Errors: ${errorCount}`);
+  }
+  console.log(`  Time: ${elapsed}s`);
+  console.log(`  Output: ${outDir}`);
+  console.log('');
+
+  return {
+    pages: totalPages - cmsPageCount,
+    cmsPages: cmsPageCount,
+    collections: collectionCount,
+    errors: errorCount,
+  };
+}