meno-core 1.0.45 → 1.0.47

package/build-astro.ts

@@ -29,11 +29,10 @@ 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 { loadBreakpointConfig, loadResponsiveScalesConfig, 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";
@@ -41,7 +40,8 @@ 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 { buildImageMetadataMap, RESPONSIVE_WIDTHS } from "./lib/server/ssr/imageMetadata";
+import { needsFormHandler, formHandlerScript } from "./lib/client/scripts/formHandler";
 
 
 // ---------------------------------------------------------------------------
@@ -52,19 +52,50 @@ function hashContent(content: string): string {
   return createHash('sha256').update(content).digest('hex').slice(0, 8);
 }
 
-function copyDirectory(src: string, dest: string): void {
+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);
+    if (stat.isDirectory()) copyDirectory(srcPath, destPath, filter);
     else copyFileSync(srcPath, destPath);
   }
 }
 
+// Astro's <Picture> re-derives responsive variants from originals at build
+// time, so the pre-baked -{width}.webp/.avif files and the SSR-only
+// manifest.json are dead weight in the exported project.
+const imageVariantSuffixRe = new RegExp(
+  `-(${RESPONSIVE_WIDTHS.join('|')})\\.(webp|avif)$`,
+);
+function shouldCopyImageForAstro(filename: string): boolean {
+  if (filename === 'manifest.json') return false;
+  if (imageVariantSuffixRe.test(filename)) return false;
+  return true;
+}
+
 function isCMSPage(pageData: JSONPage): boolean {
   return pageData.meta?.source === 'cms' && !!pageData.meta?.cms;
 }
