meno-core 1.0.38 → 1.0.40

package/build-astro.ts

@@ -0,0 +1,1041 @@
+/**
+ * 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 { emitCMSPage } from './lib/server/astro/cmsPageEmitter';
+import { collectAllMappingClasses } from "./lib/server/astro/cssCollector";
+import { buildImageMetadataMap } from "./lib/server/ssr/imageMetadata";
+import { extractUtilityClassesFromHTML, generateUtilityCSS } from "./lib/shared/cssGeneration";
+
+// ---------------------------------------------------------------------------
+// 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, '\\${');
+}
+
+/**
+ * Compute locale → URL path map for a page's slug translations.
+ * Used by locale list rendering to generate correct links.
+ */
+function computePageSlugMap(
+  slugs: Record<string, string>,
+  i18nConfig: I18nConfig
+): Record<string, string> {
+  const map: Record<string, string> = {};
+  for (const localeConfig of i18nConfig.locales) {
+    const code = localeConfig.code;
+    const isDefault = code === i18nConfig.defaultLocale;
+    const slug = slugs[code] || '';
+    if (isDefault) {
+      map[code] = slug === '' ? '/' : `/${slug}`;
+    } else {
+      map[code] = slug === '' ? `/${code}` : `/${code}/${slug}`;
+    }
+  }
+  return map;
+}
+
+/**
+ * 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':
+      // Support both plain strings and i18n objects { _i18n: true, en: "...", pl: "..." }
+      return 'z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()])';
+    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;
+  /** SSR fallback HTML for complex nodes (list, locale-list) keyed by element path */
+  ssrFallbackCollector?: Map<string, string>;
+}
+
+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);
+
+  // Build image metadata map for responsive image generation
+  const imageMetadataMap = await buildImageMetadataMap();
+  if (imageMetadataMap.size > 0) {
+    console.log(`Loaded image metadata for ${imageMetadataMap.size} image(s)\n`);
+  }
+
+  // ----------------------------------------------------------
+  // 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>; ssrFallbackCollector?: Map<string, 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,
+      ssrFallbackCollector: result.ssrFallbackCollector,
+    });
+  }
+
+  // ---------- 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++;
+    }
+  }
+
+  // Pre-compute layout dependencies needed by both CMS and regular page emission
+  const fontPreloads = generateFontPreloadTags();
+  const mergedLibraries = mergeLibraries(globalLibraries, componentLibraries);
+  const buildLibraries = filterLibrariesByContext(mergedLibraries, 'build');
+  const libraryTags = generateLibraryTags(buildLibraries);
+  const defaultTheme = themeConfig.default || 'light';
+
+  // ---------- 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}`);
+
+        // Count items for stats
+        const items = await cmsService.queryItems({ collection: cmsSchema.id });
+        const itemCount = items.length;
+
+        if (itemCount === 0) {
+          console.log(`    No items found in cms/${cmsSchema.id}/`);
+        } else {
+          console.log(`    Found ${itemCount} item(s)`);
+        }
+
+        // Render SSR once for metadata collection (interactive styles, component CSS, JS)
+        const defaultLocale = i18nConfig.defaultLocale;
+        const dummyPath = cmsSchema.urlPattern.replace('{{slug}}', '__placeholder__');
+
+        const metaResult = await renderPageSSR(
+          pageData,
+          globalComponents,
+          dummyPath,
+          siteUrl,
+          defaultLocale,
+          i18nConfig,
+          slugMappings,
+          undefined, // no CMS context - just collecting metadata
+          cmsService,
+          true
+        );
+
+        // Collect interactive styles and component CSS
+        mergeInteractiveStyles(metaResult.interactiveStylesMap);
+        if (metaResult.componentCSS) {
+          allComponentCSS.add(metaResult.componentCSS);
+        }
+
+        // Deduplicate JavaScript by content hash
+        const scriptPaths: string[] = [];
+        if (metaResult.javascript) {
+          const hash = hashContent(metaResult.javascript);
+          if (!jsContents.has(hash)) {
+            jsContents.set(hash, metaResult.javascript);
+          }
+          scriptPaths.push(`/_scripts/${hash}.js`);
+        }
+
+        // Determine route file path from urlPattern
+        const isMultiLocale = i18nConfig.locales.length > 1;
+        const urlPatternWithoutSlash = cmsSchema.urlPattern.replace(/^\//, '');
+        const slugPlaceholderIdx = urlPatternWithoutSlash.indexOf('{{');
+        const pathPrefix = slugPlaceholderIdx > 0 ? urlPatternWithoutSlash.substring(0, slugPlaceholderIdx) : '';
+
+        // Generate CMS page with getStaticPaths()
+        const ssrFallbacks = metaResult.ssrFallbackCollector ?? new Map<string, string>();
+
+        // For each locale (or just default), generate a route file
+        const localesToEmit = isMultiLocale ? i18nConfig.locales : [{ code: i18nConfig.defaultLocale }];
+
+        for (const localeEntry of localesToEmit) {
+          const localeCode = localeEntry.code;
+          const isDefault = localeCode === i18nConfig.defaultLocale;
+
+          // Route file path: blog/[slug].astro for default, pl/blog/[slug].astro for non-default
+          let astroFilePath: string;
+          if (pathPrefix) {
+            astroFilePath = isDefault
+              ? `${pathPrefix}[slug].astro`
+              : `${localeCode}/${pathPrefix}[slug].astro`;
+          } else {
+            astroFilePath = isDefault
+              ? '[slug].astro'
+              : `${localeCode}/[slug].astro`;
+          }
+
+          const fileDepth = astroFilePath.split('/').length - 1;
+          const importPath = layoutImportPath(fileDepth);
+
+          const astroContent = emitCMSPage({
+            pageData,
+            globalComponents,
+            cmsSchema,
+            title: String(pageData.meta?.title || cmsSchema.name),
+            meta: metaResult.meta,
+            locale: localeCode,
+            theme: defaultTheme,
+            fontPreloads,
+            libraryTags,
+            scriptPaths,
+            layoutImportPath: importPath,
+            fileDepth,
+            ssrFallbacks,
+            pageName: file.replace('.json', ''),
+            breakpoints,
+            imageMetadataMap,
+            i18nConfig,
+            isMultiLocale: false, // Each file handles one locale
+            slugMappings,
+          });
+
+          const astroFileFull = join(pagesOutDir, astroFilePath);
+          const astroFileDir = astroFileFull.substring(0, astroFileFull.lastIndexOf('/'));
+          if (!existsSync(astroFileDir)) {
+            mkdirSync(astroFileDir, { recursive: true });
+          }
+
+          await writeFile(astroFileFull, astroContent, 'utf-8');
+        }
+
+        console.log(`    Generated: ${pathPrefix}[slug].astro (${itemCount} items × ${localesToEmit.length} locale(s))`);
+
+        cmsPageCount += itemCount * i18nConfig.locales.length;
+      } 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 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, i18nConfig.defaultLocale);
+      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 allFallbackHtml: string[] = []; // Collect SSR fallback HTML for utility CSS generation
+
+  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 pages with page data
+    if (result.pageData) {
+      try {
+        // Use SSR fallback collector from the initial render (paths already match nodeToAstro convention)
+        const ssrFallbacks = result.ssrFallbackCollector ?? new Map<string, string>();
+        ssrFallbacks.forEach((html) => {
+          allFallbackHtml.push(html);
+        });
+
+        // Compute slug map for locale list rendering
+        const pageSlugMap: Record<string, string> | undefined =
+          result.pageData.meta?.slugs
+            ? computePageSlugMap(result.pageData.meta.slugs, i18nConfig)
+            : undefined;
+
+        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,
+          pageName: result.pageName || 'index',
+          breakpoints,
+          imageMetadataMap,
+          i18nConfig: i18nConfig.locales.length > 1 ? i18nConfig : undefined,
+          currentPageSlugMap: pageSlugMap,
+          slugMappings: i18nConfig.locales.length > 1 ? slugMappings : undefined,
+        });
+      } 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 {
+      // Pages without pageData: use SSR fallback
+      astroContent = buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths);
+      allFallbackHtml.push(result.html);
+    }
+
+    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)`);
+
+  // ----------------------------------------------------------
+  // 8.5. Generate utility CSS for SSR fallback HTML
+  // ----------------------------------------------------------
+  if (allFallbackHtml.length > 0) {
+    const allClasses = new Set<string>();
+    for (const html of allFallbackHtml) {
+      for (const cls of extractUtilityClassesFromHTML(html)) {
+        allClasses.add(cls);
+      }
+    }
+    if (allClasses.size > 0) {
+      const utilityCSS = generateUtilityCSS(allClasses, breakpoints, responsiveScales);
+      if (utilityCSS) {
+        const existingCSS = await readFile(join(stylesDir, 'global.css'), 'utf-8');
+        await writeFile(join(stylesDir, 'global.css'), existingCSS + '\n\n/* SSR fallback utility classes */\n' + utilityCSS, 'utf-8');
+        console.log(`Added ${allClasses.size} utility classes for SSR fallback content`);
+      }
+    }
+  }
+
+  // ----------------------------------------------------------
+  // 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;
+
+            // Keep i18n values as-is so getStaticPaths() can resolve per-locale
+            const resolved: Record<string, unknown> = { ...item };
+
+            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/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 localeCodes = i18nConfig.locales.map(l => l.code);
+  const i18nBlock = i18nConfig.locales.length > 1
+    ? `\n  i18n: {\n    defaultLocale: '${i18nConfig.defaultLocale}',\n    locales: [${localeCodes.map(c => `'${c}'`).join(', ')}],\n    routing: { prefixDefaultLocale: false },\n  },`
+    : '';
+
+  const astroConfig = `import { defineConfig } from 'astro/config';
+import tailwind from '@astrojs/tailwind';
+
+export default defineConfig({${siteUrl ? `\n  site: '${siteUrl}',` : ''}${i18nBlock}
+  integrations: [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,
+  };
+}