meno-core 1.0.39 → 1.0.40

package/dist/lib/server/index.js

@@ -3,7 +3,7 @@ import {
 } from "../../chunks/chunk-4OFZP5NQ.js";
 import {
   buildStaticPages
-} from "../../chunks/chunk-WK5XLASY.js";
+} from "../../chunks/chunk-3NOZVNM4.js";
 import {
   ComponentService,
   EnumService,
@@ -32,7 +32,7 @@ import {
   logResponseTime,
   withErrorHandling,
   withLogging
-} from "../../chunks/chunk-HNAS6BSS.js";
+} from "../../chunks/chunk-MOCRENNU.js";
 import {
   CMSService,
   ColorService,
@@ -43,6 +43,7 @@ import {
   buildAttributes,
   buildComponentHTML,
   buildImageMetadataMap,
+  buildSlugIndex,
   clearJSValidationCache,
   collectComponentCSS,
   collectComponentJavaScript,
@@ -75,8 +76,9 @@ import {
   renderPageSSR,
   resetFontConfig,
   styleToString,
+  translatePath,
   variableService
-} from "../../chunks/chunk-W6HDII4T.js";
+} from "../../chunks/chunk-GKICS7CF.js";
 import {
   ConfigService,
   configService
@@ -110,18 +112,23 @@ import {
   writeFile
 } from "../../chunks/chunk-WQFG7PAH.js";
 import "../../chunks/chunk-LIHJ6OUH.js";
-import "../../chunks/chunk-P3FX5HJM.js";
-import "../../chunks/chunk-AIXKUVNG.js";
+import "../../chunks/chunk-LOJLO2EY.js";
+import "../../chunks/chunk-V4SVSX3X.js";
 import {
   extractInteractiveStyleMappings,
+  extractUtilityClassesFromHTML,
   generateAllInteractiveCSS,
   generateElementClassName,
+  generateUtilityCSS,
   hasInteractiveStyleMappings,
   isItemDraftForLocale,
-  isVoidElement
-} from "../../chunks/chunk-NV25WXCA.js";
+  isVoidElement,
+  singularize
+} from "../../chunks/chunk-OJ5SROQN.js";
 import {
   DEFAULT_BREAKPOINTS,
+  DEFAULT_I18N_CONFIG,
+  buildLocalizedPath,
   isI18nValue,
   resolveI18nValue
 } from "../../chunks/chunk-PGH3ATYI.js";
@@ -130,10 +137,11 @@ import {
   HMR_ROUTE,
   MAX_PORT_ATTEMPTS,
   NODE_TYPE,
+  RAW_HTML_PREFIX,
   SERVER_PORT,
   SERVE_PORT,
   init_constants
-} from "../../chunks/chunk-KULPBDC7.js";
+} from "../../chunks/chunk-Z7SAOCDG.js";
 import "../../chunks/chunk-KSBZ2L7C.js";
 
 // build-astro.ts
@@ -374,7 +382,11 @@ var singleValueMatches = {
   "top:0": "top-0",
   "right:0": "right-0",
   "bottom:0": "bottom-0",
-  "left:0": "left-0"
+  "left:0": "left-0",
+  "outline:none": "[outline:none]",
+  "background:none": "[background:none]",
+  "background:transparent": "[background:transparent]",
+  "backgroundColor:transparent": "bg-transparent"
 };
 var arbitraryPrefixMap = {
   // Spacing
@@ -433,7 +445,7 @@ var arbitraryPrefixMap = {
   backdropFilter: "backdrop",
   transform: "[transform]",
   transformOrigin: "origin",
-  transition: "transition",
+  transition: "[transition]",
   mixBlendMode: "mix-blend",
   clipPath: "[clip-path]",
   // Positioning
@@ -485,10 +497,29 @@ function propertyToTailwind(property, value) {
   if (property === "color" || property === "backgroundColor" || property === "borderColor") {
     const prefix = property === "color" ? "text" : property === "backgroundColor" ? "bg" : "border";
     if (strValue.includes("var(")) {
-      return `${prefix}-[${strValue}]`;
+      return `${prefix}-[color:${strValue}]`;
     }
     if (!strValue.match(/^[#\d]/) && !strValue.includes("rgb") && !strValue.includes("hsl")) {
-      return `${prefix}-[var(--${strValue})]`;
+      return `${prefix}-[color:var(--${strValue})]`;
+    }
+  }
+  if (property === "borderColor" || property === "color") {
+    const prefix = property === "color" ? "text" : "border";
+    const sanitized2 = strValue.replace(/\s+/g, "_");
+    return `${prefix}-[color:${sanitized2}]`;
+  }
+  if (property === "border" || property === "borderTop" || property === "borderRight" || property === "borderBottom" || property === "borderLeft") {
+    if (strValue.includes("solid") || strValue.includes("dashed") || strValue.includes("dotted") || strValue.includes("none")) {
+      const cssProp = property.replace(/([A-Z])/g, "-$1").toLowerCase();
+      const sanitized2 = strValue.replace(/\s+/g, "_");
+      return `[${cssProp}:${sanitized2}]`;
+    }
+  }
+  if (property === "background") {
+    const isSimpleColor = /^(#[0-9a-fA-F]{3,8}|rgb|hsl|var\()/.test(strValue);
+    if (!isSimpleColor) {
+      const sanitized2 = strValue.replace(/\s+/g, "_");
+      return `[background:${sanitized2}]`;
     }
   }
   const twPrefix = arbitraryPrefixMap[property];
@@ -502,14 +533,28 @@ function propertyToTailwind(property, value) {
     return `${twPrefix.slice(0, -1)}:${sanitized2}]`;
   }
   const sanitized = strValue.replace(/\s+/g, "_");
-  if (property === "fontFamily" && !sanitized.includes(",") && !sanitized.startsWith("'")) {
-    return `${twPrefix}-['${sanitized}']`;
+  if (property === "fontSize") {
+    return `text-[length:${sanitized}]`;
+  }
+  if (property === "fontFamily") {
+    return `font-[family-name:${sanitized}]`;
+  }
+  if (property === "fontWeight") {
+    return `font-[number:${sanitized}]`;
   }
   return `${twPrefix}-[${sanitized}]`;
 }
 function stylesToTailwind(style) {
   const classes = [];
   const dynamicStyles = {};
+  const hasBorderColor = "borderColor" in style && !isStyleMapping(style.borderColor);
+  const borderShorthands = /* @__PURE__ */ new Set([
+    "border",
+    "borderTop",
+    "borderRight",
+    "borderBottom",
+    "borderLeft"
+  ]);
   for (const [prop, value] of Object.entries(style)) {
     if (isStyleMapping(value)) continue;
     const strValue = String(value);
@@ -518,6 +563,15 @@ function stylesToTailwind(style) {
       dynamicStyles[cssProp] = strValue;
       continue;
     }
+    if (hasBorderColor && borderShorthands.has(prop)) {
+      const parts = strValue.split(/\s+/);
+      const width = parts.find((p) => /^\d/.test(p) || p === "0");
+      const borderStyle = parts.find((p) => /^(solid|dashed|dotted|double|groove|ridge|inset|outset|none|hidden)$/.test(p));
+      const cssProp = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+      if (width) classes.push(`[${cssProp}-width:${width}]`);
+      if (borderStyle) classes.push(`[${cssProp}-style:${borderStyle}]`);
+      continue;
+    }
     const twClass = propertyToTailwind(prop, value);
     if (twClass) {
       classes.push(twClass);
@@ -569,15 +623,121 @@ function responsiveStylesToTailwind(style, breakpoints) {
 
 // lib/server/astro/nodeToAstro.ts
 init_constants();
+
+// lib/server/astro/templateTransformer.ts
+var CMS_TEMPLATE_PATTERN = /\{\{cms\.([^}]+)\}\}/g;
+var ITEM_TEMPLATE_PATTERN = /\{\{([^}]+)\}\}/g;
+function isTemplateExpression(text) {
+  return /\{\{.+?\}\}/.test(text);
+}
+function transformCMSTemplate(text, binding = "entry", richTextFields, wrapFn) {
+  const w = (expr) => wrapFn ? `${wrapFn}(${expr})` : expr;
+  const fullMatch = text.match(/^\{\{cms\.([^}]+)\}\}$/);
+  if (fullMatch) {
+    const fieldPath = fullMatch[1].trim();
+    const topLevelField = fieldPath.split(".")[0];
+    if (richTextFields?.has(topLevelField)) {
+      return `<Fragment set:html={${w(`${binding}.data.${fieldPath}`)}} />`;
+    }
+    return `{${w(`${binding}.data.${fieldPath}`)}}`;
+  }
+  if (CMS_TEMPLATE_PATTERN.test(text)) {
+    CMS_TEMPLATE_PATTERN.lastIndex = 0;
+    const replaced = text.replace(CMS_TEMPLATE_PATTERN, (_, fieldPath) => {
+      return `\${${w(`${binding}.data.${fieldPath.trim()}`)}}`;
+    });
+    return `{\`${replaced}\`}`;
+  }
+  return text;
+}
+function rewriteItemVar(expr, itemVar) {
+  if (itemVar === "item") return expr;
+  return expr.replace(/\bitem\./g, `${itemVar}.`);
+}
+function replaceItemMetaVars(expr, indexVar, sourceVar, itemVar) {
+  const lastExpr = sourceVar ? `(${indexVar} === ${sourceVar}.length - 1)` : `false /* itemLast not supported */`;
+  let result = expr.replace(/\bitemIndex\b/g, indexVar).replace(/\bitemFirst\b/g, `(${indexVar} === 0)`).replace(/\bitemLast\b/g, lastExpr);
+  if (itemVar) result = rewriteItemVar(result, itemVar);
+  return result;
+}
+function transformItemTemplate(text, itemVar = "item", indexVar, sourceVar) {
+  const fullMatch = text.match(/^\{\{(.+)\}\}$/);
+  if (fullMatch) {
+    let expr = fullMatch[1].trim();
+    expr = rewriteItemVar(expr, itemVar);
+    if (indexVar) expr = replaceItemMetaVars(expr, indexVar, sourceVar);
+    if (expr.startsWith(`${itemVar}.`)) {
+      return `{${expr}}`;
+    }
+    return `{${expr}}`;
+  }
+  if (ITEM_TEMPLATE_PATTERN.test(text)) {
+    ITEM_TEMPLATE_PATTERN.lastIndex = 0;
+    const replaced = text.replace(ITEM_TEMPLATE_PATTERN, (_, expr) => {
+      let trimmed = expr.trim();
+      trimmed = rewriteItemVar(trimmed, itemVar);
+      if (indexVar) trimmed = replaceItemMetaVars(trimmed, indexVar, sourceVar);
+      return `\${${trimmed}}`;
+    });
+    return `{\`${replaced}\`}`;
+  }
+  return text;
+}
+
+// lib/server/astro/nodeToAstro.ts
 function ind(ctx) {
   return "  ".repeat(ctx.indent);
 }
+function localizeHref(href, ctx) {
+  if (!href.startsWith("/") || href.startsWith("//")) return href;
+  const { locale, i18nDefaultLocale, slugMappings } = ctx;
+  if (!locale || !i18nDefaultLocale) return href;
+  if (slugMappings && slugMappings.length > 0) {
+    const slugIndex = buildSlugIndex(slugMappings);
+    return translatePath(href, locale, i18nDefaultLocale, i18nDefaultLocale, slugIndex);
+  } else if (locale !== i18nDefaultLocale) {
+    return buildLocalizedPath(href, locale);
+  }
+  return href;
+}
 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 emitAttrValue(key, value, ctx) {
+  if (ctx.cmsMode && /\{\{cms\./.test(value)) {
+    const b = ctx.cmsEntryBinding || "entry";
+    const w = (expr) => ctx.cmsWrapFn ? `${ctx.cmsWrapFn}(${expr})` : expr;
+    const fullMatch = value.match(/^\{\{cms\.([^}]+)\}\}$/);
+    if (fullMatch) {
+      return `${key}={${w(`${b}.data.${fullMatch[1].trim()}`)}}`;
+    }
+    const replaced = value.replace(
+      /\{\{cms\.([^}]+)\}\}/g,
+      (_, fp) => `\${${w(`${b}.data.${fp.trim()}`)}}`
+    );
+    return `${key}={\`${replaced}\`}`;
+  }
+  if (ctx.listItemBinding && /\{\{/.test(value)) {
+    const fullMatch = value.match(/^\{\{(.+)\}\}$/);
+    if (fullMatch) {
+      let expr = fullMatch[1].trim();
+      expr = rewriteItemVar(expr, ctx.listItemBinding);
+      if (ctx.listIndexVar) expr = replaceItemMetaVars(expr, ctx.listIndexVar, ctx.listSourceVar);
+      return `${key}={${expr}}`;
+    }
+    const replaced = value.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
+      let trimmed = expr.trim();
+      trimmed = rewriteItemVar(trimmed, ctx.listItemBinding);
+      if (ctx.listIndexVar) trimmed = replaceItemMetaVars(trimmed, ctx.listIndexVar, ctx.listSourceVar);
+      return `\${${trimmed}}`;
+    });
+    return `${key}={\`${replaced}\`}`;
+  }
+  return `${key}="${escapeJSX(value)}"`;
+}
 function isHtmlMapping(value) {
   return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
 }
@@ -622,13 +782,13 @@ function mappingToClassListEntries(mapping, property, breakpointPrefix, ctx) {
     const cls1 = getClassForValue(property, css1, breakpointPrefix);
     const cls2 = getClassForValue(property, css2, breakpointPrefix);
     if (cls1 && cls2) {
-      entries.push(`${propRef} === ${JSON.stringify(coerceValue(val1))} ? '${cls1}' : '${cls2}'`);
+      entries.push(`String(${propRef}) === ${JSON.stringify(String(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}'`);
+        entries.push(`String(${propRef}) === ${JSON.stringify(String(coerceValue(val)))} && '${cls}'`);
       }
     }
   }
@@ -663,12 +823,22 @@ function buildClassAndStyleExpression(style, interactiveStyles, elementClass, ct
   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()}}`);
+      const resolved = value.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
+        let trimmed = expr.trim();
+        if (ctx.listItemBinding) trimmed = rewriteItemVar(trimmed, ctx.listItemBinding);
+        if (ctx.listIndexVar) trimmed = replaceItemMetaVars(trimmed, ctx.listIndexVar, ctx.listSourceVar);
+        return `\${${trimmed}}`;
+      });
       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()}}`);
+      const resolved = value.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
+        let trimmed = expr.trim();
+        if (ctx.listItemBinding) trimmed = rewriteItemVar(trimmed, ctx.listItemBinding);
+        if (ctx.listIndexVar) trimmed = replaceItemMetaVars(trimmed, ctx.listIndexVar, ctx.listSourceVar);
+        return `\${${trimmed}}`;
+      });
       entries.push(`${cssProp}: ${resolved}`);
     }
     styleAttr = ` style={\`${entries.join("; ")}\`}`;
@@ -723,9 +893,20 @@ function resolveTemplate(text, ctx) {
   }
   const fullMatch = text.match(/^\{\{(.+)\}\}$/);
   if (fullMatch) {
-    return `{${fullMatch[1].trim()}}`;
+    let propName = fullMatch[1].trim();
+    if (ctx.listItemBinding) propName = rewriteItemVar(propName, ctx.listItemBinding);
+    if (ctx.listIndexVar) propName = replaceItemMetaVars(propName, ctx.listIndexVar, ctx.listSourceVar);
+    if (ctx.componentProps[propName]?.type === "rich-text") {
+      return `<Fragment set:html={${propName}} />`;
+    }
+    return `{${propName}}`;
   }
-  return text.replace(/\{\{(.+?)\}\}/g, (_, expr) => `{${expr.trim()}}`);
+  return text.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
+    let trimmed = expr.trim();
+    if (ctx.listItemBinding) trimmed = rewriteItemVar(trimmed, ctx.listItemBinding);
+    if (ctx.listIndexVar) trimmed = replaceItemMetaVars(trimmed, ctx.listIndexVar, ctx.listSourceVar);
+    return `{${trimmed}}`;
+  });
 }
 function hasTemplates(text) {
   return /\{\{.+?\}\}/.test(text);
@@ -749,11 +930,53 @@ function buildAttributesString(attributes, ctx) {
       if (hasTemplates(strVal) && ctx.isComponentDef) {
         const fullMatch = strVal.match(/^\{\{(.+)\}\}$/);
         if (fullMatch) {
-          parts.push(`${key}={${fullMatch[1].trim()}}`);
+          let expr = fullMatch[1].trim();
+          if (ctx.listItemBinding) expr = rewriteItemVar(expr, ctx.listItemBinding);
+          if (ctx.listIndexVar) expr = replaceItemMetaVars(expr, ctx.listIndexVar, ctx.listSourceVar);
+          const propDef = ctx.componentProps[expr];
+          if (propDef && propDef.type === "link") {
+            parts.push(`${key}={${expr}?.href ?? "#"}`);
+          } else {
+            parts.push(`${key}={${expr} || undefined}`);
+          }
+        } else {
+          const resolved = strVal.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
+            let trimmed = expr.trim();
+            if (ctx.listItemBinding) trimmed = rewriteItemVar(trimmed, ctx.listItemBinding);
+            if (ctx.listIndexVar) trimmed = replaceItemMetaVars(trimmed, ctx.listIndexVar, ctx.listSourceVar);
+            const pd = ctx.componentProps[trimmed];
+            return pd?.type === "link" ? `\${${trimmed}?.href ?? "#"}` : `\${${trimmed}}`;
+          });
+          parts.push(`${key}={\`${resolved}\`}`);
+        }
+      } else if (ctx.listItemBinding && hasTemplates(strVal)) {
+        const fullMatch = strVal.match(/^\{\{(.+)\}\}$/);
+        if (fullMatch) {
+          let expr = fullMatch[1].trim();
+          expr = rewriteItemVar(expr, ctx.listItemBinding);
+          if (ctx.listIndexVar) expr = replaceItemMetaVars(expr, ctx.listIndexVar, ctx.listSourceVar);
+          parts.push(`${key}={${expr} || undefined}`);
         } else {
-          const resolved = strVal.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
+          const resolved = strVal.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
+            let trimmed = expr.trim();
+            trimmed = rewriteItemVar(trimmed, ctx.listItemBinding);
+            if (ctx.listIndexVar) trimmed = replaceItemMetaVars(trimmed, ctx.listIndexVar, ctx.listSourceVar);
+            return `\${${trimmed}}`;
+          });
           parts.push(`${key}={\`${resolved}\`}`);
         }