@@ -208,6 +239,8 @@ interface PageRenderResult {
   isCMSPage?: boolean;
   /** SSR fallback HTML for complex nodes (list, locale-list) keyed by element path */
   ssrFallbackCollector?: Map<string, string>;
+  /** Raw-HTML slice → processed HTML captured during SSR (for Astro exporter parity) */
+  processedRawHtmlCollector?: Map<string, string>;
 }
 
 interface AstroBuildStats {
@@ -264,10 +297,6 @@ 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
   // ----------------------------------------------------------
@@ -277,7 +306,6 @@ export async function buildAstroProject(
   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();
 
@@ -286,12 +314,10 @@ export async function buildAstroProject(
   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();
@@ -305,9 +331,6 @@ export async function buildAstroProject(
 
   // 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
@@ -346,8 +369,6 @@ export async function buildAstroProject(
     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) {
@@ -372,6 +393,7 @@ export async function buildAstroProject(
   const allComponentCSS = new Set<string>();
   const jsContents = new Map<string, string>(); // hash -> JS content
   let errorCount = 0;
+  let projectNeedsFormHandler = false;
 
   // Helper to merge interactive styles maps
   function mergeInteractiveStyles(source: Map<string, InteractiveStyles>): void {
@@ -384,7 +406,7 @@ export async function buildAstroProject(
 
   // 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> },
+    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>; processedRawHtmlCollector?: Map<string, string> },
     urlPath: string,
     astroFilePath: string,
     fileDepth: number,
@@ -408,6 +430,11 @@ export async function buildAstroProject(
       }
     }
 
+    // Detect forms that need the fetch handler
+    if (!projectNeedsFormHandler && needsFormHandler(result.html)) {
+      projectNeedsFormHandler = true;
+    }
+
     allResults.push({
       html: result.html,
       meta: result.meta,
@@ -423,6 +450,7 @@ export async function buildAstroProject(
       pageName,
       isCMSPage,
       ssrFallbackCollector: result.ssrFallbackCollector,
+      processedRawHtmlCollector: result.processedRawHtmlCollector,
     });
   }
 
@@ -444,7 +472,6 @@ export async function buildAstroProject(
       // 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;
       }
 
@@ -487,7 +514,6 @@ export async function buildAstroProject(
         );
 
         processRenderResult(result, urlPath, astroFilePath, fileDepth, pageData, pageName, false);
-        console.log(`  Rendered: ${urlPath}`);
       }
     } catch (error: any) {
       console.error(`  Error rendering ${basePath}:`, error?.message || error);
@@ -499,9 +525,56 @@ export async function buildAstroProject(
   const fontPreloads = generateFontPreloadTags();
   const mergedLibraries = mergeLibraries(globalLibraries, componentLibraries);
   const buildLibraries = filterLibrariesByContext(mergedLibraries, 'build');
-  const libraryTags = generateLibraryTags(buildLibraries);
+
+  // Mirror htmlGenerator.ts: local CSS libraries with `inline !== false` are inlined
+  // into a <style> tag, otherwise the file is copied to public/ so the <link href>
+  // resolves. This keeps any `/some-file.css` referenced in project.config.json
+  // libraries working, not just the special `custom.css` case.
+  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';
 
+  // Global customCode (head/bodyStart/bodyEnd) and icons from project.config.json
+  // are page-independent, so we bake them directly into BaseLayout.astro rather
+  // than plumbing them through every page's props. Mirrors htmlGenerator.ts's
+  // SSR output (htmlGenerator.ts:269-507 for customCode, 368-473 for icons).
+  const customCode = configService.getCustomCode();
+  const iconsConfig = await loadIconsConfig();
+  const faviconTag = iconsConfig.favicon
+    ? `<link rel="icon" href="${iconsConfig.favicon.replace(/"/g, '&quot;')}" />`
+    : '';
+  const appleTouchIconTag = iconsConfig.appleTouchIcon
+    ? `<link rel="apple-touch-icon" href="${iconsConfig.appleTouchIcon.replace(/"/g, '&quot;')}" />`
+    : '';
+  const iconTagsHtml = [faviconTag, appleTouchIconTag].filter(Boolean).join('\n  ');
+
+  const remConversionConfig = configService.getRemConversion();
+
   // ---------- CMS template pages ----------
   const templatesDir = projectPaths.templates();
   const templateSchemas: CMSSchema[] = [];
@@ -510,10 +583,6 @@ export async function buildAstroProject(
   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;
@@ -523,7 +592,6 @@ export async function buildAstroProject(
 
         const isDevBuild = process.env.MENO_DEV_BUILD === 'true';
         if (pageData.meta?.draft === true && !isDevBuild) {
-          console.log(`  Skipping draft template: ${file}`);
           continue;
         }
 
@@ -534,18 +602,11 @@ export async function buildAstroProject(
 
         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__');
@@ -626,11 +687,14 @@ export async function buildAstroProject(
             ssrFallbacks,
             pageName: file.replace('.json', ''),
             breakpoints,
+            responsiveScales,
             imageMetadataMap,
             i18nConfig,
             isMultiLocale: false, // Each file handles one locale
             slugMappings,
             imageFormat: configService.getImageFormat(),
+            processedRawHtml: metaResult.processedRawHtmlCollector,
+            remConfig: remConversionConfig,
           });
 
           const astroFileFull = join(pagesOutDir, astroFilePath);
@@ -642,8 +706,6 @@ export async function buildAstroProject(
           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);
@@ -656,39 +718,56 @@ export async function buildAstroProject(
   // 6. Generate global CSS (Tailwind + theme + interactive styles)
   // ----------------------------------------------------------
   // Collect Tailwind safelist classes from mapping variants
-  const mappingClasses = collectAllMappingClasses(globalComponents, breakpoints);
+  const mappingClasses = collectAllMappingClasses(globalComponents, breakpoints, responsiveScales);
 
   const fontCSS = generateFontCSS();
   const themeColorCSS = generateThemeColorVariablesCSS(themeConfig);
   const variablesCSS = generateVariablesCSS(variablesConfig, breakpoints, responsiveScales);
-  const remConversionConfig = configService.getRemConversion();
-  const interactiveCSS = generateAllInteractiveCSS(allInteractiveStyles, breakpoints, remConversionConfig);
   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%; }
+  img { max-width: 100%; height: auto; }
   picture { display: block; }
-  .olink { text-decoration: none; display: block; }
+  .olink { text-decoration: none; display: block; color: inherit; }
   .oem { display: inline-block; }
 }`;
 
-  const tailwindDirectives = `@tailwind base;
-@tailwind components;
-@tailwind utilities;`;
+  const safelistClasses = Array.from(mappingClasses);
+  const safelistDirectives = safelistClasses
+    .map(c => `@source inline("${c}");`)
+    .join('\n');
+  const tailwindDirectives = safelistDirectives
+    ? `@import "tailwindcss";\n\n${safelistDirectives}`
+    : `@import "tailwindcss";`;
 
-  const globalCSS = [tailwindDirectives, fontCSS, themeColorCSS, variablesCSS, baseCSS, componentCSSCombined, interactiveCSS]
+  const globalCSS = [tailwindDirectives, fontCSS, themeColorCSS, variablesCSS, baseCSS, componentCSSCombined]
     .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
   // ----------------------------------------------------------
+  // Escape for embedding inside Astro <Fragment set:html={`...`}> template
+  // literals in the generated BaseLayout file.
+  const escForTemplateLiteral = (s: string) => s
+    .replace(/\\/g, '\\\\')
+    .replace(/`/g, '\\`')
+    .replace(/\$\{/g, '\\${');
+
+  const customHeadLiteral = escForTemplateLiteral(customCode.head || '');
+  const customBodyStartLiteral = escForTemplateLiteral(customCode.bodyStart || '');
+  const customBodyEndLiteral = escForTemplateLiteral(customCode.bodyEnd || '');
+  const iconTagsLiteral = escForTemplateLiteral(iconTagsHtml);
+
+  const formHandlerBlock = projectNeedsFormHandler
+    ? `\n  <script is:inline>\n${formHandlerScript}\n  </script>`
+    : '';
+
   const baseLayoutContent = `---
 import '../styles/global.css';
 
@@ -709,22 +788,25 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <Fragment set:html={\`${iconTagsLiteral}\`} />
   <Fragment set:html={fontPreloads} />
   <Fragment set:html={libraryTags.headCSS || ''} />
   <Fragment set:html={libraryTags.headJS || ''} />
   <Fragment set:html={meta} />
+  <Fragment set:html={\`${customHeadLiteral}\`} />
   <title>{title}</title>
 </head>
 <body>
+  <Fragment set:html={\`${customBodyStartLiteral}\`} />
   <slot />
   {scripts.map((s) => <script src={s} />)}
   <Fragment set:html={libraryTags.bodyEndJS || ''} />
+  <Fragment set:html={\`${customBodyEndLiteral}\`} />${formHandlerBlock}
 </body>
 </html>
 `;
 
   await writeFile(join(layoutsDir, 'BaseLayout.astro'), baseLayoutContent, 'utf-8');
-  console.log('Generated BaseLayout.astro');
 
   // ----------------------------------------------------------
   // 7.5. Generate component .astro files
@@ -732,38 +814,21 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
   let componentFileCount = 0;
   for (const [compName, compDef] of Object.entries(globalComponents)) {
     try {
-      const astroContent = emitAstroComponent(compName, compDef, globalComponents, breakpoints, i18nConfig.defaultLocale);
+      const astroContent = emitAstroComponent(compName, compDef, globalComponents, breakpoints, i18nConfig.defaultLocale, responsiveScales, remConversionConfig);
       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)
   // ----------------------------------------------------------
   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);
-    }
+    // Write JavaScript to public/_scripts/ if present (only needed for SSR fallback pages)
+    let scriptPaths: string[] = [];
 
     let astroContent: string;
 
@@ -779,6 +844,8 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
             ? computePageSlugMap(result.pageData.meta.slugs, i18nConfig)
             : undefined;
 
+        // Component-structured pages don't need page-level _scripts/*.js
+        // because each .astro component already has its own inline <script>
         astroContent = emitAstroPage({
           pageData: result.pageData,
           globalComponents,
@@ -788,25 +855,30 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
           theme: defaultTheme,
           fontPreloads,
           libraryTags,
-          scriptPaths,
+          scriptPaths: [],
           layoutImportPath: importPath,
           fileDepth: result.fileDepth,
           ssrFallbacks,
           pageName: result.pageName || 'index',
           breakpoints,
+          responsiveScales,
           imageMetadataMap,
           i18nConfig: i18nConfig.locales.length > 1 ? i18nConfig : undefined,
           currentPageSlugMap: pageSlugMap,
           slugMappings: i18nConfig.locales.length > 1 ? slugMappings : undefined,
           imageFormat: configService.getImageFormat(),
+          processedRawHtml: result.processedRawHtmlCollector,
+          remConfig: remConversionConfig,
         });
       } catch (error: any) {
-        // Fallback to SSR HTML if component emission fails
+        // Fallback to SSR HTML if component emission fails — needs page-level script
         console.warn(`  Warning: component emission failed for ${result.urlPath}, using SSR fallback: ${error?.message}`);
+        scriptPaths = writePageScript(result.javascript, scriptsDir);
         astroContent = buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths);
       }
     } else {
-      // Pages without pageData: use SSR fallback
+      // Pages without pageData: use SSR fallback — needs page-level script
+      scriptPaths = writePageScript(result.javascript, scriptsDir);
       astroContent = buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths);
     }
 
@@ -819,7 +891,26 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
     await writeFile(astroFileFull, astroContent, 'utf-8');
   }
 
-  console.log(`Generated ${allResults.length} .astro page file(s)`);
+  // ----------------------------------------------------------
+  // 8.5. Generate robots.txt endpoint
+  // ----------------------------------------------------------
+  const robotsTsContent = `import type { APIRoute } from 'astro';
+
+export const GET: APIRoute = () => {
+  const siteUrl = import.meta.env.SITE;
+  const robotsTxt = [
+    'User-agent: *',
+    'Allow: /',
+    '',
+    siteUrl ? \`Sitemap: \${siteUrl}/sitemap-index.xml\` : '',
+  ].filter(Boolean).join('\\n');
+
+  return new Response(robotsTxt, {
+    headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+  });
+};
+`;
+  await writeFile(join(pagesOutDir, 'robots.txt.ts'), robotsTsContent, 'utf-8');
 
   // ----------------------------------------------------------
   // 9. Generate CMS content collections (if templates exist)
@@ -871,7 +962,7 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
       }
 
       collectionDefs.push(`  '${schema.id}': defineCollection({
-    type: 'data',
+    loader: glob({ pattern: '**/*.json', base: './src/content/${schema.id}' }),
     schema: z.object({
 ${fieldDefs.join(',\n')}
     })
@@ -880,8 +971,9 @@ ${fieldDefs.join(',\n')}
       collectionCount++;
     }
 
-    // Write src/content/config.ts
+    // Write src/content.config.ts (Astro 6 location — legacy src/content/config.ts is rejected)
     const configContent = `import { z, defineCollection } from 'astro:content';
+import { glob } from 'astro/loaders';
 
 const collections = {
 ${collectionDefs.join(',\n')}
@@ -890,33 +982,53 @@ ${collectionDefs.join(',\n')}
 export { collections };
 `;
 
-    await writeFile(join(contentDir, 'config.ts'), configContent, 'utf-8');
-    console.log(`Generated ${collectionCount} content collection(s) with config.ts`);
+    await writeFile(join(srcDir, 'content.config.ts'), configContent, 'utf-8');
   }
 
   // ----------------------------------------------------------
-  // 10. Copy assets to public/
+  // 10. Copy assets
   // ----------------------------------------------------------
-  const assetDirs = ['fonts', 'images', 'icons', 'videos', 'assets'];
-  let copiedAssets = 0;
+  // Images go to src/assets/images so Astro's asset pipeline can process
+  // them via astro:assets `<Picture>` (hashing, on-edit reprocessing).
+  // Everything else stays in public/ — fonts/icons/videos need stable URLs.
+
+  const imagesSrcDir = join(projectPaths.project, 'images');
+  if (existsSync(imagesSrcDir)) {
+    // src/assets/images: used by static <Picture> via ESM imports + Vite asset
+    // pipeline. Pre-baked responsive variants and manifest.json are excluded —
+    // Astro regenerates those from the originals.
+    copyDirectory(imagesSrcDir, join(srcDir, 'assets', 'images'), shouldCopyImageForAstro);
+    // public/images: used by the legacy <img>/<picture> srcset path and
+    // rich-text image rewrites, which emit plain `/images/...` URLs pointing at
+    // the pre-built variants. Without this mirror, any image not routed through
+    // the static Picture path (variants referenced directly in a srcset,
+    // CMS/template-bound images, component-prop images) 404s in `astro dev`.
+    copyDirectory(imagesSrcDir, join(publicDir, 'images'));
+  }
 
-  for (const dir of assetDirs) {
+  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));
-      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/`);
+  // Copy any project-root library files referenced by absolute URL in
+  // project.config.json (e.g. `/custom.css`). Only copies entries we already
+  // validated exist on disk during library tag generation above.
+  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);
   }
 
   // ----------------------------------------------------------
