meno-core 1.0.38 → 1.0.39

package/dist/lib/server/index.js

@@ -3,7 +3,7 @@ import {
 } from "../../chunks/chunk-4OFZP5NQ.js";
 import {
   buildStaticPages
-} from "../../chunks/chunk-JACS3C25.js";
+} from "../../chunks/chunk-WK5XLASY.js";
 import {
   ComponentService,
   EnumService,
@@ -32,7 +32,7 @@ import {
   logResponseTime,
   withErrorHandling,
   withLogging
-} from "../../chunks/chunk-UR7L5UZ3.js";
+} from "../../chunks/chunk-HNAS6BSS.js";
 import {
   CMSService,
   ColorService,
@@ -46,22 +46,37 @@ import {
   clearJSValidationCache,
   collectComponentCSS,
   collectComponentJavaScript,
+  collectComponentLibraries,
   colorService,
   createI18nResolver,
   escapeHtml,
   extractPageMeta,
+  filterLibrariesByContext,
+  generateFontCSS,
+  generateFontPreloadTags,
+  generateLibraryTags,
   generateMetaTags,
   generateSSRHTML,
+  generateThemeColorVariablesCSS,
+  generateVariablesCSS,
   getJSValidationErrors,
+  loadBreakpointConfig,
+  loadComponentDirectory,
+  loadI18nConfig,
+  loadJSONFile,
   loadProjectConfig,
+  loadResponsiveScalesConfig,
+  mapPageNameToPath,
+  mergeLibraries,
   migrateTemplatesDirectory,
+  parseJSON,
   processCMSPropsTemplate,
   processCMSTemplate,
   renderPageSSR,
   resetFontConfig,
   styleToString,
   variableService
-} from "../../chunks/chunk-EUCAKI5U.js";
+} from "../../chunks/chunk-W6HDII4T.js";
 import {
   ConfigService,
   configService
@@ -97,18 +112,1837 @@ import {
 import "../../chunks/chunk-LIHJ6OUH.js";
 import "../../chunks/chunk-P3FX5HJM.js";
 import "../../chunks/chunk-AIXKUVNG.js";
-import "../../chunks/chunk-NV25WXCA.js";
-import "../../chunks/chunk-PGH3ATYI.js";
+import {
+  extractInteractiveStyleMappings,
+  generateAllInteractiveCSS,
+  generateElementClassName,
+  hasInteractiveStyleMappings,
+  isItemDraftForLocale,
+  isVoidElement
+} from "../../chunks/chunk-NV25WXCA.js";
+import {
+  DEFAULT_BREAKPOINTS,
+  isI18nValue,
+  resolveI18nValue
+} from "../../chunks/chunk-PGH3ATYI.js";
 import "../../chunks/chunk-UB44F4Z2.js";
 import {
   HMR_ROUTE,
   MAX_PORT_ATTEMPTS,
+  NODE_TYPE,
   SERVER_PORT,
   SERVE_PORT,
   init_constants
 } from "../../chunks/chunk-KULPBDC7.js";
 import "../../chunks/chunk-KSBZ2L7C.js";
 
+// build-astro.ts
+import { existsSync, readdirSync, mkdirSync, rmSync, statSync, copyFileSync } from "fs";
+import { writeFile as writeFile2, readFile } from "fs/promises";
+import { join } from "path";
+import { createHash } from "crypto";
+
+// lib/server/astro/tailwindMapper.ts
+function isStyleMapping(value) {
+  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
+}
+function hasTemplateExpression(value) {
+  return /\{\{.+?\}\}/.test(value);
+}
+function isResponsiveStyle(style) {
+  return "base" in style || "tablet" in style || "mobile" in style;
+}
+var exactMatches = {
+  display: {
+    flex: "flex",
+    grid: "grid",
+    block: "block",
+    none: "hidden",
+    inline: "inline",
+    "inline-block": "inline-block",
+    "inline-flex": "inline-flex",
+    "inline-grid": "inline-grid"
+  },
+  flexDirection: {
+    column: "flex-col",
+    row: "flex-row",
+    "column-reverse": "flex-col-reverse",
+    "row-reverse": "flex-row-reverse"
+  },
+  justifyContent: {
+    center: "justify-center",
+    "flex-start": "justify-start",
+    "flex-end": "justify-end",
+    "space-between": "justify-between",
+    "space-around": "justify-around",
+    "space-evenly": "justify-evenly",
+    // camelCase aliases (component data uses camelCase)
+    spaceBetween: "justify-between",
+    spaceAround: "justify-around",
+    spaceEvenly: "justify-evenly",
+    flexStart: "justify-start",
+    flexEnd: "justify-end"
+  },
+  alignItems: {
+    center: "items-center",
+    "flex-start": "items-start",
+    "flex-end": "items-end",
+    stretch: "items-stretch",
+    baseline: "items-baseline",
+    // camelCase aliases
+    flexStart: "items-start",
+    flexEnd: "items-end"
+  },
+  alignContent: {
+    center: "content-center",
+    "flex-start": "content-start",
+    "flex-end": "content-end",
+    "space-between": "content-between",
+    "space-around": "content-around",
+    stretch: "content-stretch"
+  },
+  alignSelf: {
+    auto: "self-auto",
+    center: "self-center",
+    "flex-start": "self-start",
+    "flex-end": "self-end",
+    stretch: "self-stretch"
+  },
+  position: {
+    relative: "relative",
+    absolute: "absolute",
+    fixed: "fixed",
+    sticky: "sticky",
+    static: "static"
+  },
+  overflow: {
+    hidden: "overflow-hidden",
+    auto: "overflow-auto",
+    scroll: "overflow-scroll",
+    visible: "overflow-visible"
+  },
+  overflowX: {
+    hidden: "overflow-x-hidden",
+    auto: "overflow-x-auto",
+    scroll: "overflow-x-scroll",
+    visible: "overflow-x-visible"
+  },
+  overflowY: {
+    hidden: "overflow-y-hidden",
+    auto: "overflow-y-auto",
+    scroll: "overflow-y-scroll",
+    visible: "overflow-y-visible"
+  },
+  cursor: {
+    pointer: "cursor-pointer",
+    default: "cursor-default",
+    "not-allowed": "cursor-not-allowed",
+    grab: "cursor-grab",
+    grabbing: "cursor-grabbing",
+    text: "cursor-text",
+    move: "cursor-move",
+    wait: "cursor-wait"
+  },
+  textAlign: {
+    center: "text-center",
+    left: "text-left",
+    right: "text-right",
+    justify: "text-justify"
+  },
+  textDecoration: {
+    none: "no-underline",
+    underline: "underline",
+    "line-through": "line-through",
+    overline: "overline"
+  },
+  textTransform: {
+    uppercase: "uppercase",
+    lowercase: "lowercase",
+    capitalize: "capitalize",
+    none: "normal-case"
+  },
+  objectFit: {
+    cover: "object-cover",
+    contain: "object-contain",
+    fill: "object-fill",
+    none: "object-none",
+    "scale-down": "object-scale-down"
+  },
+  objectPosition: {
+    center: "object-center",
+    top: "object-top",
+    bottom: "object-bottom",
+    left: "object-left",
+    right: "object-right"
+  },
+  flexWrap: {
+    wrap: "flex-wrap",
+    nowrap: "flex-nowrap",
+    "wrap-reverse": "flex-wrap-reverse"
+  },
+  pointerEvents: {
+    none: "pointer-events-none",
+    auto: "pointer-events-auto"
+  },
+  userSelect: {
+    none: "select-none",
+    auto: "select-auto",
+    text: "select-text",
+    all: "select-all"
+  },
+  visibility: {
+    hidden: "invisible",
+    visible: "visible"
+  },
+  whiteSpace: {
+    normal: "whitespace-normal",
+    nowrap: "whitespace-nowrap",
+    pre: "whitespace-pre",
+    "pre-wrap": "whitespace-pre-wrap",
+    "pre-line": "whitespace-pre-line"
+  },
+  wordBreak: {
+    "break-all": "break-all",
+    "break-word": "break-words",
+    normal: "break-normal"
+  },
+  listStyleType: {
+    none: "list-none",
+    disc: "list-disc",
+    decimal: "list-decimal"
+  },
+  listStylePosition: {
+    inside: "list-inside",
+    outside: "list-outside"
+  },
+  boxSizing: {
+    "border-box": "box-border",
+    "content-box": "box-content"
+  },
+  gridAutoFlow: {
+    row: "grid-flow-row",
+    column: "grid-flow-col",
+    dense: "grid-flow-dense",
+    "row dense": "grid-flow-row-dense",
+    "column dense": "grid-flow-col-dense"
+  }
+};
+var singleValueMatches = {
+  // width/height 100%
+  "width:100%": "w-full",
+  "height:100%": "h-full",
+  "width:100vw": "w-screen",
+  "height:100vh": "h-screen",
+  "width:auto": "w-auto",
+  "height:auto": "h-auto",
+  "width:fit-content": "w-fit",
+  "height:fit-content": "h-fit",
+  "width:min-content": "w-min",
+  "height:min-content": "h-min",
+  "width:max-content": "w-max",
+  "height:max-content": "h-max",
+  "maxWidth:100%": "max-w-full",
+  "maxWidth:none": "max-w-none",
+  "maxHeight:100%": "max-h-full",
+  "maxHeight:none": "max-h-none",
+  "minWidth:0": "min-w-0",
+  "minHeight:0": "min-h-0",
+  "margin:auto": "m-auto",
+  "margin:0 auto": "mx-auto",
+  "marginLeft:auto": "ml-auto",
+  "marginRight:auto": "mr-auto",
+  "marginInline:auto": "mx-auto",
+  "borderRadius:50%": "rounded-full",
+  "borderRadius:9999px": "rounded-full",
+  "borderRadius:0": "rounded-none",
+  "flex:1": "flex-1",
+  "flex:none": "flex-none",
+  "flex:auto": "flex-auto",
+  "flexGrow:0": "grow-0",
+  "flexGrow:1": "grow",
+  "flexShrink:0": "shrink-0",
+  "flexShrink:1": "shrink",
+  "opacity:0": "opacity-0",
+  "opacity:1": "opacity-100",
+  "zIndex:0": "z-0",
+  "zIndex:10": "z-10",
+  "zIndex:20": "z-20",
+  "zIndex:30": "z-30",
+  "zIndex:40": "z-40",
+  "zIndex:50": "z-50",
+  "inset:0": "inset-0",
+  "top:0": "top-0",
+  "right:0": "right-0",
+  "bottom:0": "bottom-0",
+  "left:0": "left-0"
+};
+var arbitraryPrefixMap = {
+  // Spacing
+  padding: "p",
+  paddingTop: "pt",
+  paddingRight: "pr",
+  paddingBottom: "pb",
+  paddingLeft: "pl",
+  paddingInline: "px",
+  paddingBlock: "py",
+  margin: "m",
+  marginTop: "mt",
+  marginRight: "mr",
+  marginBottom: "mb",
+  marginLeft: "ml",
+  marginInline: "mx",
+  marginBlock: "my",
+  gap: "gap",
+  rowGap: "gap-y",
+  columnGap: "gap-x",
+  // Sizing
+  width: "w",
+  height: "h",
+  maxWidth: "max-w",
+  maxHeight: "max-h",
+  minWidth: "min-w",
+  minHeight: "min-h",
+  // Typography
+  fontSize: "text",
+  fontWeight: "font",
+  fontFamily: "font",
+  lineHeight: "leading",
+  letterSpacing: "tracking",
+  // Borders
+  borderRadius: "rounded",
+  borderTopLeftRadius: "rounded-tl",
+  borderTopRightRadius: "rounded-tr",
+  borderBottomLeftRadius: "rounded-bl",
+  borderBottomRightRadius: "rounded-br",
+  border: "border",
+  borderTop: "border-t",
+  borderRight: "border-r",
+  borderBottom: "border-b",
+  borderLeft: "border-l",
+  borderColor: "border",
+  // Colors
+  color: "text",
+  backgroundColor: "bg",
+  background: "bg",
+  backgroundImage: "bg",
+  // Effects
+  opacity: "opacity",
+  boxShadow: "shadow",
+  textShadow: "[text-shadow]",
+  filter: "[filter]",
+  backdropFilter: "backdrop",
+  transform: "[transform]",
+  transformOrigin: "origin",
+  transition: "transition",
+  mixBlendMode: "mix-blend",
+  clipPath: "[clip-path]",
+  // Positioning
+  top: "top",
+  right: "right",
+  bottom: "bottom",
+  left: "left",
+  inset: "inset",
+  zIndex: "z",
+  // Grid
+  gridTemplateColumns: "grid-cols",
+  gridTemplateRows: "grid-rows",
+  gridColumn: "col",
+  gridRow: "row",
+  gridAutoRows: "auto-rows",
+  gridAutoColumns: "auto-cols",
+  // Flexbox extras
+  flexGrow: "grow",
+  flexShrink: "shrink",
+  flexBasis: "basis",
+  order: "order",
+  flex: "flex",
+  // Aspect ratio
+  aspectRatio: "aspect",
+  // Outline
+  outline: "outline",
+  outlineWidth: "outline",
+  outlineOffset: "outline-offset",
+  outlineColor: "outline",
+  // Other
+  accentColor: "accent",
+  textIndent: "[text-indent]",
+  verticalAlign: "align",
+  overflowWrap: "[overflow-wrap]",
+  scrollBehavior: "scroll",
+  resize: "resize"
+};
+function propertyToTailwind(property, value) {
+  const strValue = String(value);
+  if (strValue === "") return null;
+  if (hasTemplateExpression(strValue)) return null;
+  const singleKey = `${property}:${strValue}`;
+  if (singleValueMatches[singleKey]) {
+    return singleValueMatches[singleKey];
+  }
+  if (exactMatches[property]?.[strValue]) {
+    return exactMatches[property][strValue];
+  }
+  if (property === "color" || property === "backgroundColor" || property === "borderColor") {
+    const prefix = property === "color" ? "text" : property === "backgroundColor" ? "bg" : "border";
+    if (strValue.includes("var(")) {
+      return `${prefix}-[${strValue}]`;
+    }
+    if (!strValue.match(/^[#\d]/) && !strValue.includes("rgb") && !strValue.includes("hsl")) {
+      return `${prefix}-[var(--${strValue})]`;
+    }
+  }
+  const twPrefix = arbitraryPrefixMap[property];
+  if (!twPrefix) {
+    const cssProp = property.replace(/([A-Z])/g, "-$1").toLowerCase();
+    const sanitized2 = strValue.replace(/\s+/g, "_");
+    return `[${cssProp}:${sanitized2}]`;
+  }
+  if (twPrefix.startsWith("[")) {
+    const sanitized2 = strValue.replace(/\s+/g, "_");
+    return `${twPrefix.slice(0, -1)}:${sanitized2}]`;
+  }
+  const sanitized = strValue.replace(/\s+/g, "_");
+  if (property === "fontFamily" && !sanitized.includes(",") && !sanitized.startsWith("'")) {
+    return `${twPrefix}-['${sanitized}']`;
+  }
+  return `${twPrefix}-[${sanitized}]`;
+}
+function stylesToTailwind(style) {
+  const classes = [];
+  const dynamicStyles = {};
+  for (const [prop, value] of Object.entries(style)) {
+    if (isStyleMapping(value)) continue;
+    const strValue = String(value);
+    if (hasTemplateExpression(strValue)) {
+      const cssProp = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+      dynamicStyles[cssProp] = strValue;
+      continue;
+    }
+    const twClass = propertyToTailwind(prop, value);
+    if (twClass) {
+      classes.push(twClass);
+    }
+  }
+  return { classes, dynamicStyles };
+}
+function responsiveStylesToTailwind(style, breakpoints) {
+  if (!style) return { classes: [], dynamicStyles: {} };
+  const allClasses = [];
+  const allDynamicStyles = {};
+  if (isResponsiveStyle(style)) {
+    const responsive = style;
+    if (responsive.base) {
+      const { classes, dynamicStyles } = stylesToTailwind(responsive.base);
+      allClasses.push(...classes);
+      Object.assign(allDynamicStyles, dynamicStyles);
+    }
+    if (responsive.tablet) {
+      const bpValue = breakpoints.tablet?.breakpoint ?? 1024;
+      const prefix = `max-[${bpValue}px]:`;
+      const { classes, dynamicStyles } = stylesToTailwind(responsive.tablet);
+      allClasses.push(...classes.map((cls) => `${prefix}${cls}`));
+      Object.assign(allDynamicStyles, dynamicStyles);
+    }
+    if (responsive.mobile) {
+      const bpValue = breakpoints.mobile?.breakpoint ?? 540;
+      const prefix = `max-[${bpValue}px]:`;
+      const { classes, dynamicStyles } = stylesToTailwind(responsive.mobile);
+      allClasses.push(...classes.map((cls) => `${prefix}${cls}`));
+      Object.assign(allDynamicStyles, dynamicStyles);
+    }
+    for (const [bpName, bpStyle] of Object.entries(responsive)) {
+      if (bpName === "base" || bpName === "tablet" || bpName === "mobile" || !bpStyle) continue;
+      const bpValue = breakpoints[bpName]?.breakpoint;
+      if (!bpValue) continue;
+      const prefix = `max-[${bpValue}px]:`;
+      const { classes, dynamicStyles } = stylesToTailwind(bpStyle);
+      allClasses.push(...classes.map((cls) => `${prefix}${cls}`));
+      Object.assign(allDynamicStyles, dynamicStyles);
+    }
+  } else {
+    const { classes, dynamicStyles } = stylesToTailwind(style);
+    allClasses.push(...classes);
+    Object.assign(allDynamicStyles, dynamicStyles);
+  }
+  return { classes: allClasses, dynamicStyles: allDynamicStyles };
+}
+
+// lib/server/astro/nodeToAstro.ts
+init_constants();
+function ind(ctx) {
+  return "  ".repeat(ctx.indent);
+}
+function isStyleMapping2(value) {
+  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
+}
+function isLinkMapping(value) {
+  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
+}
+function isHtmlMapping(value) {
+  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
+}
+function isResponsiveStyle2(style) {
+  return "base" in style || "tablet" in style || "mobile" in style;
+}
+function escapeJSX(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeTemplateLiteral(s) {
+  return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function collectStyleMappings(style) {
+  if (!style) return [];
+  const result = [];
+  if (isResponsiveStyle2(style)) {
+    const responsive = style;
+    for (const [bp, bpStyle] of Object.entries(responsive)) {
+      if (!bpStyle) continue;
+      for (const [prop, value] of Object.entries(bpStyle)) {
+        if (isStyleMapping2(value)) {
+          result.push({ property: prop, mapping: value, breakpoint: bp });
+        }
+      }
+    }
+  } else {
+    for (const [prop, value] of Object.entries(style)) {
+      if (isStyleMapping2(value)) {
+        result.push({ property: prop, mapping: value });
+      }
+    }
+  }
+  return result;
+}
+function mappingToClassListEntries(mapping, property, breakpointPrefix, ctx) {
+  const entries = [];
+  const values = Object.entries(mapping.values);
+  if (values.length === 0) return entries;
+  const propRef = ctx.isComponentDef ? mapping.prop : mapping.prop;
+  if (values.length === 2) {
+    const [[val1, css1], [val2, css2]] = values;
+    const cls1 = getClassForValue(property, css1, breakpointPrefix);
+    const cls2 = getClassForValue(property, css2, breakpointPrefix);
+    if (cls1 && cls2) {
+      entries.push(`${propRef} === ${JSON.stringify(coerceValue(val1))} ? '${cls1}' : '${cls2}'`);
+    }
+  } else {
+    for (const [val, cssValue] of values) {
+      const cls = getClassForValue(property, cssValue, breakpointPrefix);
+      if (cls) {
+        entries.push(`${propRef} === ${JSON.stringify(coerceValue(val))} && '${cls}'`);
+      }
+    }
+  }
+  return entries;
+}
+function coerceValue(val) {
+  if (val === "true") return true;
+  if (val === "false") return false;
+  return val;
+}
+function getClassForValue(property, value, breakpointPrefix) {
+  const twClass = propertyToTailwind(property, value);
+  if (!twClass) return null;
+  return breakpointPrefix ? `${breakpointPrefix}${twClass}` : twClass;
+}
+function buildClassAndStyleExpression(style, interactiveStyles, elementClass, ctx) {
+  const result = style ? responsiveStylesToTailwind(style, ctx.breakpoints) : { classes: [], dynamicStyles: {} };
+  const staticClasses = result.classes;
+  const dynamicStyles = result.dynamicStyles;
+  if (elementClass) {
+    staticClasses.unshift(elementClass);
+  }
+  const conditionals = [];
+  const mappings = collectStyleMappings(style);
+  for (const { property, mapping, breakpoint } of mappings) {
+    const bpValue = breakpoint === "tablet" ? ctx.breakpoints.tablet?.breakpoint ?? 1024 : breakpoint === "mobile" ? ctx.breakpoints.mobile?.breakpoint ?? 540 : 0;
+    const prefix = bpValue ? `max-[${bpValue}px]:` : "";
+    const entries = mappingToClassListEntries(mapping, property, prefix, ctx);
+    conditionals.push(...entries);
+  }
+  let styleAttr = "";
+  if (Object.keys(dynamicStyles).length > 0 && ctx.isComponentDef) {
+    const styleParts = [];
+    for (const [cssProp, value] of Object.entries(dynamicStyles)) {
+      const resolved = value.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
+      styleParts.push(`${cssProp}: \${${resolved.includes("${") ? resolved.replace(/\$\{(.+?)\}/g, "$1") : `'${resolved}'`}}`);
+    }
+    const entries = [];
+    for (const [cssProp, value] of Object.entries(dynamicStyles)) {
+      const resolved = value.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
+      entries.push(`${cssProp}: ${resolved}`);
+    }
+    styleAttr = ` style={\`${entries.join("; ")}\`}`;
+  }
+  if (interactiveStyles && interactiveStyles.length > 0 && ctx.isComponentDef && hasInteractiveStyleMappings(interactiveStyles)) {
+    const { mappings: mappings2 } = extractInteractiveStyleMappings(interactiveStyles);
+    if (mappings2.length > 0) {
+      const varParts = [];
+      for (const extracted of mappings2) {
+        const { mapping, variableIndex } = extracted;
+        const varName = `--is-${variableIndex}`;
+        const entries = Object.entries(mapping.values);
+        if (entries.length === 2) {
+          const [[val1, css1], [val2, css2]] = entries;
+          varParts.push(`'${varName}': ${mapping.prop} === ${JSON.stringify(coerceValue(val1))} ? '${css1}' : '${css2}'`);
+        } else {
+          const lookupEntries = entries.filter(([, v]) => v !== "").map(([k, v]) => `${JSON.stringify(coerceValue(k))}: '${v}'`).join(", ");
+          varParts.push(`'${varName}': ({${lookupEntries}})[${mapping.prop}] || ''`);
+        }
+      }
+      if (varParts.length > 0) {
+        const existingStyleParts = styleAttr ? styleAttr.replace(/^ style=\{`/, "").replace(/`\}$/, "") : "";
+        const varStyleExpr = varParts.join(", ");
+        if (existingStyleParts) {
+          styleAttr = ` style={\`${existingStyleParts}; \${ Object.entries({${varStyleExpr}}).map(([k,v]) => \`\${k}:\${v}\`).join(';') }\`}`;
+        } else {
+          styleAttr = ` style={Object.entries({${varStyleExpr}}).map(([k,v]) => \`\${k}:\${v}\`).join(';')}`;
+        }
+      }
+    }
+  }
+  let classExpr;
+  if (conditionals.length === 0) {
+    if (staticClasses.length === 0) {
+      classExpr = "";
+    } else {
+      classExpr = ` class="${staticClasses.join(" ")}"`;
+    }
+  } else {
+    const parts = [];
+    if (staticClasses.length > 0) {
+      parts.push(`'${staticClasses.join(" ")}'`);
+    }
+    parts.push(...conditionals);
+    classExpr = ` class:list={[${parts.join(", ")}]}`;
+  }
+  return { classExpr, styleAttr };
+}
+function resolveTemplate(text, ctx) {
+  if (!ctx.isComponentDef) {
+    return text;
+  }
+  const fullMatch = text.match(/^\{\{(.+)\}\}$/);
+  if (fullMatch) {
+    return `{${fullMatch[1].trim()}}`;
+  }
+  return text.replace(/\{\{(.+?)\}\}/g, (_, expr) => `{${expr.trim()}}`);
+}
+function hasTemplates(text) {
+  return /\{\{.+?\}\}/.test(text);
+}
+function buildElementClass(ctx, label) {
+  return generateElementClassName({
+    fileType: ctx.fileType,
+    fileName: ctx.fileName,
+    label,
+    path: ctx.elementPath
+  });
+}
+function buildAttributesString(attributes, ctx) {
+  if (!attributes) return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(attributes)) {
+    if (typeof value === "boolean") {
+      if (value) parts.push(key);
+    } else {
+      const strVal = String(value);
+      if (hasTemplates(strVal) && ctx.isComponentDef) {
+        const fullMatch = strVal.match(/^\{\{(.+)\}\}$/);
+        if (fullMatch) {
+          parts.push(`${key}={${fullMatch[1].trim()}}`);
+        } else {
+          const resolved = strVal.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
+          parts.push(`${key}={\`${resolved}\`}`);
+        }
+      } else {
+        parts.push(`${key}="${escapeJSX(strVal)}"`);
+      }
+    }
+  }
+  return parts.length > 0 ? " " + parts.join(" ") : "";
+}
+function formatPropValue(value) {
+  if (typeof value === "string") return `"${escapeJSX(value)}"`;
+  if (typeof value === "number") return `{${value}}`;
+  if (typeof value === "boolean") return `{${value}}`;
+  if (value === null || value === void 0) return `{undefined}`;
+  return `{${JSON.stringify(value)}}`;
+}
+function nodeToAstro(node, ctx) {
+  if (node === null || node === void 0) return "";
+  if (typeof node === "string") {
+    if (hasTemplates(node) && ctx.isComponentDef) {
+      return `${ind(ctx)}${resolveTemplate(node, ctx)}
+`;
+    }
+    return `${ind(ctx)}${escapeJSX(node)}
+`;
+  }
+  if (typeof node === "number") {
+    return `${ind(ctx)}${node}
+`;
+  }
+  if (Array.isArray(node)) {
+    let result = "";
+    for (let i = 0; i < node.length; i++) {
+      const child = node[i];
+      const savedPath = [...ctx.elementPath];
+      ctx.elementPath = [...ctx.elementPath, i];
+      result += nodeToAstro(child, ctx);
+      ctx.elementPath = savedPath;
+    }
+    return result;
+  }
+  switch (node.type) {
+    case NODE_TYPE.NODE:
+      return emitHtmlNode(node, ctx);
+    case NODE_TYPE.COMPONENT:
+      return emitComponentInstance(node, ctx);
+    case NODE_TYPE.SLOT:
+      return emitSlotMarker(node, ctx);
+    case NODE_TYPE.EMBED:
+      return emitEmbedNode(node, ctx);
+    case NODE_TYPE.LINK:
+      return emitLinkNode(node, ctx);
+    case NODE_TYPE.LOCALE_LIST:
+      return emitFallback(ctx);
+    case NODE_TYPE.LIST:
+    case "cms-list":
+      return emitFallback(ctx);
+    default:
+      return emitFallback(ctx);
+  }
+}
+function emitHtmlNode(node, ctx) {
+  let tag = node.tag;
+  const label = node.label;
+  const style = node.style;
+  let isDynamic = false;
+  let dynamicTagVar = "";
+  if (hasTemplates(tag) && ctx.isComponentDef) {
+    isDynamic = true;
+    dynamicTagVar = `Tag_${ctx.elementPath.join("_")}`;
+    const resolved = tag.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
+    if (!ctx.dynamicTags) ctx.dynamicTags = /* @__PURE__ */ new Map();
+    ctx.dynamicTags.set(dynamicTagVar, resolved);
+    tag = dynamicTagVar;
+  }
+  const ifExpr = emitIfOpen(node, ctx);
+  let elementClass = null;
+  if (node.interactiveStyles && node.interactiveStyles.length > 0 || node.generateElementClass) {
+    elementClass = buildElementClass(ctx, label);
+  }
+  const { classExpr, styleAttr } = buildClassAndStyleExpression(style, node.interactiveStyles, elementClass, ctx);
+  const attrs = buildAttributesString(node.attributes, ctx);
+  const openClose = isDynamic ? dynamicTagVar : tag;
+  if (!isDynamic && isVoidElement(tag)) {
+    return `${ifExpr}${ind(ctx)}<${tag}${classExpr}${styleAttr}${attrs} />
+${emitIfClose(node, ctx)}`;
+  }
+  const children = emitChildren(node.children, ctx);
+  if (!children.trim() && !isDynamic) {
+    return `${ifExpr}${ind(ctx)}<${tag}${classExpr}${styleAttr}${attrs} />
+${emitIfClose(node, ctx)}`;
+  }
+  return `${ifExpr}${ind(ctx)}<${openClose}${classExpr}${styleAttr}${attrs}>
+` + children + `${ind(ctx)}</${openClose}>
+${emitIfClose(node, ctx)}`;
+}
+function emitComponentInstance(node, ctx) {
+  const name = node.component;
+  ctx.imports.add(name);
+  const ifExpr = emitIfOpen(node, ctx);
+  const propParts = [];
+  if (node.props) {
+    for (const [key, value] of Object.entries(node.props)) {
+      if (key === "children") continue;
+      if (typeof value === "string" && hasTemplates(value) && ctx.isComponentDef) {
+        const fullMatch = value.match(/^\{\{(.+)\}\}$/);
+        if (fullMatch) {
+          propParts.push(`${key}={${fullMatch[1].trim()}}`);
+        } else {
+          const resolved = value.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
+          propParts.push(`${key}={\`${resolved}\`}`);
+        }
+      } else {
+        propParts.push(`${key}=${formatPropValue(value)}`);
+      }
+    }
+  }
+  if (node.style) {
+    const { classes: instanceClasses } = responsiveStylesToTailwind(node.style, ctx.breakpoints);
+    if (instanceClasses.length > 0) {
+      propParts.push(`class="${instanceClasses.join(" ")}"`);
+    }
+  }
+  const propsStr = propParts.length > 0 ? " " + propParts.join(" ") : "";
+  const children = emitChildren(node.children, ctx);
+  if (!children.trim()) {
+    return `${ifExpr}${ind(ctx)}<${name}${propsStr} />
+${emitIfClose(node, ctx)}`;
+  }
+  return `${ifExpr}${ind(ctx)}<${name}${propsStr}>
+` + children + `${ind(ctx)}</${name}>
+${emitIfClose(node, ctx)}`;
+}
+function emitSlotMarker(node, ctx) {
+  if (node.default) {
+    const defaultContent = emitChildren(node.default, ctx);
+    if (defaultContent.trim()) {
+      return `${ind(ctx)}<slot>
+` + defaultContent + `${ind(ctx)}</slot>
+`;
+    }
+  }
+  return `${ind(ctx)}<slot />
+`;
+}
+function emitEmbedNode(node, ctx) {
+  const ifExpr = emitIfOpen(node, ctx);
+  const style = node.style;
+  let elementClass = null;
+  if (node.interactiveStyles && node.interactiveStyles.length > 0 || node.generateElementClass) {
+    elementClass = buildElementClass(ctx, node.label);
+  }
+  const { classExpr, styleAttr } = buildClassAndStyleExpression(style, node.interactiveStyles, elementClass, ctx);
+  const attrs = buildAttributesString(node.attributes, ctx);
+  if (isHtmlMapping(node.html)) {
+    if (ctx.isComponentDef) {
+      const propRef = node.html.prop;
+      return `${ifExpr}${ind(ctx)}<div${classExpr.replace('"', '"oem ') || ' class="oem"'}${attrs}>
+${ind(ctx)}  <Fragment set:html={${propRef}} />
+${ind(ctx)}</div>
+${emitIfClose(node, ctx)}`;
+    }
+  }
+  const htmlStr = typeof node.html === "string" ? node.html : "";
+  const escapedHtml = escapeTemplateLiteral(htmlStr);
+  let finalClassExpr = classExpr;
+  if (!classExpr.includes("oem")) {
+    if (classExpr) {
+      finalClassExpr = classExpr.replace(/class="/, 'class="oem ').replace(/class:list={\['/, "class:list={['oem ");
+    } else {
+      finalClassExpr = ' class="oem"';
+    }
+  }
+  return `${ifExpr}${ind(ctx)}<div${finalClassExpr}${attrs}>
+${ind(ctx)}  <Fragment set:html={\`${escapedHtml}\`} />
+${ind(ctx)}</div>
+${emitIfClose(node, ctx)}`;
+}
+function emitLinkNode(node, ctx) {
+  const ifExpr = emitIfOpen(node, ctx);
+  const style = node.style;
+  let elementClass = null;
+  if (node.interactiveStyles && node.interactiveStyles.length > 0 || node.generateElementClass) {
+    elementClass = buildElementClass(ctx, node.label);
+  }
+  const { classExpr, styleAttr } = buildClassAndStyleExpression(style, node.interactiveStyles, elementClass, ctx);
+  let finalClassExpr = classExpr;
+  if (!classExpr.includes("olink")) {
+    if (classExpr) {
+      finalClassExpr = classExpr.replace(/class="/, 'class="olink ').replace(/class:list={\['/, "class:list={['olink ");
+    } else {
+      finalClassExpr = ' class="olink"';
+    }
+  }
+  let hrefAttr;
+  if (isLinkMapping(node.href)) {
+    if (ctx.isComponentDef) {
+      const propRef = node.href.prop;
+      hrefAttr = ` href={${propRef}.href}`;
+    } else {
+      hrefAttr = ' href="#"';
+    }
+  } else {
+    const href = typeof node.href === "string" ? node.href : "#";
+    if (hasTemplates(href) && ctx.isComponentDef) {
+      const fullMatch = href.match(/^\{\{(.+)\}\}$/);
+      if (fullMatch) {
+        hrefAttr = ` href={${fullMatch[1].trim()}}`;
+      } else {
+        const resolved = href.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
+        hrefAttr = ` href={\`${resolved}\`}`;
+      }
+    } else {
+      hrefAttr = ` href="${escapeJSX(href)}"`;
+    }
+  }
+  const attrs = buildAttributesString(node.attributes, ctx);
+  const children = emitChildren(node.children, ctx);
+  if (!children.trim()) {
+    return `${ifExpr}${ind(ctx)}<a${hrefAttr}${finalClassExpr}${styleAttr}${attrs} />
+${emitIfClose(node, ctx)}`;
+  }
+  return `${ifExpr}${ind(ctx)}<a${hrefAttr}${finalClassExpr}${styleAttr}${attrs}>
+` + children + `${ind(ctx)}</a>
+${emitIfClose(node, ctx)}`;
+}
+function emitFallback(ctx) {
+  const pathKey = ctx.elementPath.join(".");
+  const ssrHtml = ctx.ssrFallbacks.get(pathKey);
+  if (ssrHtml) {
+    const escaped = escapeTemplateLiteral(ssrHtml);
+    return `${ind(ctx)}<Fragment set:html={\`${escaped}\`} />
+`;
+  }
+  return `${ind(ctx)}{/* Complex node - SSR fallback not available */}
+`;
+}
+function emitIfOpen(node, ctx) {
+  const ifValue = node.if;
+  if (ifValue === void 0 || ifValue === true) return "";
+  if (typeof ifValue === "boolean") {
+    return ifValue ? "" : `${ind(ctx)}{/* hidden */}
+`;
+  }
+  if (typeof ifValue === "object" && ifValue._mapping && ctx.isComponentDef) {
+    return `${ind(ctx)}{${ifValue.prop} && (
+`;
+  }
+  if (typeof ifValue === "string" && ctx.isComponentDef) {
+    const fullMatch = ifValue.match(/^\{\{(.+)\}\}$/);
+    const expr = fullMatch ? fullMatch[1].trim() : ifValue.replace(/\{\{(.+?)\}\}/g, "$1");
+    return `${ind(ctx)}{${expr} && (
+`;
+  }
+  return "";
+}
+function emitIfClose(node, ctx) {
+  const ifValue = node.if;
+  if (ifValue === void 0 || ifValue === true) return "";
+  if (typeof ifValue === "boolean") return "";
+  if (typeof ifValue === "object" && ifValue._mapping && ctx.isComponentDef || typeof ifValue === "string" && ctx.isComponentDef) {
+    return `${ind(ctx)})}
+`;
+  }
+  return "";
+}
+function emitChildren(children, ctx) {
+  if (!children) return "";
+  const innerCtx = { ...ctx, indent: ctx.indent + 1, elementPath: [...ctx.elementPath] };
+  if (typeof children === "string") {
+    return nodeToAstro(children, innerCtx);
+  }
+  if (Array.isArray(children)) {
+    return nodeToAstro(children, innerCtx);
+  }
+  return nodeToAstro(children, innerCtx);
+}
+
+// lib/server/astro/componentEmitter.ts
+function propDefToTSType(def) {
+  switch (def.type) {
+    case "string":
+    case "rich-text":
+    case "file":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "select":
+      if ("options" in def && def.options && def.options.length > 0) {
+        return def.options.map((o) => `'${o}'`).join(" | ");
+      }
+      return "string";
+    case "link":
+      return "{ href: string; target?: string }";
+    case "list":
+      return "any[]";
+    default:
+      return "any";
+  }
+}
+function formatDefault(def) {
+  if (!("default" in def) || def.default === void 0) return null;
+  const val = def.default;
+  if (typeof val === "string") return JSON.stringify(val);
+  if (typeof val === "number" || typeof val === "boolean") return String(val);
+  if (typeof val === "object" && val !== null && "_i18n" in val) {
+    for (const [key, v] of Object.entries(val)) {
+      if (key !== "_i18n" && typeof v === "string") return JSON.stringify(v);
+    }
+    return null;
+  }
+  if (typeof val === "object" && val !== null && "href" in val) {
+    return JSON.stringify(val);
+  }
+  if (Array.isArray(val)) {
+    return JSON.stringify(val);
+  }
+  return JSON.stringify(val);
+}
+function emitAstroComponent(name, def, allComponents, breakpoints = DEFAULT_BREAKPOINTS) {
+  const comp = def.component;
+  const propDefs = comp.interface || {};
+  const structure = comp.structure;
+  if (!structure) {
+    return buildNoStructureComponent(name, comp);
+  }
+  const ctx = {
+    imports: /* @__PURE__ */ new Set(),
+    isComponentDef: true,
+    componentProps: propDefs,
+    globalComponents: allComponents,
+    indent: 0,
+    ssrFallbacks: /* @__PURE__ */ new Map(),
+    elementPath: [0],
+    fileType: "component",
+    fileName: name,
+    breakpoints
+  };
+  const templateBody = nodeToAstro(structure, ctx);
+  const frontmatter = buildFrontmatter(name, propDefs, ctx.imports, ctx.dynamicTags);
+  const styleSection = comp.css ? `
+<style>
+${comp.css}
+</style>
+` : "";
+  const scriptSection = comp.javascript ? `
+<script>
+${comp.javascript}
+</script>
+` : "";
+  return `---
+${frontmatter}---
+${templateBody}${styleSection}${scriptSection}`;
+}
+function buildFrontmatter(componentName, propDefs, imports, dynamicTags) {
+  const lines = [];
+  for (const imp of Array.from(imports).sort()) {
+    lines.push(`import ${imp} from './${imp}.astro';`);
+  }
+  if (lines.length > 0) lines.push("");
+  const propEntries = Object.entries(propDefs);
+  if (propEntries.length > 0) {
+    lines.push("interface Props {");
+    for (const [propName, propDef] of propEntries) {
+      if (propName === "children") continue;
+      const tsType = propDefToTSType(propDef);
+      const optional = "default" in propDef && propDef.default !== void 0;
+      lines.push(`  ${propName}${optional ? "?" : ""}: ${tsType};`);
+    }
+    lines.push("}");
+    lines.push("");
+    const destructParts = [];
+    for (const [propName, propDef] of propEntries) {
+      if (propName === "children") continue;
+      const defaultVal = formatDefault(propDef);
+      if (defaultVal !== null) {
+        destructParts.push(`${propName} = ${defaultVal}`);
+      } else {
+        destructParts.push(propName);
+      }
+    }
+    if (destructParts.length > 0) {
+      if (destructParts.length <= 3 && destructParts.join(", ").length < 80) {
+        lines.push(`const { ${destructParts.join(", ")} } = Astro.props;`);
+      } else {
+        lines.push("const {");
+        for (const part of destructParts) {
+          lines.push(`  ${part},`);
+        }
+        lines.push("} = Astro.props;");
+      }
+    }
+  }
+  if (dynamicTags && dynamicTags.size > 0) {
+    lines.push("");
+    for (const [varName, templateExpr] of dynamicTags) {
+      lines.push(`const ${varName} = \`${templateExpr}\`;`);
+    }
+  }
+  if (lines.length > 0) lines.push("");
+  return lines.join("\n");
+}
+function buildNoStructureComponent(name, comp) {
+  let content = "---\n---\n<slot />\n";
+  if (comp.css) content += `
+<style>
+${comp.css}
+</style>
+`;
+  if (comp.javascript) content += `
+<script>
+${comp.javascript}
+</script>
+`;
+  return content;
+}
+
+// lib/server/astro/pageEmitter.ts
+function escapeTemplateLiteral2(s) {
+  return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function escapeJSX2(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function componentImportPath(fileDepth, componentName) {
+  const ups = "../".repeat(fileDepth + 1);
+  return `${ups}components/${componentName}.astro`;
+}
+function emitAstroPage(options) {
+  const {
+    pageData,
+    globalComponents,
+    title,
+    meta,
+    locale,
+    theme,
+    fontPreloads,
+    libraryTags,
+    scriptPaths,
+    layoutImportPath: layoutImportPath2,
+    fileDepth,
+    ssrFallbacks,
+    pageName,
+    breakpoints: breakpointsOpt
+  } = options;
+  const breakpoints = breakpointsOpt ?? DEFAULT_BREAKPOINTS;
+  const root = pageData.root;
+  if (!root) {
+    return buildEmptyPage(layoutImportPath2, title, meta, locale, theme, fontPreloads, libraryTags, scriptPaths);
+  }
+  const ctx = {
+    imports: /* @__PURE__ */ new Set(),
+    isComponentDef: false,
+    componentProps: {},
+    globalComponents,
+    indent: 1,
+    // inside BaseLayout
+    ssrFallbacks,
+    elementPath: [0],
+    fileType: "page",
+    fileName: pageName,
+    breakpoints
+  };
+  const templateBody = nodeToAstro(root, ctx);
+  const importLines = [];
+  importLines.push(`import BaseLayout from '${layoutImportPath2}';`);
+  const componentImports = Array.from(ctx.imports).sort();
+  for (const comp of componentImports) {
+    const path = componentImportPath(fileDepth, comp);
+    importLines.push(`import ${comp} from '${path}';`);
+  }
+  const scriptsArrayLiteral = scriptPaths.length > 0 ? `[${scriptPaths.map((s) => `"${s}"`).join(", ")}]` : "[]";
+  const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral2(libraryTags.headCSS || "")}\`, headJS: \`${escapeTemplateLiteral2(libraryTags.headJS || "")}\`, bodyEndJS: \`${escapeTemplateLiteral2(libraryTags.bodyEndJS || "")}\` }`;
+  const escapedMeta = escapeTemplateLiteral2(meta);
+  const escapedFontPreloads = escapeTemplateLiteral2(fontPreloads);
+  return `---
+${importLines.join("\n")}
+---
+<BaseLayout
+  title="${escapeJSX2(title)}"
+  meta={\`${escapedMeta}\`}
+  scripts={${scriptsArrayLiteral}}
+  locale="${locale}"
+  theme="${theme}"
+  fontPreloads={\`${escapedFontPreloads}\`}
+  libraryTags={${libraryTagsLiteral}}
+>
+${templateBody}</BaseLayout>
+`;
+}
+function buildEmptyPage(layoutImport, title, meta, locale, theme, fontPreloads, libraryTags, scriptPaths) {
+  const escapedMeta = escapeTemplateLiteral2(meta);
+  const escapedFontPreloads = escapeTemplateLiteral2(fontPreloads);
+  const scriptsArrayLiteral = scriptPaths.length > 0 ? `[${scriptPaths.map((s) => `"${s}"`).join(", ")}]` : "[]";
+  const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral2(libraryTags.headCSS || "")}\`, headJS: \`${escapeTemplateLiteral2(libraryTags.headJS || "")}\`, bodyEndJS: \`${escapeTemplateLiteral2(libraryTags.bodyEndJS || "")}\` }`;
+  return `---
+import BaseLayout from '${layoutImport}';
+---
+<BaseLayout
+  title="${escapeJSX2(title)}"
+  meta={\`${escapedMeta}\`}
+  scripts={${scriptsArrayLiteral}}
+  locale="${locale}"
+  theme="${theme}"
+  fontPreloads={\`${escapedFontPreloads}\`}
+  libraryTags={${libraryTagsLiteral}}
+>
+</BaseLayout>
+`;
+}
+
+// lib/server/astro/cssCollector.ts
+function isStyleMapping3(value) {
+  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
+}
+function isResponsiveStyle3(style) {
+  return "base" in style || "tablet" in style || "mobile" in style;
+}
+function collectFromStyle(style, classes, breakpoints) {
+  if (!style) return;
+  if (isResponsiveStyle3(style)) {
+    for (const [bp, bpStyle] of Object.entries(style)) {
+      if (!bpStyle) continue;
+      let prefix = "";
+      if (bp !== "base") {
+        const bpValue = breakpoints[bp]?.breakpoint;
+        if (bpValue) {
+          prefix = `max-[${bpValue}px]:`;
+        }
+      }
+      collectFromFlatStyle(bpStyle, prefix, classes);
+    }
+  } else {
+    collectFromFlatStyle(style, "", classes);
+  }
+}
+function collectFromFlatStyle(style, prefix, classes) {
+  for (const [property, value] of Object.entries(style)) {
+    if (!isStyleMapping3(value)) continue;
+    for (const [, cssValue] of Object.entries(value.values)) {
+      const twClass = propertyToTailwind(property, cssValue);
+      if (twClass) {
+        classes.add(prefix ? `${prefix}${twClass}` : twClass);
+      }
+    }
+  }
+}
+function walkNode(node, classes, breakpoints) {
+  if (!node || typeof node === "string" || typeof node === "number") return;
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      walkNode(child, classes, breakpoints);
+    }
+    return;
+  }
+  if ("style" in node && node.style) {
+    collectFromStyle(node.style, classes, breakpoints);
+  }
+  if ("interactiveStyles" in node && Array.isArray(node.interactiveStyles)) {
+    for (const rule of node.interactiveStyles) {
+      if (rule.style) {
+        collectFromStyle(rule.style, classes, breakpoints);
+      }
+    }
+  }
+  if ("children" in node && node.children) {
+    if (Array.isArray(node.children)) {
+      for (const child of node.children) {
+        walkNode(child, classes, breakpoints);
+      }
+    }
+  }
+}
+function collectAllMappingClasses(componentDefs, breakpoints = DEFAULT_BREAKPOINTS) {
+  const classes = /* @__PURE__ */ new Set();
+  for (const def of Object.values(componentDefs)) {
+    const structure = def.component?.structure;
+    if (structure) {
+      walkNode(structure, classes, breakpoints);
+    }
+  }
+  return classes;
+}
+
+// build-astro.ts
+function hashContent2(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 8);
+}
+function copyDirectory(src, dest) {
+  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) {
+  return pageData.meta?.source === "cms" && !!pageData.meta?.cms;
+}
+function buildCMSItemPath(urlPattern, item, slugField, locale, i18nConfig) {
+  let slug = item[slugField] ?? item._slug ?? item._id;
+  if (isI18nValue(slug)) {
+    slug = resolveI18nValue(slug, locale, i18nConfig);
+  }
+  return urlPattern.replace("{{slug}}", String(slug));
+}
+function scanJSONFiles(dir, prefix = "") {
+  const results = [];
+  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;
+}
+function layoutImportPath(fileDepth) {
+  const ups = "../".repeat(fileDepth + 1);
+  return `${ups}layouts/BaseLayout.astro`;
+}
+function escapeTemplateLiteral3(s) {
+  return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function cmsFieldToZod(field) {
+  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()";
+  }
+}
+function buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths) {
+  const escapedMeta = escapeTemplateLiteral3(result.meta);
+  const escapedHTML = escapeTemplateLiteral3(result.html);
+  const escapedFontPreloads = escapeTemplateLiteral3(fontPreloads);
+  const scriptsArrayLiteral = scriptPaths.length > 0 ? `[${scriptPaths.map((s) => `"${s}"`).join(", ")}]` : "[]";
+  const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral3(libraryTags.headCSS || "")}\`, headJS: \`${escapeTemplateLiteral3(libraryTags.headJS || "")}\`, bodyEndJS: \`${escapeTemplateLiteral3(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>
+`;
+}
+async function buildAstroProject(projectRoot, outputDir) {
+  const startTime = Date.now();
+  console.log("\u{1F3D7}\uFE0F  Building Astro export...\n");
+  configService.reset();
+  const projectConfig = await loadProjectConfig();
+  const siteUrl = projectConfig.siteUrl?.replace(/\/$/, "") || "";
+  const i18nConfig = await loadI18nConfig();
+  console.log(`\u{1F310} Locales: ${i18nConfig.locales.map((l) => l.code).join(", ")} (default: ${i18nConfig.defaultLocale})
+`);
+  await migrateTemplatesDirectory();
+  const { components, warnings, errors: compErrors } = await loadComponentDirectory(projectPaths.components());
+  const globalComponents = {};
+  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)
+`);
+  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();
+  await configService.load();
+  const globalLibraries = configService.getLibraries();
+  const componentLibraries = collectComponentLibraries(globalComponents);
+  const outDir = outputDir || join(projectPaths.project, "astro-export");
+  if (existsSync(outDir)) {
+    rmSync(outDir, { recursive: true, force: true });
+  }
+  mkdirSync(outDir, { recursive: true });
+  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 });
+  }
+  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
+`);
+  const slugMappings = [];
+  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(pageContent);
+      if (pageData.meta?.slugs) {
+        const pageId = basePath === "/" ? "index" : basePath.substring(1);
+        slugMappings.push({ pageId, slugs: pageData.meta.slugs });
+      }
+    } catch {
+    }
+  }
+  const allResults = [];
+  const allInteractiveStyles = /* @__PURE__ */ new Map();
+  const allComponentCSS = /* @__PURE__ */ new Set();
+  const jsContents = /* @__PURE__ */ new Map();
+  let errorCount = 0;
+  function mergeInteractiveStyles(source) {
+    for (const [key, value] of source) {
+      if (!allInteractiveStyles.has(key)) {
+        allInteractiveStyles.set(key, value);
+      }
+    }
+  }
+  function processRenderResult(result, urlPath, astroFilePath, fileDepth, pageData, pageName, isCMSPage2) {
+    mergeInteractiveStyles(result.interactiveStylesMap);
+    if (result.componentCSS) {
+      allComponentCSS.add(result.componentCSS);
+    }
+    if (result.javascript) {
+      const hash = hashContent2(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: isCMSPage2
+    });
+  }
+  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(pageContent);
+      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;
+        let slug;
+        if (slugs && slugs[locale]) {
+          slug = slugs[locale];
+        } else if (basePath === "/") {
+          slug = "";
+        } else {
+          slug = basePath.substring(1);
+        }
+        const urlPath = isDefault ? slug === "" ? "/" : `/${slug}` : slug === "" ? `/${locale}` : `/${locale}/${slug}`;
+        const 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,
+          void 0,
+          // cmsContext
+          cmsService,
+          true
+          // isProductionBuild
+        );
+        processRenderResult(result, urlPath, astroFilePath, fileDepth, pageData, pageName, false);
+        console.log(`  Rendered: ${urlPath}`);
+      }
+    } catch (error) {
+      console.error(`  Error rendering ${basePath}:`, error?.message || error);
+      errorCount++;
+    }
+  }
+  const templatesDir = projectPaths.templates();
+  const templateSchemas = [];
+  let cmsPageCount = 0;
+  if (existsSync(templatesDir)) {
+    const templateFiles = readdirSync(templatesDir).filter((f) => f.endsWith(".json"));
+    if (templateFiles.length > 0) {
+      console.log(`
+Processing ${templateFiles.length} CMS template(s)...
+`);
+    }
+    for (const file of templateFiles) {
+      const templateContent = await loadJSONFile(join(templatesDir, file));
+      if (!templateContent) continue;
+      try {
+        const pageData = parseJSON(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;
+        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 isDevBuild2 = process.env.MENO_DEV_BUILD === "true";
+            if (!isDevBuild2 && isItemDraftForLocale(item, locale)) {
+              continue;
+            }
+            const itemPath = buildCMSItemPath(cmsSchema.urlPattern, item, cmsSchema.slugField, locale, i18nConfig);
+            const itemWithUrl = { ...item, _url: itemPath };
+            const result = await renderPageSSR(
+              pageData,
+              globalComponents,
+              itemPath,
+              siteUrl,
+              locale,
+              i18nConfig,
+              slugMappings,
+              { cms: itemWithUrl },
+              cmsService,
+              true
+            );
+            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) {
+        console.error(`  Error processing template ${file}:`, error?.message || error);
+        errorCount++;
+      }
+    }
+  }
+  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 writeFile2(join(stylesDir, "global.css"), globalCSS, "utf-8");
+  console.log(`
+Generated global.css (${(globalCSS.length / 1024).toFixed(1)} KB)`);
+  const fontPreloads = generateFontPreloadTags();
+  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 writeFile2(join(layoutsDir, "BaseLayout.astro"), baseLayoutContent, "utf-8");
+  console.log("Generated BaseLayout.astro");
+  let componentFileCount = 0;
+  for (const [compName, compDef] of Object.entries(globalComponents)) {
+    try {
+      const astroContent = emitAstroComponent(compName, compDef, globalComponents, breakpoints);
+      await writeFile2(join(componentsOutDir, `${compName}.astro`), astroContent, "utf-8");
+      componentFileCount++;
+    } catch (error) {
+      console.warn(`  Warning: could not generate component ${compName}: ${error?.message}`);
+    }
+  }
+  console.log(`Generated ${componentFileCount} component .astro file(s)`);
+  const defaultTheme = themeConfig.default || "light";
+  for (const result of allResults) {
+    const importPath = layoutImportPath(result.fileDepth);
+    const scriptPaths = [];
+    if (result.javascript) {
+      const hash = hashContent2(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 writeFile2(fullScriptPath, result.javascript, "utf-8");
+      }
+      scriptPaths.push(scriptPublicPath);
+    }
+    let astroContent;
+    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: /* @__PURE__ */ new Map(),
+          // SSR fallbacks for complex nodes
+          pageName: result.pageName || "index",
+          breakpoints
+        });
+      } catch (error) {
+        console.warn(`  Warning: component emission failed for ${result.urlPath}, using SSR fallback: ${error?.message}`);
+        astroContent = buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths);
+      }
+    } else {
+      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 writeFile2(astroFileFull, astroContent, "utf-8");
+  }
+  console.log(`Generated ${allResults.length} .astro page file(s)`);
+  let collectionCount = 0;
+  if (templateSchemas.length > 0) {
+    const contentDir = join(srcDir, "content");
+    mkdirSync(contentDir, { recursive: true });
+    const collectionDefs = [];
+    for (const schema of templateSchemas) {
+      const collectionDir = join(contentDir, schema.id);
+      mkdirSync(collectionDir, { recursive: true });
+      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);
+            const resolved = {};
+            for (const [key, value] of Object.entries(item)) {
+              if (isI18nValue(value)) {
+                resolved[key] = resolveI18nValue(value, i18nConfig.defaultLocale, i18nConfig);
+              } else {
+                resolved[key] = value;
+              }
+            }
+            await writeFile2(
+              join(collectionDir, itemFile),
+              JSON.stringify(resolved, null, 2),
+              "utf-8"
+            );
+          } catch (err) {
+            console.warn(`    Warning: could not process CMS item ${itemFile}: ${err?.message}`);
+          }
+        }
+      }
+      const fieldDefs = [];
+      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++;
+    }
+    const configContent = `import { z, defineCollection } from 'astro:content';
+
+const collections = {
+${collectionDefs.join(",\n")}
+};
+
+export { collections };
+`;
+    await writeFile2(join(contentDir, "config.ts"), configContent, "utf-8");
+    console.log(`Generated ${collectionCount} content collection(s) with config.ts`);
+  }
+  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++;
+    }
+  }
+  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/`);
+  }
+  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 writeFile2(join(outDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf-8");
+  const astroConfig = `import { defineConfig } from 'astro/config';
+import sitemap from '@astrojs/sitemap';
+import tailwind from '@astrojs/tailwind';
+
+export default defineConfig({${siteUrl ? `
+  site: '${siteUrl}',` : ""}
+  integrations: [sitemap(), tailwind({ applyBaseStyles: false })],
+});
+`;
+  const safelistArray = Array.from(mappingClasses);
+  const safelistLiteral = safelistArray.length > 0 ? `
+  safelist: [
+${safelistArray.map((c) => `    '${c}'`).join(",\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 writeFile2(join(outDir, "tailwind.config.mjs"), tailwindConfig, "utf-8");
+  await writeFile2(join(outDir, "astro.config.mjs"), astroConfig, "utf-8");
+  const tsConfig = {
+    extends: "astro/tsconfigs/strict"
+  };
+  await writeFile2(join(outDir, "tsconfig.json"), JSON.stringify(tsConfig, null, 2), "utf-8");
+  console.log("Generated package.json, astro.config.mjs, tailwind.config.mjs, tsconfig.json");
+  const elapsed = ((Date.now() - startTime) / 1e3).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
+  };
+}
+
 // lib/server/index.ts
 init_constants();
 export {
@@ -130,6 +1964,7 @@ export {
   SERVE_PORT,
   VariableService,
   WebSocketManager,
+  buildAstroProject,
   buildAttributes,
   buildComponentHTML,
   buildImageMetadataMap,