+      } else if (ctx.cmsMode && /\{\{cms\./.test(strVal)) {
+        const b = ctx.cmsEntryBinding || "entry";
+        const w = (expr) => ctx.cmsWrapFn ? `${ctx.cmsWrapFn}(${expr})` : expr;
+        const fullMatch = strVal.match(/^\{\{cms\.([^}]+)\}\}$/);
+        if (fullMatch) {
+          parts.push(`${key}={${w(`${b}.data.${fullMatch[1].trim()}`)}}`);
+        } else {
+          const replaced = strVal.replace(/\{\{cms\.([^}]+)\}\}/g, (_, fieldPath) => {
+            return `\${${w(`${b}.data.${fieldPath.trim()}`)}}`;
+          });
+          parts.push(`${key}={\`${replaced}\`}`);
+        }
       } else {
         parts.push(`${key}="${escapeJSX(strVal)}"`);
       }
@@ -768,11 +991,46 @@ function formatPropValue(value) {
   if (value === null || value === void 0) return `{undefined}`;
   return `{${JSON.stringify(value)}}`;
 }
+function resolveI18n(value, ctx) {
+  if (ctx.locale && isI18nValue(value)) {
+    return resolveI18nValue(value, ctx.locale, DEFAULT_I18N_CONFIG);
+  }
+  return value;
+}
 function nodeToAstro(node, ctx) {
   if (node === null || node === void 0) return "";
+  if (typeof node === "object" && !Array.isArray(node) && isI18nValue(node)) {
+    const resolved = resolveI18n(node, ctx);
+    if (typeof resolved === "string") {
+      return `${ind(ctx)}${escapeJSX(resolved)}
+`;
+    }
+    if (ctx.isComponentDef && isI18nValue(resolved)) {
+      ctx.needsI18nResolver = true;
+      return `${ind(ctx)}{r(${JSON.stringify(resolved)})}
+`;
+    }
+    return `${ind(ctx)}${String(resolved ?? "")}
+`;
+  }
   if (typeof node === "string") {
+    if (ctx.cmsMode && isTemplateExpression(node) && /\{\{cms\./.test(node)) {
+      const transformed = transformCMSTemplate(node, ctx.cmsEntryBinding || "entry", ctx.cmsRichTextFields, ctx.cmsWrapFn);
+      return `${ind(ctx)}${transformed}
+`;
+    }
+    if (ctx.listItemBinding && isTemplateExpression(node)) {
+      const transformed = transformItemTemplate(node, ctx.listItemBinding, ctx.listIndexVar, ctx.listSourceVar);
+      return `${ind(ctx)}${transformed}
+`;
+    }
     if (hasTemplates(node) && ctx.isComponentDef) {
       return `${ind(ctx)}${resolveTemplate(node, ctx)}
+`;
+    }
+    if (node.startsWith(RAW_HTML_PREFIX)) {
+      const rawHtml = node.slice(RAW_HTML_PREFIX.length);
+      return `${ind(ctx)}<Fragment set:html={\`${escapeTemplateLiteral(rawHtml)}\`} />
 `;
     }
     return `${ind(ctx)}${escapeJSX(node)}
@@ -787,7 +1045,7 @@ function nodeToAstro(node, ctx) {
     for (let i = 0; i < node.length; i++) {
       const child = node[i];
       const savedPath = [...ctx.elementPath];
-      ctx.elementPath = [...ctx.elementPath, i];
+      ctx.elementPath = [...ctx.elementPath.slice(0, -1), i];
       result += nodeToAstro(child, ctx);
       ctx.elementPath = savedPath;
     }
@@ -805,16 +1063,116 @@ function nodeToAstro(node, ctx) {
     case NODE_TYPE.LINK:
       return emitLinkNode(node, ctx);
     case NODE_TYPE.LOCALE_LIST:
-      return emitFallback(ctx);
+      return emitLocaleListNode(node, ctx);
     case NODE_TYPE.LIST:
     case "cms-list":
-      return emitFallback(ctx);
+      return emitListNode(node, ctx);
+    case "image":
+      return emitImageTypeNode(node, ctx);
     default:
       return emitFallback(ctx);
   }
 }
+var IMG_TAILWIND_PREFIXES = ["object-", "rounded", "border", "shadow", "[filter", "[transform", "mix-blend"];
+var IMG_OPACITY_PATTERN = /^opacity-/;
+var DEFAULT_SIZES2 = "100vw";
+function splitImageClasses(allClasses) {
+  const imgClasses = [];
+  const pictureClasses = [];
+  for (const cls of allClasses) {
+    const baseCls = cls.includes(":") ? cls.split(":").pop() : cls;
+    if (IMG_TAILWIND_PREFIXES.some((p) => baseCls.startsWith(p)) || IMG_OPACITY_PATTERN.test(baseCls)) {
+      imgClasses.push(cls);
+    } else {
+      pictureClasses.push(cls);
+    }
+  }
+  return { pictureClasses, imgClasses };
+}
+function emitImageNode(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 = node.attributes || {};
+  const src = attrs.src;
+  const alt = attrs.alt;
+  const loading = attrs.loading;
+  const fetchpriority = attrs.fetchpriority;
+  let width = attrs.width;
+  let height = attrs.height;
+  const sizes = attrs.sizes;
+  const metadata = src ? ctx.imageMetadataMap?.get(String(src)) : void 0;
+  if (metadata) {
+    if (width === void 0 && metadata.width) width = metadata.width;
+    if (height === void 0 && metadata.height) height = metadata.height;
+  }
+  const sizesValue = sizes || DEFAULT_SIZES2;
+  const imageSpecificKeys = /* @__PURE__ */ new Set(["src", "alt", "loading", "width", "height", "sizes", "srcset", "fetchpriority"]);
+  const otherAttrs = {};
+  if (node.attributes) {
+    for (const [k, v] of Object.entries(node.attributes)) {
+      if (!imageSpecificKeys.has(k)) otherAttrs[k] = v;
+    }
+  }
+  const otherAttrsStr = buildAttributesString(otherAttrs, ctx);
+  let imgAttrs = "";
+  if (src) imgAttrs += ` ${emitAttrValue("src", String(src), ctx)}`;
+  if (alt !== void 0) imgAttrs += ` ${emitAttrValue("alt", String(alt), ctx)}`;
+  if (fetchpriority) imgAttrs += ` fetchpriority="${escapeJSX(String(fetchpriority))}"`;
+  if (loading) imgAttrs += ` loading="${escapeJSX(String(loading))}"`;
+  if (width !== void 0) imgAttrs += ` width="${escapeJSX(String(width))}"`;
+  if (height !== void 0) imgAttrs += ` height="${escapeJSX(String(height))}"`;
+  let blurStyle = "";
+  if (metadata?.blurHash) {
+    blurStyle = ` style="background-image: url(${escapeJSX(metadata.blurHash)}); background-size: cover;" onload="this.style.backgroundImage=''"`;
+  }
+  const ifExpr = emitIfOpen(node, ctx);
+  const ifClose = emitIfClose(node, ctx);
+  if (metadata?.avifSrcset) {
+    const classMatch = classExpr.match(/class="([^"]*)"/);
+    const classListMatch = classExpr.match(/class:list={\[(.+)\]}/);
+    if (classListMatch) {
+      return `${ifExpr}${ind(ctx)}<picture${classExpr}${styleAttr}>
+${ind(ctx)}  <source type="image/avif" srcset="${escapeJSX(metadata.avifSrcset)}" sizes="${escapeJSX(sizesValue)}" />
+${ind(ctx)}  <source type="image/webp" srcset="${escapeJSX(metadata.srcset)}" sizes="${escapeJSX(sizesValue)}" />
+${ind(ctx)}  <img${imgAttrs}${blurStyle}${otherAttrsStr} />
+${ind(ctx)}</picture>
+${ifClose}`;
+    }
+    const allClasses = classMatch ? classMatch[1].split(/\s+/).filter(Boolean) : [];
+    const { pictureClasses, imgClasses } = splitImageClasses(allClasses);
+    const pictureClassAttr = pictureClasses.length > 0 ? ` class="${pictureClasses.join(" ")}"` : "";
+    const imgClassAttr = imgClasses.length > 0 ? ` class="${imgClasses.join(" ")}"` : "";
+    return `${ifExpr}${ind(ctx)}<picture${pictureClassAttr}${styleAttr}>
+${ind(ctx)}  <source type="image/avif" srcset="${escapeJSX(metadata.avifSrcset)}" sizes="${escapeJSX(sizesValue)}" />
+${ind(ctx)}  <source type="image/webp" srcset="${escapeJSX(metadata.srcset)}" sizes="${escapeJSX(sizesValue)}" />
+${ind(ctx)}  <img${imgClassAttr}${imgAttrs}${blurStyle}${otherAttrsStr} />
+${ind(ctx)}</picture>
+${ifClose}`;
+  }
+  if (metadata?.srcset) {
+    imgAttrs += ` srcset="${escapeJSX(metadata.srcset)}"`;
+    imgAttrs += ` sizes="${escapeJSX(sizesValue)}"`;
+  }
+  return `${ifExpr}${ind(ctx)}<img${classExpr}${styleAttr}${imgAttrs}${blurStyle}${otherAttrsStr} />
+${ifClose}`;
+}
 function emitHtmlNode(node, ctx) {
   let tag = node.tag;
+  if (tag && /^[A-Z]/.test(tag)) {
+    tag = tag.toLowerCase();
+  }
+  if (tag === "img" && ctx.imageMetadataMap) {
+    return emitImageNode(node, ctx);
+  }
   const label = node.label;
   const style = node.style;
   let isDynamic = false;
@@ -854,16 +1212,40 @@ function emitComponentInstance(node, ctx) {
   const ifExpr = emitIfOpen(node, ctx);
   const propParts = [];
   if (node.props) {
-    for (const [key, value] of Object.entries(node.props)) {
+    for (const [key, rawValue] of Object.entries(node.props)) {
       if (key === "children") continue;
+      const value = resolveI18n(rawValue, ctx);
       if (typeof value === "string" && hasTemplates(value) && ctx.isComponentDef) {
         const fullMatch = value.match(/^\{\{(.+)\}\}$/);
         if (fullMatch) {
-          propParts.push(`${key}={${fullMatch[1].trim()}}`);
+          let expr = fullMatch[1].trim();
+          if (ctx.listItemBinding) expr = rewriteItemVar(expr, ctx.listItemBinding);
+          if (ctx.listIndexVar) expr = replaceItemMetaVars(expr, ctx.listIndexVar, ctx.listSourceVar);
+          propParts.push(`${key}={${expr}}`);
         } else {
-          const resolved = value.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
+          const resolved = value.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
+            let trimmed = expr.trim();
+            if (ctx.listItemBinding) trimmed = rewriteItemVar(trimmed, ctx.listItemBinding);
+            if (ctx.listIndexVar) trimmed = replaceItemMetaVars(trimmed, ctx.listIndexVar, ctx.listSourceVar);
+            return `\${${trimmed}}`;
+          });
           propParts.push(`${key}={\`${resolved}\`}`);
         }
+      } else if (typeof value === "string" && ctx.cmsMode && /\{\{cms\./.test(value)) {
+        const b = ctx.cmsEntryBinding || "entry";
+        const w = (expr) => ctx.cmsWrapFn ? `${ctx.cmsWrapFn}(${expr})` : expr;
+        const fullMatch = value.match(/^\{\{cms\.([^}]+)\}\}$/);
+        if (fullMatch) {
+          propParts.push(`${key}={${w(`${b}.data.${fullMatch[1].trim()}`)}}`);
+        } else {
+          const replaced = value.replace(/\{\{cms\.([^}]+)\}\}/g, (_, fieldPath) => {
+            return `\${${w(`${b}.data.${fieldPath.trim()}`)}}`;
+          });
+          propParts.push(`${key}={\`${replaced}\`}`);
+        }
+      } else if (ctx.isComponentDef && isI18nValue(value)) {
+        ctx.needsI18nResolver = true;
+        propParts.push(`${key}={r(${JSON.stringify(value)})}`);
       } else {
         propParts.push(`${key}=${formatPropValue(value)}`);
       }
@@ -946,26 +1328,55 @@ function emitLinkNode(node, ctx) {
       finalClassExpr = ' class="olink"';
     }
   }
+  const resolvedHref = resolveI18n(node.href, ctx);
+  const nodeHref = resolvedHref;
   let hrefAttr;
-  if (isLinkMapping(node.href)) {
+  if (isLinkMapping(nodeHref)) {
     if (ctx.isComponentDef) {
-      const propRef = node.href.prop;
-      hrefAttr = ` href={${propRef}.href}`;
+      const propRef = nodeHref.prop;
+      hrefAttr = ` href={${propRef}?.href ?? "#"}`;
     } else {
       hrefAttr = ' href="#"';
     }
   } else {
-    const href = typeof node.href === "string" ? node.href : "#";
+    const href = typeof nodeHref === "string" ? nodeHref : "#";
     if (hasTemplates(href) && ctx.isComponentDef) {
       const fullMatch = href.match(/^\{\{(.+)\}\}$/);
       if (fullMatch) {
-        hrefAttr = ` href={${fullMatch[1].trim()}}`;
+        let expr = fullMatch[1].trim();
+        if (ctx.listItemBinding) expr = rewriteItemVar(expr, ctx.listItemBinding);
+        if (ctx.listIndexVar) expr = replaceItemMetaVars(expr, ctx.listIndexVar, ctx.listSourceVar);
+        const propDef = ctx.componentProps[expr];
+        if (propDef && propDef.type === "link") {
+          hrefAttr = ` href={${expr}?.href ?? "#"}`;
+        } else {
+          hrefAttr = ` href={${expr}}`;
+        }
       } else {
-        const resolved = href.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
+        const resolved = href.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
+          let trimmed = expr.trim();
+          if (ctx.listItemBinding) trimmed = rewriteItemVar(trimmed, ctx.listItemBinding);
+          if (ctx.listIndexVar) trimmed = replaceItemMetaVars(trimmed, ctx.listIndexVar, ctx.listSourceVar);
+          const pd = ctx.componentProps[trimmed];
+          return pd?.type === "link" ? `\${${trimmed}?.href ?? "#"}` : `\${${trimmed}}`;
+        });
         hrefAttr = ` href={\`${resolved}\`}`;
       }
+    } else if (ctx.cmsMode && /\{\{cms\./.test(href)) {
+      const b = ctx.cmsEntryBinding || "entry";
+      const w = (expr) => ctx.cmsWrapFn ? `${ctx.cmsWrapFn}(${expr})` : expr;
+      const fullMatch = href.match(/^\{\{cms\.([^}]+)\}\}$/);
+      if (fullMatch) {
+        hrefAttr = ` href={${w(`${b}.data.${fullMatch[1].trim()}`)}}`;
+      } else {
+        const replaced = href.replace(/\{\{cms\.([^}]+)\}\}/g, (_, fieldPath) => {
+          return `\${${w(`${b}.data.${fieldPath.trim()}`)}}`;
+        });
+        hrefAttr = ` href={\`${replaced}\`}`;
+      }
     } else {
-      hrefAttr = ` href="${escapeJSX(href)}"`;
+      const localizedHref = localizeHref(href, ctx);
+      hrefAttr = ` href="${escapeJSX(localizedHref)}"`;
     }
   }
   const attrs = buildAttributesString(node.attributes, ctx);