@@ -936,9 +1048,14 @@ export { collections };
       preview: 'astro preview',
     },
     dependencies: {
-      'astro': '^4.0.0',
-      '@astrojs/tailwind': '^5.0.0',
-      'tailwindcss': '^3.4.0',
+      'astro': '^6.0.0',
+      '@astrojs/sitemap': '^3.0.0',
+      '@tailwindcss/vite': '^4.0.0',
+      'tailwindcss': '^4.0.0',
+    },
+    // Astro 6 expects Vite 7; pin it so npm doesn't pull Vite 8+ and warn.
+    overrides: {
+      'vite': '^7.0.0',
     },
   };
 
@@ -951,31 +1068,17 @@ export { collections };
     : '';
 
   const astroConfig = `import { defineConfig } from 'astro/config';
-import tailwind from '@astrojs/tailwind';
+import tailwindcss from '@tailwindcss/vite';
+import sitemap from '@astrojs/sitemap';
 
 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: {},
+  integrations: [sitemap()],
+  vite: {
+    plugins: [tailwindcss()],
   },
-  plugins: [],
-};
+});
 `;
 
-  await writeFile(join(outDir, 'tailwind.config.mjs'), tailwindConfig, 'utf-8');
-
   await writeFile(join(outDir, 'astro.config.mjs'), astroConfig, 'utf-8');
 
   // tsconfig.json
@@ -985,30 +1088,14 @@ export default {
 
   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');
+  // src/env.d.ts — resolves astro:assets and other virtual module types in IDE
+  await writeFile(join(outDir, 'src', 'env.d.ts'), '/// <reference path="../.astro/types.d.ts" />\n', 'utf-8');
 
   // ----------------------------------------------------------
   // 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,