@@ -978,6 +1389,234 @@ ${emitIfClose(node, ctx)}`;
 ` + children + `${ind(ctx)}</a>
 ${emitIfClose(node, ctx)}`;
 }
+function emitImageTypeNode(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 src = node.src;
+  const alt = node.alt;
+  let imgAttrs = "";
+  if (src) imgAttrs += ` src="${escapeJSX(String(src))}"`;
+  if (alt !== void 0) imgAttrs += ` alt="${escapeJSX(String(alt))}"`;
+  const metadata = src ? ctx.imageMetadataMap?.get(String(src)) : void 0;
+  if (metadata) {
+    let width = metadata.width;
+    let height = metadata.height;
+    if (width !== void 0) imgAttrs += ` width="${width}"`;
+    if (height !== void 0) imgAttrs += ` height="${height}"`;
+    let blurStyle = "";
+    if (metadata.blurHash) {
+      blurStyle = ` style="background-image: url(${escapeJSX(metadata.blurHash)}); background-size: cover;" onload="this.style.backgroundImage=''"`;
+    }
+    const sizesValue = DEFAULT_SIZES2;
+    if (metadata.avifSrcset) {
+      const classMatch = classExpr.match(/class="([^"]*)"/);
+      const allClasses = classMatch ? classMatch[1].split(/\s+/).filter(Boolean) : [];
+      const { pictureClasses, imgClasses } = splitImageClasses(allClasses);
+      const pictureClassAttr = pictureClasses.length > 0 ? ` class="${pictureClasses.join(" ")}"` : "";
+      const imgClassAttr = imgClasses.length > 0 ? ` class="${imgClasses.join(" ")}"` : "";
+      return `${ind(ctx)}<picture${pictureClassAttr}${styleAttr}>
+${ind(ctx)}  <source type="image/avif" srcset="${escapeJSX(metadata.avifSrcset)}" sizes="${escapeJSX(sizesValue)}" />
+${ind(ctx)}  <source type="image/webp" srcset="${escapeJSX(metadata.srcset)}" sizes="${escapeJSX(sizesValue)}" />
+${ind(ctx)}  <img${imgClassAttr}${imgAttrs}${blurStyle} />
+${ind(ctx)}</picture>
+`;
+    }
+    if (metadata.srcset) {
+      imgAttrs += ` srcset="${escapeJSX(metadata.srcset)}"`;
+      imgAttrs += ` sizes="${escapeJSX(sizesValue)}"`;
+    }
+  }
+  return `${ind(ctx)}<img${classExpr}${styleAttr}${imgAttrs} />
+`;
+}
+function emitListNode(node, ctx) {
+  const sourceType = node.sourceType || "prop";
+  const itemAs = node.itemAs || "item";
+  if (sourceType === "collection") {
+    return emitCollectionListNode(node, ctx);
+  }
+  if (!ctx.isComponentDef && !ctx.listItemBinding) {
+    return emitFallback(ctx);
+  }
+  let source = node.source || "items";
+  const templateMatch = source.match(/^\{\{(.+)\}\}$/);
+  if (templateMatch) {
+    source = templateMatch[1].trim();
+  }
+  let mapSource = source;
+  if (node.offset && node.limit) {
+    mapSource = `${source}.slice(${node.offset}, ${node.offset + node.limit})`;
+  } else if (node.offset) {
+    mapSource = `${source}.slice(${node.offset})`;
+  } else if (node.limit) {
+    mapSource = `${source}.slice(0, ${node.limit})`;
+  }
+  const indexVar = `${itemAs}Index`;
+  const innerCtx = {
+    ...ctx,
+    indent: ctx.indent + 1,
+    listItemBinding: itemAs,
+    listIndexVar: indexVar,
+    listSourceVar: mapSource,
+    elementPath: [...ctx.elementPath, 0]
+  };
+  const children = node.children ? node.children.map((child, i) => {
+    const childCtx = { ...innerCtx, elementPath: [...ctx.elementPath, i] };
+    const out = nodeToAstro(child, childCtx);
+    if (childCtx.needsI18nResolver) ctx.needsI18nResolver = true;
+    return out;
+  }).join("") : "";
+  return `${ind(ctx)}{${mapSource}.map((${itemAs}, ${indexVar}) => (
+` + children + `${ind(ctx)}))}
+`;
+}
+function emitCollectionListNode(node, ctx) {
+  const source = node.source || "";
+  const itemAs = node.itemAs || singularize(source);
+  if (!ctx.frontmatterLines) ctx.frontmatterLines = [];
+  if (!ctx.astroImports) ctx.astroImports = /* @__PURE__ */ new Set();
+  ctx.astroImports.add("getCollection");
+  const collectionVar = `${source}List`;
+  let queryChain = `await getCollection('${source}')`;
+  if (node.filter) {
+    if (typeof node.filter === "object" && !Array.isArray(node.filter) && "field" in node.filter) {
+      const f = node.filter;
+      const op = f.operator || "eq";
+      if (op === "eq") {
+        queryChain += `.then(items => items.filter(e => e.data.${f.field} === ${JSON.stringify(f.value)}))`;
+      }
+    }
+  }
+  if (node.sort) {
+    const sortConfig = Array.isArray(node.sort) ? node.sort[0] : node.sort;
+    if (sortConfig) {
+      const order = sortConfig.order === "desc" ? -1 : 1;
+      queryChain += `.then(items => items.sort((a, b) => a.data.${sortConfig.field} > b.data.${sortConfig.field} ? ${order} : ${-order}))`;
+    }
+  }
+  if (node.offset || node.limit) {
+    const start = node.offset || 0;
+    const end = node.limit ? start + node.limit : void 0;
+    queryChain += `.then(items => items.slice(${start}${end !== void 0 ? `, ${end}` : ""}))`;
+  }
+  ctx.frontmatterLines.push(`const ${collectionVar} = ${queryChain};`);
+  const indexVar = `${itemAs}Index`;
+  const innerCtx = {
+    ...ctx,
+    indent: ctx.indent + 1,
+    listItemBinding: itemAs,
+    listIndexVar: indexVar,
+    listSourceVar: collectionVar,
+    cmsMode: true,
+    cmsEntryBinding: itemAs,
+    elementPath: [...ctx.elementPath, 0]
+  };
+  const children = node.children ? node.children.map((child, i) => {
+    const childCtx = { ...innerCtx, elementPath: [...ctx.elementPath, i] };
+    const out = nodeToAstro(child, childCtx);
+    if (childCtx.needsI18nResolver) ctx.needsI18nResolver = true;
+    return out;
+  }).join("") : "";
+  return `${ind(ctx)}{${collectionVar}.map((${itemAs}, ${indexVar}) => (
+` + children + `${ind(ctx)}))}
+`;
+}
+function emitLocaleListNode(node, ctx) {
+  if (!ctx.i18nConfig || !ctx.currentPageSlugMap) {
+    return emitFallback(ctx);
+  }
+  const i18nConfig = ctx.i18nConfig;
+  const slugMap = ctx.currentPageSlugMap;
+  const showCurrent = node.showCurrent !== false;
+  const showSeparator = node.showSeparator !== false;
+  const showFlag = node.showFlag !== false;
+  const displayType = node.displayType || "nativeName";
+  const style = node.style;
+  let elementClass = null;
+  if (node.interactiveStyles && node.interactiveStyles.length > 0 || node.generateElementClass) {
+    elementClass = buildElementClass(ctx, node.label);
+  }
+  const { classExpr: containerClassExpr, styleAttr: containerStyleAttr } = buildClassAndStyleExpression(
+    style,
+    node.interactiveStyles,
+    elementClass,
+    ctx
+  );
+  const itemStyle = node.itemStyle;
+  const itemResult = itemStyle ? responsiveStylesToTailwind(itemStyle, ctx.breakpoints) : { classes: [], dynamicStyles: {} };
+  const itemClasses = itemResult.classes;
+  const activeItemStyle = node.activeItemStyle;
+  const activeResult = activeItemStyle ? responsiveStylesToTailwind(activeItemStyle, ctx.breakpoints) : { classes: [], dynamicStyles: {} };
+  const activeItemClasses = [...itemClasses, ...activeResult.classes];
+  const separatorStyle = node.separatorStyle;
+  const sepResult = separatorStyle ? responsiveStylesToTailwind(separatorStyle, ctx.breakpoints) : { classes: [], dynamicStyles: {} };
+  const separatorClasses = sepResult.classes;
+  const localeIconMap = /* @__PURE__ */ new Map();
+  for (const localeConfig of i18nConfig.locales) {
+    if (localeConfig.icon) {
+      localeIconMap.set(localeConfig.code, localeConfig.icon);
+    }
+  }
+  const flagStyle = node.flagStyle;
+  const flagResult = flagStyle ? responsiveStylesToTailwind(flagStyle, ctx.breakpoints) : { classes: [], dynamicStyles: {} };
+  const flagClasses = flagResult.classes;
+  const links = [];
+  const currentLocale = ctx.locale || i18nConfig.defaultLocale;
+  for (const localeConfig of i18nConfig.locales) {
+    const code = localeConfig.code;
+    const isCurrent = code === currentLocale;
+    if (!showCurrent && isCurrent) continue;
+    const path = slugMap[code] || "/";
+    const classes = isCurrent ? activeItemClasses : itemClasses;
+    const classAttr = classes.length > 0 ? ` class="${classes.join(" ")}"` : "";
+    const currentAttr = isCurrent ? ' data-current="true"' : ' data-current="false"';
+    const hreflangAttr = ` hreflang="${localeConfig.langTag}"`;
+    let displayText;
+    switch (displayType) {
+      case "code":
+        displayText = code.toUpperCase();
+        break;
+      case "name":
+        displayText = localeConfig.name;
+        break;
+      case "nativeName":
+      default:
+        displayText = localeConfig.nativeName;
+        break;
+    }
+    let linkContent = "";
+    const localeIcon = localeIconMap.get(code);
+    if (showFlag && localeIcon) {
+      const flagClassAttr = flagClasses.length > 0 ? ` class="${flagClasses.join(" ")}"` : "";
+      linkContent += `<img src="${escapeJSX(localeIcon)}" alt="${escapeJSX(localeConfig.nativeName)} flag"${flagClassAttr}>`;
+    }
+    linkContent += `<div>${escapeJSX(displayText)}</div>`;
+    links.push(`${ind(ctx)}  <a href="${escapeJSX(path)}"${hreflangAttr}${currentAttr} data-locale="${escapeJSX(code)}"${classAttr}>${linkContent}</a>`);
+  }
+  let linksContent;
+  if (showSeparator && links.length > 1) {
+    const sepClassAttr = separatorClasses.length > 0 ? ` class="${separatorClasses.join(" ")}"` : "";
+    linksContent = links.join(`
+${ind(ctx)}  <span${sepClassAttr}></span>
+`);
+  } else {
+    linksContent = links.join("\n");
+  }
+  const attrs = buildAttributesString(node.attributes, ctx);
+  return `${ind(ctx)}<div data-locale-list="true"${containerClassExpr}${containerStyleAttr}${attrs}>
+` + linksContent + `
+${ind(ctx)}</div>
+`;
+}
 function emitFallback(ctx) {
   const pathKey = ctx.elementPath.join(".");
   const ssrHtml = ctx.ssrFallbacks.get(pathKey);
@@ -997,14 +1636,43 @@ function emitIfOpen(node, ctx) {
 `;
   }
   if (typeof ifValue === "object" && ifValue._mapping && ctx.isComponentDef) {
-    return `${ind(ctx)}{${ifValue.prop} && (
+    const trueValues = Object.entries(ifValue.values).filter(([, v]) => v === true).map(([k]) => `'${k}'`);
+    if (trueValues.length === 0) return `${ind(ctx)}{/* hidden */}
+`;
+    if (trueValues.length === 1) {
+      return `${ind(ctx)}{${ifValue.prop} === ${trueValues[0]} && (
+`;
+    }
+    return `${ind(ctx)}{[${trueValues.join(", ")}].includes(${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} && (
+  if (typeof ifValue === "string") {
+    if (ctx.cmsMode && ifValue.includes("{{cms.")) {
+      const match = ifValue.match(/^\{\{cms\.([^}]+)\}\}$/);
+      if (match) {
+        const binding = ctx.cmsEntryBinding || "entry";
+        return `${ind(ctx)}{${binding}.data.${match[1].trim()} && (
 `;
+      }
+    }
+    if (ctx.listItemBinding && /\{\{/.test(ifValue)) {
+      const match = ifValue.match(/^\{\{([^}]+)\}\}$/);
+      if (match) {
+        let expr = match[1].trim();
+        expr = rewriteItemVar(expr, ctx.listItemBinding);
+        if (ctx.listIndexVar) expr = replaceItemMetaVars(expr, ctx.listIndexVar, ctx.listSourceVar);
+        return `${ind(ctx)}{${expr} && (
+`;
+      }
+    }
+    if (ctx.isComponentDef) {
+      const fullMatch = ifValue.match(/^\{\{(.+)\}\}$/);
+      let expr = fullMatch ? fullMatch[1].trim() : ifValue.replace(/\{\{(.+?)\}\}/g, "$1");
+      if (ctx.listItemBinding) expr = rewriteItemVar(expr, ctx.listItemBinding);
+      if (ctx.listIndexVar) expr = replaceItemMetaVars(expr, ctx.listIndexVar, ctx.listSourceVar);
+      return `${ind(ctx)}{${expr} && (
+`;
+    }
   }
   return "";
 }
@@ -1012,22 +1680,40 @@ 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) {
+  if (typeof ifValue === "object" && ifValue._mapping && ctx.isComponentDef) {
     return `${ind(ctx)})}
 `;
   }
+  if (typeof ifValue === "string") {
+    const hasCmsCondition = ctx.cmsMode && ifValue.includes("{{cms.");
+    const hasItemCondition = ctx.listItemBinding && /\{\{/.test(ifValue);
+    if (hasCmsCondition || hasItemCondition || 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);
+    const out2 = nodeToAstro(children, innerCtx);
+    if (innerCtx.needsI18nResolver) ctx.needsI18nResolver = true;
+    return out2;
   }
   if (Array.isArray(children)) {
-    return nodeToAstro(children, innerCtx);
+    let result = "";
+    for (let i = 0; i < children.length; i++) {
+      const childCtx = { ...innerCtx, elementPath: [...ctx.elementPath, i] };
+      result += nodeToAstro(children[i], childCtx);
+      if (childCtx.needsI18nResolver) ctx.needsI18nResolver = true;
+    }
+    return result;
   }
-  return nodeToAstro(children, innerCtx);
+  const out = nodeToAstro(children, innerCtx);
+  if (innerCtx.needsI18nResolver) ctx.needsI18nResolver = true;
+  return out;
 }
 
 // lib/server/astro/componentEmitter.ts
@@ -1073,7 +1759,7 @@ function formatDefault(def) {
   }
   return JSON.stringify(val);
 }
-function emitAstroComponent(name, def, allComponents, breakpoints = DEFAULT_BREAKPOINTS) {
+function emitAstroComponent(name, def, allComponents, breakpoints = DEFAULT_BREAKPOINTS, defaultLocale = "en") {
   const comp = def.component;
   const propDefs = comp.interface || {};
   const structure = comp.structure;
@@ -1090,25 +1776,22 @@ function emitAstroComponent(name, def, allComponents, breakpoints = DEFAULT_BREA
     elementPath: [0],
     fileType: "component",
     fileName: name,
-    breakpoints
+    breakpoints,
+    defaultLocale
   };
   const templateBody = nodeToAstro(structure, ctx);
-  const frontmatter = buildFrontmatter(name, propDefs, ctx.imports, ctx.dynamicTags);
+  const frontmatter = buildFrontmatter(name, propDefs, ctx.imports, ctx.dynamicTags, ctx.needsI18nResolver ? defaultLocale : void 0);
   const styleSection = comp.css ? `
 <style>
 ${comp.css}
 </style>
 ` : "";
-  const scriptSection = comp.javascript ? `
-<script>
-${comp.javascript}
-</script>
-` : "";
+  const scriptSection = comp.javascript ? buildScriptSection(comp.javascript, comp, propDefs) : "";
   return `---
 ${frontmatter}---
 ${templateBody}${styleSection}${scriptSection}`;
 }
-function buildFrontmatter(componentName, propDefs, imports, dynamicTags) {
+function buildFrontmatter(componentName, propDefs, imports, dynamicTags, i18nDefaultLocale) {
   const lines = [];
   for (const imp of Array.from(imports).sort()) {
     lines.push(`import ${imp} from './${imp}.astro';`);
@@ -1131,6 +1814,8 @@ function buildFrontmatter(componentName, propDefs, imports, dynamicTags) {
       const defaultVal = formatDefault(propDef);
       if (defaultVal !== null) {
         destructParts.push(`${propName} = ${defaultVal}`);
+      } else if (propDef.type === "link") {
+        destructParts.push(`${propName} = { href: "#" }`);
       } else {
         destructParts.push(propName);
       }
@@ -1153,6 +1838,16 @@ function buildFrontmatter(componentName, propDefs, imports, dynamicTags) {
       lines.push(`const ${varName} = \`${templateExpr}\`;`);
     }
   }
+  if (i18nDefaultLocale) {
+    lines.push("");
+    lines.push(`const r = (v: any) => {`);
+    lines.push(`  if (v && typeof v === 'object' && v._i18n) {`);
+    lines.push(`    const locale = Astro.currentLocale ?? '${i18nDefaultLocale}';`);
+    lines.push(`    return v[locale] ?? v['${i18nDefaultLocale}'] ?? Object.values(v).find((s: any) => typeof s === 'string' && s !== '') ?? '';`);
+    lines.push(`  }`);
+    lines.push(`  return v ?? '';`);
+    lines.push(`};`);
+  }
   if (lines.length > 0) lines.push("");
   return lines.join("\n");
 }
@@ -1164,12 +1859,56 @@ ${comp.css}
 </style>
 `;
   if (comp.javascript) content += `
-<script>
+<script is:inline>
 ${comp.javascript}
 </script>
 `;
   return content;
 }
+function transformDefineVarsJS(js, varNames) {
+  let result = js;
+  result = result.replace(
+    /^\s*(const|let|var)\s+\{([^}]+)\}\s*=\s*props\s*;?\s*$/gm,
+    (match, _keyword, inner) => {
+      const names = inner.split(",").map((s) => s.trim()).filter(Boolean);
+      if (names.every((n) => varNames.includes(n))) return "";
+      return match;
+    }
+  );
+  const sorted = [...varNames].sort((a, b) => b.length - a.length);
+  for (const name of sorted) {
+    result = result.replace(new RegExp(`props\\.${name}\\b`, "g"), name);
+  }
+  for (const name of varNames) {
+    result = result.replace(
+      new RegExp(`^\\s*(var|let|const)\\s+${name}\\s*=[^;]*;?\\s*$`, "gm"),
+      ""
+    );
+  }
+  return result;
+}
+function buildScriptSection(js, comp, propDefs) {
+  const elInit = "const el = document.currentScript.previousElementSibling;";
+  if (comp.defineVars) {
+    const vars = comp.defineVars === true ? Object.keys(propDefs).filter((k) => k !== "children") : comp.defineVars;
+    if (vars.length > 0) {
+      const transformedJS = transformDefineVarsJS(js, vars);
+      const defineVarsObj = `{ ${vars.join(", ")} }`;
+      return `
+<script define:vars={${defineVarsObj}}>
+${elInit}
+${transformedJS}
+</script>
+`;
+    }
+  }
+  return `
+<script is:inline>
+${elInit}
+${js}
+</script>
+`;
+}
 
 // lib/server/astro/pageEmitter.ts
 function escapeTemplateLiteral2(s) {
@@ -1197,7 +1936,11 @@ function emitAstroPage(options) {
     fileDepth,
     ssrFallbacks,
     pageName,
-    breakpoints: breakpointsOpt
+    breakpoints: breakpointsOpt,
+    imageMetadataMap,
+    i18nConfig,
+    currentPageSlugMap,
+    slugMappings
   } = options;
   const breakpoints = breakpointsOpt ?? DEFAULT_BREAKPOINTS;
   const root = pageData.root;
@@ -1215,10 +1958,22 @@ function emitAstroPage(options) {
     elementPath: [0],
     fileType: "page",
     fileName: pageName,
-    breakpoints
+    breakpoints,
+    imageMetadataMap,
+    locale,
+    i18nConfig,
+    currentPageSlugMap,
+    frontmatterLines: [],
+    astroImports: /* @__PURE__ */ new Set(),
+    slugMappings,
+    i18nDefaultLocale: i18nConfig?.defaultLocale
   };
   const templateBody = nodeToAstro(root, ctx);
   const importLines = [];
+  if (ctx.astroImports && ctx.astroImports.size > 0) {
+    const astroImports = Array.from(ctx.astroImports);
+    importLines.push(`import { ${astroImports.join(", ")} } from 'astro:content';`);
+  }
   importLines.push(`import BaseLayout from '${layoutImportPath2}';`);
   const componentImports = Array.from(ctx.imports).sort();
   for (const comp of componentImports) {
@@ -1229,8 +1984,9 @@ function emitAstroPage(options) {
   const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral2(libraryTags.headCSS || "")}\`, headJS: \`${escapeTemplateLiteral2(libraryTags.headJS || "")}\`, bodyEndJS: \`${escapeTemplateLiteral2(libraryTags.bodyEndJS || "")}\` }`;
   const escapedMeta = escapeTemplateLiteral2(meta);
   const escapedFontPreloads = escapeTemplateLiteral2(fontPreloads);
+  const extraFrontmatter = ctx.frontmatterLines && ctx.frontmatterLines.length > 0 ? "\n" + ctx.frontmatterLines.join("\n") : "";
   return `---
-${importLines.join("\n")}
+${importLines.join("\n")}${extraFrontmatter}
 ---
 <BaseLayout
   title="${escapeJSX2(title)}"
@@ -1241,7 +1997,9 @@ ${importLines.join("\n")}
   fontPreloads={\`${escapedFontPreloads}\`}
   libraryTags={${libraryTagsLiteral}}
 >
-${templateBody}</BaseLayout>
+  <div id="root">
+${templateBody}  </div>
+</BaseLayout>
 `;
 }
 function buildEmptyPage(layoutImport, title, meta, locale, theme, fontPreloads, libraryTags, scriptPaths) {
@@ -1265,88 +2023,333 @@ import BaseLayout from '${layoutImport}';
 `;
 }
 
-// lib/server/astro/cssCollector.ts
-function isStyleMapping3(value) {
-  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
+// lib/server/astro/cmsPageEmitter.ts
+function escapeTemplateLiteral3(s) {
+  return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
 }
-function isResponsiveStyle3(style) {
-  return "base" in style || "tablet" in style || "mobile" in style;
+function escapeJSX3(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
 }
-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 componentImportPath2(fileDepth, componentName) {
+  const ups = "../".repeat(fileDepth + 1);
+  return `${ups}components/${componentName}.astro`;
 }
-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 collectRichTextFields(schema) {
+  const richTextFields = /* @__PURE__ */ new Set();
+  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+    if (fieldDef.type === "rich-text") {
+      richTextFields.add(fieldName);
     }
   }
+  return richTextFields;
 }
-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);
-      }
-    }
+function transformTitleExpression(title, binding, richTextFields, wrapFn) {
+  if (!/\{\{cms\./.test(title)) {
+    return `"${escapeJSX3(title)}"`;
   }
-  if ("children" in node && node.children) {
-    if (Array.isArray(node.children)) {
-      for (const child of node.children) {
-        walkNode(child, classes, breakpoints);
-      }
-    }
+  const w = (expr) => wrapFn ? `${wrapFn}(${expr})` : expr;
+  const fullMatch = title.match(/^\{\{cms\.([^}]+)\}\}$/);
+  if (fullMatch) {
+    return `{${w(`${binding}.data.${fullMatch[1].trim()}`)}}`;
   }
+  const replaced = title.replace(/\{\{cms\.([^}]+)\}\}/g, (_, fieldPath) => {
+    return `\${${w(`${binding}.data.${fieldPath.trim()}`)}}`;
+  });
+  return `{\`${replaced}\`}`;
 }
-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);
+function extractPathPrefix(urlPattern) {
+  const withoutLeading = urlPattern.replace(/^\//, "");
+  const idx = withoutLeading.indexOf("{{");
+  if (idx <= 0) return "";
+  return withoutLeading.substring(0, idx);
+}
+function buildGetStaticPaths(schema, isMultiLocale, i18nConfig, locale) {
+  const collectionId = schema.id;
+  const slugField = schema.slugField || "slug";
+  const pathPrefix = extractPathPrefix(schema.urlPattern);
+  const targetLocale = locale || i18nConfig.defaultLocale;
+  if (!isMultiLocale) {
+    const slugExpr = i18nConfig.locales.length > 1 ? `entry.data.${slugField}?.${targetLocale} || entry.data.${slugField} || entry.id` : `entry.data.${slugField} || entry.id`;
+    return [
+      `export async function getStaticPaths() {`,
+      `  const entries = await getCollection('${collectionId}');`,
+      `  return entries.map(entry => ({`,
+      `    params: { slug: ${slugExpr} },`,
+      `    props: { entry },`,
+      `  }));`,
+      `}`,
+      ``,
+      `const { entry } = Astro.props;`
+    ].join("\n");
+  }
+  const defaultLocale = i18nConfig.defaultLocale;
+  const locales = i18nConfig.locales;
+  const lines = [
+    `export async function getStaticPaths() {`,
+    `  const entries = await getCollection('${collectionId}');`,
+    `  const paths = [];`,
+    `  for (const entry of entries) {`
+  ];
+  for (const locale2 of locales) {
+    const code = locale2.code;
+    const slugExpr = `entry.data.${slugField}?.${code} || entry.data.${slugField} || entry.id`;
+    if (code === defaultLocale) {
+      if (pathPrefix) {
+        lines.push(
+          `    paths.push({`,
+          `      params: { slug: \`${pathPrefix}\${${slugExpr}}\` },`,
+          `      props: { entry, locale: '${code}' },`,
+          `    });`
+        );
+      } else {
+        lines.push(
+          `    paths.push({`,
+          `      params: { slug: ${slugExpr} },`,
+          `      props: { entry, locale: '${code}' },`,
+          `    });`
+        );
+      }
+    } else {
+      lines.push(
+        `    paths.push({`,
+        `      params: { slug: \`${code}/${pathPrefix}\${${slugExpr}}\` },`,
+        `      props: { entry, locale: '${code}' },`,
+        `    });`
+      );
     }
   }
-  return classes;
-}
-
-// build-astro.ts
-function hashContent2(content) {
-  return createHash("sha256").update(content).digest("hex").slice(0, 8);
+  lines.push(
+    `  }`,
+    `  return paths;`,
+    `}`,
+    ``,
+    `const { entry, locale = '${defaultLocale}' } = Astro.props;`
+  );
+  return lines.join("\n");
 }
-function copyDirectory(src, dest) {
-  if (!existsSync(src)) return;
-  if (!existsSync(dest)) mkdirSync(dest, { recursive: true });
-  const files = readdirSync(src);
-  for (const file of files) {
+function emitCMSPage(options) {
+  const {
+    pageData,
+    globalComponents,
+    cmsSchema,
+    title,
+    meta,
+    locale,
+    theme,
+    fontPreloads,
+    libraryTags,
+    scriptPaths,
+    layoutImportPath: layoutImportPath2,
+    fileDepth,
+    ssrFallbacks,
+    pageName,
+    breakpoints: breakpointsOpt,
+    imageMetadataMap,
+    i18nConfig,
+    isMultiLocale,
+    slugMappings
+  } = options;
+  const breakpoints = breakpointsOpt ?? DEFAULT_BREAKPOINTS;
+  const binding = "entry";
+  const richTextFields = collectRichTextFields(cmsSchema);
+  const wrapFn = "r";
+  const root = pageData.root;
+  if (!root) {
+    return buildEmptyCMSPage(
+      layoutImportPath2,
+      title,
+      meta,
+      locale,
+      theme,
+      fontPreloads,
+      libraryTags,
+      scriptPaths,
+      cmsSchema,
+      isMultiLocale,
+      i18nConfig,
+      binding,
+      richTextFields
+    );
+  }
+  const ctx = {
+    imports: /* @__PURE__ */ new Set(),
+    isComponentDef: false,
+    componentProps: {},
+    globalComponents,
+    indent: 1,
+    // inside BaseLayout
+    ssrFallbacks,
+    elementPath: [0],
+    fileType: "page",
+    fileName: pageName,
+    breakpoints,
+    imageMetadataMap,
+    locale,
+    cmsMode: true,
+    cmsEntryBinding: binding,
+    cmsRichTextFields: richTextFields,
+    cmsWrapFn: wrapFn,
+    slugMappings,
+    i18nDefaultLocale: i18nConfig.defaultLocale
+  };
+  const templateBody = nodeToAstro(root, ctx);
+  const importLines = [];
+  importLines.push(`import { getCollection } from 'astro:content';`);
+  importLines.push(`import BaseLayout from '${layoutImportPath2}';`);
+  const componentImports = Array.from(ctx.imports).sort();
+  for (const comp of componentImports) {
+    const path = componentImportPath2(fileDepth, comp);
+    importLines.push(`import ${comp} from '${path}';`);
+  }
+  const staticPaths = buildGetStaticPaths(cmsSchema, isMultiLocale, i18nConfig, locale);
+  const scriptsArrayLiteral = scriptPaths.length > 0 ? `[${scriptPaths.map((s) => `"${s}"`).join(", ")}]` : "[]";
+  const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral3(libraryTags.headCSS || "")}\`, headJS: \`${escapeTemplateLiteral3(libraryTags.headJS || "")}\`, bodyEndJS: \`${escapeTemplateLiteral3(libraryTags.bodyEndJS || "")}\` }`;
+  const escapedMeta = escapeTemplateLiteral3(meta).replace(
+    /\{\{cms\.([^}]+)\}\}/g,
+    (_, fieldPath) => `\${${wrapFn}(${binding}.data.${fieldPath.trim()})}`
+  );
+  const escapedFontPreloads = escapeTemplateLiteral3(fontPreloads);
+  const titleExpr = transformTitleExpression(title, binding, richTextFields, wrapFn);
+  const resolverHelper = `function r(v) {
+  if (v && typeof v === 'object' && v._i18n) return v['${locale}'] ?? v['${i18nConfig.defaultLocale}'] ?? Object.values(v).find(x => x !== true && x !== undefined) ?? '';
+  return v ?? '';
+}`;
+  return `---
+${importLines.join("\n")}
+
+${staticPaths}
+
+${resolverHelper}
+---
+<BaseLayout
+  title=${titleExpr}
+  meta={\`${escapedMeta}\`}
+  scripts={${scriptsArrayLiteral}}
+  locale="${locale}"
+  theme="${theme}"
+  fontPreloads={\`${escapedFontPreloads}\`}
+  libraryTags={${libraryTagsLiteral}}
+>
+  <div id="root">
+${templateBody}  </div>
+</BaseLayout>
+`;
+}
+function buildEmptyCMSPage(layoutImport, title, meta, locale, theme, fontPreloads, libraryTags, scriptPaths, cmsSchema, isMultiLocale, i18nConfig, binding, richTextFields) {
+  const escapedMeta = escapeTemplateLiteral3(meta);
+  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 || "")}\` }`;
+  const wrapFn = "r";
+  const staticPaths = buildGetStaticPaths(cmsSchema, isMultiLocale, i18nConfig, locale);
+  const titleExpr = transformTitleExpression(title, binding, richTextFields, wrapFn);
+  const resolverHelper = `function r(v) {
+  if (v && typeof v === 'object' && v._i18n) return v['${locale}'] ?? v['${i18nConfig.defaultLocale}'] ?? Object.values(v).find(x => x !== true && x !== undefined) ?? '';
+  return v ?? '';
+}`;
+  return `---
+import { getCollection } from 'astro:content';
+import BaseLayout from '${layoutImport}';
+
+${staticPaths}
+
+${resolverHelper}
+---
+<BaseLayout
+  title=${titleExpr}
+  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);
@@ -1357,13 +2360,6 @@ function copyDirectory(src, dest) {
 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;
@@ -1381,15 +2377,29 @@ function layoutImportPath(fileDepth) {
   const ups = "../".repeat(fileDepth + 1);
   return `${ups}layouts/BaseLayout.astro`;
 }
-function escapeTemplateLiteral3(s) {
+function escapeTemplateLiteral4(s) {
   return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
 }
+function computePageSlugMap(slugs, i18nConfig) {
+  const map = {};
+  for (const localeConfig of i18nConfig.locales) {
+    const code = localeConfig.code;
+    const isDefault = code === i18nConfig.defaultLocale;
+    const slug = slugs[code] || "";
+    if (isDefault) {
+      map[code] = slug === "" ? "/" : `/${slug}`;
+    } else {
+      map[code] = slug === "" ? `/${code}` : `/${code}/${slug}`;
+    }
+  }
+  return map;
+}
 function cmsFieldToZod(field) {
   switch (field.type) {
     case "string":
     case "text":
     case "rich-text":
-      return "z.string()";
+      return "z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()])";
     case "number":
       return "z.number()";
     case "boolean":
@@ -1412,11 +2422,11 @@ function cmsFieldToZod(field) {
   }
 }
 function buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths) {
-  const escapedMeta = escapeTemplateLiteral3(result.meta);
-  const escapedHTML = escapeTemplateLiteral3(result.html);
-  const escapedFontPreloads = escapeTemplateLiteral3(fontPreloads);
+  const escapedMeta = escapeTemplateLiteral4(result.meta);
+  const escapedHTML = escapeTemplateLiteral4(result.html);
+  const escapedFontPreloads = escapeTemplateLiteral4(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 || "")}\` }`;
+  const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral4(libraryTags.headCSS || "")}\`, headJS: \`${escapeTemplateLiteral4(libraryTags.headJS || "")}\`, bodyEndJS: \`${escapeTemplateLiteral4(libraryTags.bodyEndJS || "")}\` }`;
   return `---
 import BaseLayout from '${importPath}';
 ---
@@ -1463,6 +2473,11 @@ async function buildAstroProject(projectRoot, outputDir) {
   await configService.load();
   const globalLibraries = configService.getLibraries();
   const componentLibraries = collectComponentLibraries(globalComponents);
+  const imageMetadataMap = await buildImageMetadataMap();
+  if (imageMetadataMap.size > 0) {
+    console.log(`Loaded image metadata for ${imageMetadataMap.size} image(s)
+`);
+  }
   const outDir = outputDir || join(projectPaths.project, "astro-export");
   if (existsSync(outDir)) {
     rmSync(outDir, { recursive: true, force: true });
@@ -1517,7 +2532,7 @@ async function buildAstroProject(projectRoot, outputDir) {
       }
     }
   }
-  function processRenderResult(result, urlPath, astroFilePath, fileDepth, pageData, pageName, isCMSPage2) {
+  function processRenderResult(result, urlPath, astroFilePath, fileDepth, pageData, pageName, isCMSPage3) {
     mergeInteractiveStyles(result.interactiveStylesMap);
     if (result.componentCSS) {
       allComponentCSS.add(result.componentCSS);
@@ -1541,7 +2556,8 @@ async function buildAstroProject(projectRoot, outputDir) {
       astroFilePath,
       pageData,
       pageName,
-      isCMSPage: isCMSPage2
+      isCMSPage: isCMSPage3,
+      ssrFallbackCollector: result.ssrFallbackCollector
     });
   }
   for (const file of pageFiles) {
@@ -1598,6 +2614,11 @@ async function buildAstroProject(projectRoot, outputDir) {
       errorCount++;
     }
   }
+  const fontPreloads = generateFontPreloadTags();
+  const mergedLibraries = mergeLibraries(globalLibraries, componentLibraries);
+  const buildLibraries = filterLibrariesByContext(mergedLibraries, "build");
+  const libraryTags = generateLibraryTags(buildLibraries);
+  const defaultTheme = themeConfig.default || "light";
   const templatesDir = projectPaths.templates();
   const templateSchemas = [];
   let cmsPageCount = 0;
@@ -1626,42 +2647,87 @@ Processing ${templateFiles.length} CMS template(s)...
         templateSchemas.push(cmsSchema);
         console.log(`  CMS Collection: ${cmsSchema.id}`);
         const items = await cmsService.queryItems({ collection: cmsSchema.id });
-        if (items.length === 0) {
+        const itemCount = items.length;
+        if (itemCount === 0) {
           console.log(`    No items found in cms/${cmsSchema.id}/`);
-          continue;
+        } else {
+          console.log(`    Found ${itemCount} item(s)`);
         }
-        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++;
+        const defaultLocale = i18nConfig.defaultLocale;
+        const dummyPath = cmsSchema.urlPattern.replace("{{slug}}", "__placeholder__");
+        const metaResult = await renderPageSSR(
+          pageData,
+          globalComponents,
+          dummyPath,
+          siteUrl,
+          defaultLocale,
+          i18nConfig,
+          slugMappings,
+          void 0,
+          // no CMS context - just collecting metadata
+          cmsService,
+          true
+        );
+        mergeInteractiveStyles(metaResult.interactiveStylesMap);
+        if (metaResult.componentCSS) {
+          allComponentCSS.add(metaResult.componentCSS);
+        }
+        const scriptPaths = [];
+        if (metaResult.javascript) {
+          const hash = hashContent2(metaResult.javascript);
+          if (!jsContents.has(hash)) {
+            jsContents.set(hash, metaResult.javascript);
+          }
+          scriptPaths.push(`/_scripts/${hash}.js`);
+        }
+        const isMultiLocale = i18nConfig.locales.length > 1;
+        const urlPatternWithoutSlash = cmsSchema.urlPattern.replace(/^\//, "");
+        const slugPlaceholderIdx = urlPatternWithoutSlash.indexOf("{{");
+        const pathPrefix = slugPlaceholderIdx > 0 ? urlPatternWithoutSlash.substring(0, slugPlaceholderIdx) : "";
+        const ssrFallbacks = metaResult.ssrFallbackCollector ?? /* @__PURE__ */ new Map();
+        const localesToEmit = isMultiLocale ? i18nConfig.locales : [{ code: i18nConfig.defaultLocale }];
+        for (const localeEntry of localesToEmit) {
+          const localeCode = localeEntry.code;
+          const isDefault = localeCode === i18nConfig.defaultLocale;
+          let astroFilePath;
+          if (pathPrefix) {
+            astroFilePath = isDefault ? `${pathPrefix}[slug].astro` : `${localeCode}/${pathPrefix}[slug].astro`;
+          } else {
+            astroFilePath = isDefault ? "[slug].astro" : `${localeCode}/[slug].astro`;
           }
+          const fileDepth = astroFilePath.split("/").length - 1;
+          const importPath = layoutImportPath(fileDepth);
+          const astroContent = emitCMSPage({
+            pageData,
+            globalComponents,
+            cmsSchema,
+            title: String(pageData.meta?.title || cmsSchema.name),
+            meta: metaResult.meta,
+            locale: localeCode,
+            theme: defaultTheme,
+            fontPreloads,
+            libraryTags,
+            scriptPaths,
+            layoutImportPath: importPath,
+            fileDepth,
+            ssrFallbacks,
+            pageName: file.replace(".json", ""),
+            breakpoints,
+            imageMetadataMap,
+            i18nConfig,
+            isMultiLocale: false,
+            // Each file handles one locale
+            slugMappings
+          });
+          const astroFileFull = join(pagesOutDir, astroFilePath);
+          const astroFileDir = astroFileFull.substring(0, astroFileFull.lastIndexOf("/"));
+          if (!existsSync(astroFileDir)) {
+            mkdirSync(astroFileDir, { recursive: true });
+          }
+          await writeFile2(astroFileFull, astroContent, "utf-8");
         }
+        console.log(`    Generated: ${pathPrefix}[slug].astro (${itemCount} items \xD7 ${localesToEmit.length} locale(s))`);
+        cmsPageCount += itemCount * i18nConfig.locales.length;
       } catch (error) {
         console.error(`  Error processing template ${file}:`, error?.message || error);
         errorCount++;
@@ -1690,10 +2756,6 @@ Processing ${templateFiles.length} CMS template(s)...
   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';
 
@@ -1732,7 +2794,7 @@ 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);
+      const astroContent = emitAstroComponent(compName, compDef, globalComponents, breakpoints, i18nConfig.defaultLocale);
       await writeFile2(join(componentsOutDir, `${compName}.astro`), astroContent, "utf-8");
       componentFileCount++;
     } catch (error) {
@@ -1740,7 +2802,7 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
     }
   }
   console.log(`Generated ${componentFileCount} component .astro file(s)`);
-  const defaultTheme = themeConfig.default || "light";
+  const allFallbackHtml = [];
   for (const result of allResults) {
     const importPath = layoutImportPath(result.fileDepth);
     const scriptPaths = [];
@@ -1758,8 +2820,13 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
       scriptPaths.push(scriptPublicPath);
     }
     let astroContent;
-    if (result.pageData && !result.isCMSPage) {
+    if (result.pageData) {
       try {
+        const ssrFallbacks = result.ssrFallbackCollector ?? /* @__PURE__ */ new Map();
+        ssrFallbacks.forEach((html) => {
+          allFallbackHtml.push(html);
+        });
+        const pageSlugMap = result.pageData.meta?.slugs ? computePageSlugMap(result.pageData.meta.slugs, i18nConfig) : void 0;
         astroContent = emitAstroPage({
           pageData: result.pageData,
           globalComponents,
@@ -1772,10 +2839,13 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
           scriptPaths,
           layoutImportPath: importPath,
           fileDepth: result.fileDepth,
-          ssrFallbacks: /* @__PURE__ */ new Map(),
-          // SSR fallbacks for complex nodes
+          ssrFallbacks,
           pageName: result.pageName || "index",
-          breakpoints
+          breakpoints,
+          imageMetadataMap,
+          i18nConfig: i18nConfig.locales.length > 1 ? i18nConfig : void 0,
+          currentPageSlugMap: pageSlugMap,
+          slugMappings: i18nConfig.locales.length > 1 ? slugMappings : void 0
         });
       } catch (error) {
         console.warn(`  Warning: component emission failed for ${result.urlPath}, using SSR fallback: ${error?.message}`);
@@ -1783,6 +2853,7 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
       }
     } else {
       astroContent = buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths);
+      allFallbackHtml.push(result.html);
     }
     const astroFileFull = join(pagesOutDir, result.astroFilePath);
     const astroFileDir = astroFileFull.substring(0, astroFileFull.lastIndexOf("/"));
@@ -1792,6 +2863,22 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
     await writeFile2(astroFileFull, astroContent, "utf-8");
   }
   console.log(`Generated ${allResults.length} .astro page file(s)`);
+  if (allFallbackHtml.length > 0) {
+    const allClasses = /* @__PURE__ */ new Set();
+    for (const html of allFallbackHtml) {
+      for (const cls of extractUtilityClassesFromHTML(html)) {
+        allClasses.add(cls);
+      }
+    }
+    if (allClasses.size > 0) {
+      const utilityCSS = generateUtilityCSS(allClasses, breakpoints, responsiveScales);
+      if (utilityCSS) {
+        const existingCSS = await readFile(join(stylesDir, "global.css"), "utf-8");
+        await writeFile2(join(stylesDir, "global.css"), existingCSS + "\n\n/* SSR fallback utility classes */\n" + utilityCSS, "utf-8");
+        console.log(`Added ${allClasses.size} utility classes for SSR fallback content`);
+      }
+    }
+  }
   let collectionCount = 0;
   if (templateSchemas.length > 0) {
     const contentDir = join(srcDir, "content");
@@ -1807,14 +2894,7 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
           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;
-              }
-            }
+            const resolved = { ...item };
             await writeFile2(
               join(collectionDir, itemFile),
               JSON.stringify(resolved, null, 2),
@@ -1882,19 +2962,24 @@ export { collections };
     },
     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 localeCodes = i18nConfig.locales.map((l) => l.code);
+  const i18nBlock = i18nConfig.locales.length > 1 ? `
+  i18n: {
+    defaultLocale: '${i18nConfig.defaultLocale}',
+    locales: [${localeCodes.map((c) => `'${c}'`).join(", ")}],
+    routing: { prefixDefaultLocale: false },
+  },` : "";
   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 })],
+  site: '${siteUrl}',` : ""}${i18nBlock}
+  integrations: [tailwind({ applyBaseStyles: false })],
 });
 `;
   const safelistArray = Array.from(mappingClasses);
@@ -1943,6 +3028,730 @@ export default {
   };
 }
 
+// lib/server/webflow/buildWebflow.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join2 } from "path";
+
+// lib/server/webflow/types.ts
+function mapCMSFieldType(menoType) {
+  switch (menoType) {
+    case "string":
+      return "PlainText";
+    case "text":
+    case "rich-text":
+      return "RichText";
+    case "number":
+      return "Number";
+    case "boolean":
+      return "Switch";
+    case "image":
+      return "Image";
+    case "date":
+      return "Date";
+    case "select":
+      return "Option";
+    case "file":
+      return "File";
+    case "reference":
+      return "Reference";
+    default:
+      return "PlainText";
+  }
+}
+
+// lib/server/webflow/nodeToWebflow.ts
+init_constants();
+
+// lib/server/webflow/styleMapper.ts
+var UNITLESS_PROPERTIES = /* @__PURE__ */ new Set([
+  "opacity",
+  "z-index",
+  "flex-grow",
+  "flex-shrink",
+  "flex",
+  "order",
+  "orphans",
+  "widows",
+  "column-count",
+  "font-weight",
+  "tab-size"
+]);
+function isStyleMapping4(value) {
+  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
+}
+function isResponsiveStyle4(style) {
+  return "base" in style || "tablet" in style || "mobile" in style;
+}
+function toKebabCase(prop) {
+  return prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+function styleObjectToCSS(style) {
+  const css = {};
+  for (const [prop, value] of Object.entries(style)) {
+    if (isStyleMapping4(value)) continue;
+    if (value === "" || value === void 0 || value === null) continue;
+    if (typeof value === "boolean" || typeof value === "object") continue;
+    const cssProp = toKebabCase(prop);
+    if (typeof value === "number") {
+      if (isNaN(value)) continue;
+      css[cssProp] = UNITLESS_PROPERTIES.has(cssProp) ? String(value) : `${value}px`;
+    } else {
+      css[cssProp] = String(value);
+    }
+  }
+  return css;
+}
+function collectStyleMappings2(style) {
+  if (!style) return [];
+  const result = [];
+  if (isResponsiveStyle4(style)) {
+    const base = style.base;
+    if (base) {
+      for (const [prop, value] of Object.entries(base)) {
+        if (isStyleMapping4(value)) {
+          result.push({ property: prop, mapping: value });
+        }
+      }
+    }
+  } else {
+    for (const [prop, value] of Object.entries(style)) {
+      if (isStyleMapping4(value)) {
+        result.push({ property: prop, mapping: value });
+      }
+    }
+  }
+  return result;
+}
+function postfixToPseudoState(postfix) {
+  if (postfix.includes(":hover")) return "hover";
+  if (postfix.includes(":focus-visible")) return "focus-visible";
+  if (postfix.includes(":focus")) return "focus";
+  if (postfix.includes(":active")) return "active";
+  if (postfix.includes(":visited")) return "visited";
+  return null;
+}
+function mapStylesToWebflow(className, style, interactiveStyles, breakpoints) {
+  const webflowClassName = className.replace(/_/g, "-");
+  const primaryClass = {
+    name: webflowClassName,
+    base: {}
+  };
+  if (style) {
+    if (isResponsiveStyle4(style)) {
+      const responsive = style;
+      if (responsive.base) {
+        primaryClass.base = styleObjectToCSS(responsive.base);
+      }
+      if (responsive.tablet) {
+        if (!primaryClass.breakpoints) primaryClass.breakpoints = {};
+        primaryClass.breakpoints.Tablet = styleObjectToCSS(responsive.tablet);
+      }
+      if (responsive.mobile) {
+        if (!primaryClass.breakpoints) primaryClass.breakpoints = {};
+        primaryClass.breakpoints.MobilePortrait = styleObjectToCSS(responsive.mobile);
+      }
+      for (const [bpName, bpStyle] of Object.entries(responsive)) {
+        if (!bpStyle || bpName === "base" || bpName === "tablet" || bpName === "mobile") continue;
+        if (!primaryClass.breakpoints) primaryClass.breakpoints = {};
+        primaryClass.breakpoints.Tablet = {
+          ...primaryClass.breakpoints.Tablet,
+          ...styleObjectToCSS(bpStyle)
+        };
+      }
+    } else {
+      primaryClass.base = styleObjectToCSS(style);
+    }
+  }
+  if (interactiveStyles && interactiveStyles.length > 0) {
+    for (const rule of interactiveStyles) {
+      if (!rule.postfix) continue;
+      const pseudoState = postfixToPseudoState(rule.postfix);
+      if (!pseudoState) continue;
+      const ruleStyle = rule.style;
+      if (!primaryClass.pseudoStates) primaryClass.pseudoStates = {};
+      if (isResponsiveStyle4(ruleStyle)) {
+        const responsive = ruleStyle;
+        if (responsive.base) {
+          primaryClass.pseudoStates[pseudoState] = {
+            ...primaryClass.pseudoStates[pseudoState],
+            ...styleObjectToCSS(responsive.base)
+          };
+        }
+      } else {
+        primaryClass.pseudoStates[pseudoState] = {
+          ...primaryClass.pseudoStates[pseudoState],
+          ...styleObjectToCSS(ruleStyle)
+        };
+      }
+    }
+  }
+  const comboClasses = [];
+  const mappings = collectStyleMappings2(style);
+  for (const { property, mapping } of mappings) {
+    for (const [value, cssValue] of Object.entries(mapping.values)) {
+      if (cssValue === "" || cssValue === void 0) continue;
+      const comboName = `is-${sanitizeClassName(mapping.prop)}-${sanitizeClassName(String(value))}`;
+      const comboClass = {
+        name: comboName,
+        base: {
+          [toKebabCase(property)]: typeof cssValue === "number" ? UNITLESS_PROPERTIES.has(toKebabCase(property)) ? String(cssValue) : `${cssValue}px` : String(cssValue)
+        },
+        comboParent: webflowClassName
+      };
+      comboClasses.push(comboClass);
+    }
+  }
+  return { primaryClass, comboClasses };
+}
+function sanitizeClassName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
+// lib/server/webflow/nodeToWebflow.ts
+function buildElementClass2(ctx, label) {
+  return generateElementClassName({
+    fileType: ctx.fileType,
+    fileName: ctx.fileName,
+    label,
+    path: ctx.elementPath
+  });
+}
+function resolveTemplate2(text, props) {
+  if (!props) return text;
+  return text.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
+    const trimmed = expr.trim();
+    const orMatch = trimmed.match(/^(.+?)\s*\|\|\s*['"](.+?)['"]$/);
+    if (orMatch) {
+      const value2 = resolveNestedProp(props, orMatch[1].trim());
+      return value2 !== void 0 && value2 !== "" && value2 !== null ? String(value2) : orMatch[2];
+    }
+    const ternaryMatch = trimmed.match(/^(.+?)\s*\?\s*['"](.+?)['"]\s*:\s*['"](.+?)['"]$/);
+    if (ternaryMatch) {
+      const value2 = resolveNestedProp(props, ternaryMatch[1].trim());
+      return value2 ? ternaryMatch[2] : ternaryMatch[3];
+    }
+    const value = resolveNestedProp(props, trimmed);
+    return value !== void 0 ? String(value) : "";
+  });
+}
+function resolveNestedProp(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function hasTemplates2(text) {
+  return /\{\{.+?\}\}/.test(text);
+}
+function nodeToWebflow(node, ctx, instanceProps) {
+  if (node === null || node === void 0) return [];
+  if (typeof node === "string") {
+    const text = instanceProps ? resolveTemplate2(node, instanceProps) : node;
+    return [{ tag: "span", textContent: text }];
+  }
+  if (typeof node === "number") {
+    return [{ tag: "span", textContent: String(node) }];
+  }
+  if (Array.isArray(node)) {
+    const results = [];
+    for (let i = 0; i < node.length; i++) {
+      const child = node[i];
+      const savedPath = [...ctx.elementPath];
+      ctx.elementPath = [...ctx.elementPath, i];
+      results.push(...nodeToWebflow(child, ctx, instanceProps));
+      ctx.elementPath = savedPath;
+    }
+    return results;
+  }
+  switch (node.type) {
+    case NODE_TYPE.NODE:
+      return [emitHtmlNode2(node, ctx, instanceProps)];
+    case NODE_TYPE.COMPONENT:
+      return emitComponentInstance2(node, ctx, instanceProps);
+    case NODE_TYPE.SLOT:
+      return emitSlotMarker2(node, ctx, instanceProps);
+    case NODE_TYPE.EMBED:
+      return [emitEmbedNode2(node, ctx, instanceProps)];
+    case NODE_TYPE.LINK:
+      return [emitLinkNode2(node, ctx, instanceProps)];
+    case NODE_TYPE.LIST:
+    case "cms-list":
+    case NODE_TYPE.LOCALE_LIST:
+      return [{ tag: "div", attributes: { "data-meno-type": node.type } }];
+    default:
+      return [];
+  }
+}
+function emitHtmlNode2(node, ctx, instanceProps) {
+  const tag = hasTemplates2(node.tag) && instanceProps ? resolveTemplate2(node.tag, instanceProps) : node.tag;
+  const style = node.style;
+  const interactiveStyles = node.interactiveStyles;
+  const needsClass = style || interactiveStyles && interactiveStyles.length > 0 || node.generateElementClass;
+  let className;
+  let comboClassNames;
+  if (needsClass) {
+    const elementClass = buildElementClass2(ctx, node.label);
+    const { primaryClass, comboClasses } = mapStylesToWebflow(
+      elementClass,
+      style,
+      interactiveStyles,
+      ctx.breakpoints
+    );
+    className = primaryClass.name;
+    ctx.styleClasses.set(primaryClass.name, primaryClass);
+    if (comboClasses.length > 0) {
+      comboClassNames = [];
+      for (const combo of comboClasses) {
+        ctx.styleClasses.set(combo.name, combo);
+        comboClassNames.push(combo.name);
+      }
+    }
+  }
+  const attributes = {};
+  if (node.attributes) {
+    for (const [key, value] of Object.entries(node.attributes)) {
+      if (instanceProps && typeof value === "string" && hasTemplates2(value)) {
+        attributes[key] = resolveTemplate2(value, instanceProps);
+      } else {
+        attributes[key] = value;
+      }
+    }
+  }
+  let children;
+  let textContent;
+  if (!isVoidElement(tag) && node.children) {
+    if (typeof node.children === "string") {
+      textContent = instanceProps ? resolveTemplate2(node.children, instanceProps) : node.children;
+    } else if (Array.isArray(node.children) && node.children.length === 1 && typeof node.children[0] === "string") {
+      const text = node.children[0];
+      textContent = instanceProps ? resolveTemplate2(text, instanceProps) : text;
+    } else {
+      const innerCtx = { ...ctx, elementPath: [...ctx.elementPath] };
+      children = convertChildren(node.children, innerCtx, instanceProps);
+      if (children.length === 0) children = void 0;
+    }
+  }
+  let conditional;
+  const ifValue = node.if;
+  if (ifValue !== void 0 && ifValue !== true) {
+    if (typeof ifValue === "object" && ifValue._mapping) {
+      conditional = { prop: ifValue.prop, condition: "truthy" };
+    } else if (typeof ifValue === "string") {
+      const match = ifValue.match(/^\{\{(.+)\}\}$/);
+      conditional = { prop: match ? match[1].trim() : ifValue, condition: "truthy" };
+    }
+  }
+  const element = { tag };
+  if (className) element.className = className;
+  if (comboClassNames) element.comboClasses = comboClassNames;
+  if (textContent) element.textContent = textContent;
+  if (children) element.children = children;
+  if (Object.keys(attributes).length > 0) element.attributes = attributes;
+  if (conditional) element.conditional = conditional;
+  return element;
+}
+function emitComponentInstance2(node, ctx, parentProps) {
+  const compDef = ctx.globalComponents[node.component];
+  if (!compDef) {
+    return [{ tag: "div", attributes: { "data-component": node.component } }];
+  }
+  const resolvedProps = {};
+  const structured = compDef.component;
+  if (structured?.interface) {
+    for (const [key, propDef] of Object.entries(structured.interface)) {
+      resolvedProps[key] = propDef.default;
+    }
+  }
+  if (node.props) {
+    for (const [key, value] of Object.entries(node.props)) {
+      if (key === "children") continue;
+      if (typeof value === "string" && hasTemplates2(value) && parentProps) {
+        resolvedProps[key] = resolveTemplate2(value, parentProps);
+      } else {
+        resolvedProps[key] = value;
+      }
+    }
+  }
+  const body = structured?.structure || compDef.node;
+  if (!body) return [];
+  const compCtx = {
+    ...ctx,
+    fileType: "component",
+    fileName: node.component,
+    elementPath: [0],
+    slotChildren: node.children
+  };
+  return nodeToWebflow(body, compCtx, resolvedProps);
+}
+function emitSlotMarker2(node, ctx, instanceProps) {
+  if (ctx.slotChildren) {
+    const parentCtx = {
+      ...ctx,
+      slotChildren: void 0
+      // prevent infinite slot nesting
+    };
+    return convertChildren(ctx.slotChildren, parentCtx, instanceProps);
+  }
+  if (node.default) {
+    return convertChildren(node.default, ctx, instanceProps);
+  }
+  return [];
+}
+function emitEmbedNode2(node, ctx, instanceProps) {
+  const style = node.style;
+  const interactiveStyles = node.interactiveStyles;
+  let className;
+  if (style || interactiveStyles && interactiveStyles.length > 0) {
+    const elementClass = buildElementClass2(ctx, node.label);
+    const { primaryClass } = mapStylesToWebflow(
+      elementClass,
+      style,
+      interactiveStyles,
+      ctx.breakpoints
+    );
+    className = primaryClass.name;
+    ctx.styleClasses.set(primaryClass.name, primaryClass);
+  }
+  const htmlStr = typeof node.html === "string" ? node.html : "";
+  const element = {
+    tag: "div",
+    rawHtml: htmlStr
+  };
+  if (className) element.className = className;
+  return element;
+}
+function emitLinkNode2(node, ctx, instanceProps) {
+  const style = node.style;
+  const interactiveStyles = node.interactiveStyles;
+  let className;
+  if (style || interactiveStyles && interactiveStyles.length > 0) {
+    const elementClass = buildElementClass2(ctx, node.label);
+    const { primaryClass } = mapStylesToWebflow(
+      elementClass,
+      style,
+      interactiveStyles,
+      ctx.breakpoints
+    );
+    className = primaryClass.name;
+    ctx.styleClasses.set(primaryClass.name, primaryClass);
+  }
+  let href = "#";
+  if (typeof node.href === "string") {
+    href = instanceProps && hasTemplates2(node.href) ? resolveTemplate2(node.href, instanceProps) : node.href;
+  }
+  const attributes = { href };
+  if (node.attributes) {
+    for (const [key, value] of Object.entries(node.attributes)) {
+      attributes[key] = value;
+    }
+  }
+  let children;
+  if (node.children) {
+    children = convertChildren(node.children, ctx, instanceProps);
+    if (children.length === 0) children = void 0;
+  }
+  const element = { tag: "a", attributes };
+  if (className) element.className = className;
+  if (children) element.children = children;
+  return element;
+}
+function convertChildren(children, ctx, instanceProps) {
+  if (!children) return [];
+  if (typeof children === "string") {
+    return nodeToWebflow(children, ctx, instanceProps);
+  }
+  if (Array.isArray(children)) {
+    return nodeToWebflow(children, ctx, instanceProps);
+  }
+  return nodeToWebflow(children, ctx, instanceProps);
+}
+
+// lib/server/webflow/buildWebflow.ts
+function scanJSONFiles2(dir, prefix = "") {
+  const results = [];
+  if (!existsSync2(dir)) return results;
+  const entries = readdirSync2(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(...scanJSONFiles2(join2(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name));
+    }
+  }
+  return results;
+}
+function isCMSPage2(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 scanAssets(projectRoot) {
+  const assets = [];
+  const assetDirs = [
+    { dir: "images", type: "image" },
+    { dir: "fonts", type: "font" },
+    { dir: "videos", type: "video" },
+    { dir: "assets", type: "file" }
+  ];
+  for (const { dir, type } of assetDirs) {
+    const fullDir = join2(projectRoot, dir);
+    if (!existsSync2(fullDir)) continue;
+    const files = scanJSONFiles2(fullDir).map((f) => f.replace(".json", ""));
+    const allFiles = scanAllFiles(fullDir);
+    for (const file of allFiles) {
+      assets.push({
+        localPath: `${dir}/${file}`,
+        type,
+        fileName: file.split("/").pop()
+      });
+    }
+  }
+  return assets;
+}
+function scanAllFiles(dir, prefix = "") {
+  const results = [];
+  if (!existsSync2(dir)) return results;
+  const entries = readdirSync2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isFile()) {
+      results.push(relativePath);
+    } else if (entry.isDirectory()) {
+      results.push(...scanAllFiles(join2(dir, entry.name), relativePath));
+    }
+  }
+  return results;
+}
+function extractCSSVariables(themeColorCSS, variablesCSS) {
+  const vars = {};
+  const regex = /--([\w-]+)\s*:\s*([^;]+)/g;
+  for (const css of [themeColorCSS, variablesCSS]) {
+    let match;
+    while ((match = regex.exec(css)) !== null) {
+      vars[`--${match[1]}`] = match[2].trim();
+    }
+  }
+  return vars;
+}
+async function buildWebflowPayload(projectRoot) {
+  configService.reset();
+  const projectConfig = await loadProjectConfig();
+  const siteUrl = projectConfig.siteUrl?.replace(/\/$/, "") || "";
+  const i18nConfig = await loadI18nConfig();
+  await migrateTemplatesDirectory();
+  const { components } = await loadComponentDirectory(projectPaths.components());
+  const globalComponents = {};
+  components.forEach((value, key) => {
+    globalComponents[key] = value;
+  });
+  const cmsProvider = new FileSystemCMSProvider(projectPaths.templates(), projectPaths.cms());
+  const cmsService = new CMSService(cmsProvider);
+  await cmsService.initialize();
+  const themeConfig = await colorService.loadThemeConfig();
+  const variablesConfig = await variableService.loadConfig();
+  const breakpoints = await loadBreakpointConfig();
+  const responsiveScales = await loadResponsiveScalesConfig();
+  await configService.load();
+  const pagesDir = projectPaths.pages();
+  if (!existsSync2(pagesDir)) {
+    return emptyPayload();
+  }
+  const pageFiles = scanJSONFiles2(pagesDir);
+  if (pageFiles.length === 0) {
+    return emptyPayload();
+  }
+  const slugMappings = [];
+  for (const file of pageFiles) {
+    const pageName = file.replace(".json", "");
+    const basePath = mapPageNameToPath(pageName);
+    const pageContent = await loadJSONFile(join2(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 allPages = [];
+  const allStyleClasses = /* @__PURE__ */ new Map();
+  for (const file of pageFiles) {
+    const pageName = file.replace(".json", "");
+    const basePath = mapPageNameToPath(pageName);
+    const pageContent = await loadJSONFile(join2(pagesDir, file));
+    if (!pageContent) continue;
+    try {
+      const pageData = parseJSON(pageContent);
+      if (pageData.meta?.draft === true) 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 result = await renderPageSSR(
+          pageData,
+          globalComponents,
+          urlPath,
+          siteUrl,
+          locale,
+          i18nConfig,
+          slugMappings,
+          void 0,
+          cmsService,
+          true
+        );
+        const ctx = {
+          globalComponents,
+          elementPath: [0],
+          fileType: "page",
+          fileName: pageName,
+          breakpoints,
+          styleClasses: allStyleClasses
+        };
+        const body = pageData.root || pageData.node;
+        const elements = body ? nodeToWebflow(body, ctx) : [];
+        allPages.push({
+          title: result.title,
+          slug: slug || "index",
+          metaDescription: typeof pageData.meta?.description === "string" ? pageData.meta.description : void 0,
+          elements,
+          locale
+        });
+      }
+    } catch (error) {
+      console.error(`Error processing ${basePath}:`, error?.message);
+    }
+  }
+  const templatesDir = projectPaths.templates();
+  const cmsCollections = [];
+  if (existsSync2(templatesDir)) {
+    const templateFiles = readdirSync2(templatesDir).filter((f) => f.endsWith(".json"));
+    for (const file of templateFiles) {
+      const templateContent = await loadJSONFile(join2(templatesDir, file));
+      if (!templateContent) continue;
+      try {
+        const pageData = parseJSON(templateContent);
+        if (pageData.meta?.draft === true) continue;
+        if (!isCMSPage2(pageData)) continue;
+        const cmsSchema = pageData.meta.cms;
+        const items = await cmsService.queryItems({ collection: cmsSchema.id });
+        const fields = [];
+        if (cmsSchema.fields) {
+          for (const [fieldName, fieldDef] of Object.entries(cmsSchema.fields)) {
+            fields.push({
+              name: fieldDef.label || fieldName,
+              slug: fieldName,
+              type: mapCMSFieldType(fieldDef.type),
+              required: fieldDef.required,
+              options: fieldDef.options
+            });
+          }
+        }
+        const resolvedItems = [];
+        for (const item of items) {
+          const resolved = {};
+          for (const [key, value] of Object.entries(item)) {
+            if (isI18nValue(value)) {
+              resolved[key] = resolveI18nValue(value, i18nConfig.defaultLocale, i18nConfig);
+            } else {
+              resolved[key] = value;
+            }
+          }
+          resolvedItems.push(resolved);
+        }
+        cmsCollections.push({
+          name: cmsSchema.id,
+          slug: cmsSchema.id,
+          urlPattern: cmsSchema.urlPattern,
+          fields,
+          items: resolvedItems
+        });
+        for (const item of items) {
+          for (const localeConfig of i18nConfig.locales) {
+            const locale = localeConfig.code;
+            if (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 ctx = {
+              globalComponents,
+              elementPath: [0],
+              fileType: "page",
+              fileName: file.replace(".json", ""),
+              breakpoints,
+              styleClasses: allStyleClasses
+            };
+            const body = pageData.root || pageData.node;
+            const cmsProps = { cms: itemWithUrl };
+            const elements = body ? nodeToWebflow(body, ctx, cmsProps) : [];
+            const slug = itemPath.startsWith("/") ? itemPath.substring(1) : itemPath;
+            allPages.push({
+              title: result.title,
+              slug,
+              elements,
+              locale
+            });
+          }
+        }
+      } catch (error) {
+        console.error(`Error processing template ${file}:`, error?.message);
+      }
+    }
+  }
+  const themeColorCSS = generateThemeColorVariablesCSS(themeConfig);
+  const variablesCSS = generateVariablesCSS(variablesConfig, breakpoints, responsiveScales);
+  const cssVariables = extractCSSVariables(themeColorCSS, variablesCSS);
+  const assets = scanAssets(projectPaths.project);
+  return {
+    version: 1,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pages: allPages,
+    styles: Array.from(allStyleClasses.values()),
+    cms: cmsCollections,
+    assets,
+    cssVariables: Object.keys(cssVariables).length > 0 ? cssVariables : void 0
+  };
+}
+function emptyPayload() {
+  return {
+    version: 1,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pages: [],
+    styles: [],
+    cms: [],
+    assets: []
+  };
+}
+
 // lib/server/index.ts
 init_constants();
 export {
@@ -1970,6 +3779,7 @@ export {
   buildImageMetadataMap,
   buildLineMap,
   buildStaticPages,
+  buildWebflowPayload,
   bundleFile,
   clearJSValidationCache,
   collectComponentCSS,