meno-core 1.0.39 → 1.0.41

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-EQOSDQS2.js";
 import {
   ComponentService,
   EnumService,
@@ -32,7 +32,7 @@ import {
   logResponseTime,
   withErrorHandling,
   withLogging
-} from "../../chunks/chunk-HNAS6BSS.js";
+} from "../../chunks/chunk-SNUROC7E.js";
 import {
   CMSService,
   ColorService,
@@ -46,15 +46,12 @@ import {
   clearJSValidationCache,
   collectComponentCSS,
   collectComponentJavaScript,
-  collectComponentLibraries,
   colorService,
   createI18nResolver,
   escapeHtml,
   extractPageMeta,
-  filterLibrariesByContext,
   generateFontCSS,
   generateFontPreloadTags,
-  generateLibraryTags,
   generateMetaTags,
   generateSSRHTML,
   generateThemeColorVariablesCSS,
@@ -67,7 +64,6 @@ import {
   loadProjectConfig,
   loadResponsiveScalesConfig,
   mapPageNameToPath,
-  mergeLibraries,
   migrateTemplatesDirectory,
   parseJSON,
   processCMSPropsTemplate,
@@ -76,11 +72,11 @@ import {
   resetFontConfig,
   styleToString,
   variableService
-} from "../../chunks/chunk-W6HDII4T.js";
+} from "../../chunks/chunk-SK3TLNUP.js";
 import {
   ConfigService,
   configService
-} from "../../chunks/chunk-A6KWUEA6.js";
+} from "../../chunks/chunk-MKB2J6AD.js";
 import {
   bundleFile,
   createRuntimeServer,
@@ -110,18 +106,14 @@ 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-S2HXJTAF.js";
+import "../../chunks/chunk-IBR2F4IL.js";
 import {
-  extractInteractiveStyleMappings,
-  generateAllInteractiveCSS,
   generateElementClassName,
-  hasInteractiveStyleMappings,
   isItemDraftForLocale,
   isVoidElement
-} from "../../chunks/chunk-NV25WXCA.js";
+} from "../../chunks/chunk-IGVQF5GY.js";
 import {
-  DEFAULT_BREAKPOINTS,
   isI18nValue,
   resolveI18nValue
 } from "../../chunks/chunk-PGH3ATYI.js";
@@ -133,603 +125,189 @@ import {
   SERVER_PORT,
   SERVE_PORT,
   init_constants
-} from "../../chunks/chunk-KULPBDC7.js";
+} from "../../chunks/chunk-LBWIHPN7.js";
 import "../../chunks/chunk-KSBZ2L7C.js";
 
-// build-astro.ts
-import { existsSync, readdirSync, mkdirSync, rmSync, statSync, copyFileSync } from "fs";
-import { writeFile as writeFile2, readFile } from "fs/promises";
+// lib/server/webflow/buildWebflow.ts
+import { existsSync, readdirSync } from "fs";
 import { join } from "path";
-import { createHash } from "crypto";
 
-// lib/server/astro/tailwindMapper.ts
+// 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 isStyleMapping(value) {
   return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
 }
-function hasTemplateExpression(value) {
-  return /\{\{.+?\}\}/.test(value);
-}
 function isResponsiveStyle(style) {
   return "base" in style || "tablet" in style || "mobile" in style;
 }
-var exactMatches = {
-  display: {
-    flex: "flex",
-    grid: "grid",
-    block: "block",
-    none: "hidden",
-    inline: "inline",
-    "inline-block": "inline-block",
-    "inline-flex": "inline-flex",
-    "inline-grid": "inline-grid"
-  },
-  flexDirection: {
-    column: "flex-col",
-    row: "flex-row",
-    "column-reverse": "flex-col-reverse",
-    "row-reverse": "flex-row-reverse"
-  },
-  justifyContent: {
-    center: "justify-center",
-    "flex-start": "justify-start",
-    "flex-end": "justify-end",
-    "space-between": "justify-between",
-    "space-around": "justify-around",
-    "space-evenly": "justify-evenly",
-    // camelCase aliases (component data uses camelCase)
-    spaceBetween: "justify-between",
-    spaceAround: "justify-around",
-    spaceEvenly: "justify-evenly",
-    flexStart: "justify-start",
-    flexEnd: "justify-end"
-  },
-  alignItems: {
-    center: "items-center",
-    "flex-start": "items-start",
-    "flex-end": "items-end",
-    stretch: "items-stretch",
-    baseline: "items-baseline",
-    // camelCase aliases
-    flexStart: "items-start",
-    flexEnd: "items-end"
-  },
-  alignContent: {
-    center: "content-center",
-    "flex-start": "content-start",
-    "flex-end": "content-end",
-    "space-between": "content-between",
-    "space-around": "content-around",
-    stretch: "content-stretch"
-  },
-  alignSelf: {
-    auto: "self-auto",
-    center: "self-center",
-    "flex-start": "self-start",
-    "flex-end": "self-end",
-    stretch: "self-stretch"
-  },
-  position: {
-    relative: "relative",
-    absolute: "absolute",
-    fixed: "fixed",
-    sticky: "sticky",
-    static: "static"
-  },
-  overflow: {
-    hidden: "overflow-hidden",
-    auto: "overflow-auto",
-    scroll: "overflow-scroll",
-    visible: "overflow-visible"
-  },
-  overflowX: {
-    hidden: "overflow-x-hidden",
-    auto: "overflow-x-auto",
-    scroll: "overflow-x-scroll",
-    visible: "overflow-x-visible"
-  },
-  overflowY: {
-    hidden: "overflow-y-hidden",
-    auto: "overflow-y-auto",
-    scroll: "overflow-y-scroll",
-    visible: "overflow-y-visible"
-  },
-  cursor: {
-    pointer: "cursor-pointer",
-    default: "cursor-default",
-    "not-allowed": "cursor-not-allowed",
-    grab: "cursor-grab",
-    grabbing: "cursor-grabbing",
-    text: "cursor-text",
-    move: "cursor-move",
-    wait: "cursor-wait"
-  },
-  textAlign: {
-    center: "text-center",
-    left: "text-left",
-    right: "text-right",
-    justify: "text-justify"
-  },
-  textDecoration: {
-    none: "no-underline",
-    underline: "underline",
-    "line-through": "line-through",
-    overline: "overline"
-  },
-  textTransform: {
-    uppercase: "uppercase",
-    lowercase: "lowercase",
-    capitalize: "capitalize",
-    none: "normal-case"
-  },
-  objectFit: {
-    cover: "object-cover",
-    contain: "object-contain",
-    fill: "object-fill",
-    none: "object-none",
-    "scale-down": "object-scale-down"
-  },
-  objectPosition: {
-    center: "object-center",
-    top: "object-top",
-    bottom: "object-bottom",
-    left: "object-left",
-    right: "object-right"
-  },
-  flexWrap: {
-    wrap: "flex-wrap",
-    nowrap: "flex-nowrap",
-    "wrap-reverse": "flex-wrap-reverse"
-  },
-  pointerEvents: {
-    none: "pointer-events-none",
-    auto: "pointer-events-auto"
-  },
-  userSelect: {
-    none: "select-none",
-    auto: "select-auto",
-    text: "select-text",
-    all: "select-all"
-  },
-  visibility: {
-    hidden: "invisible",
-    visible: "visible"
-  },
-  whiteSpace: {
-    normal: "whitespace-normal",
-    nowrap: "whitespace-nowrap",
-    pre: "whitespace-pre",
-    "pre-wrap": "whitespace-pre-wrap",
-    "pre-line": "whitespace-pre-line"
-  },
-  wordBreak: {
-    "break-all": "break-all",
-    "break-word": "break-words",
-    normal: "break-normal"
-  },
-  listStyleType: {
-    none: "list-none",
-    disc: "list-disc",
-    decimal: "list-decimal"
-  },
-  listStylePosition: {
-    inside: "list-inside",
-    outside: "list-outside"
-  },
-  boxSizing: {
-    "border-box": "box-border",
-    "content-box": "box-content"
-  },
-  gridAutoFlow: {
-    row: "grid-flow-row",
-    column: "grid-flow-col",
-    dense: "grid-flow-dense",
-    "row dense": "grid-flow-row-dense",
-    "column dense": "grid-flow-col-dense"
-  }
-};
-var singleValueMatches = {
-  // width/height 100%
-  "width:100%": "w-full",
-  "height:100%": "h-full",
-  "width:100vw": "w-screen",
-  "height:100vh": "h-screen",
-  "width:auto": "w-auto",
-  "height:auto": "h-auto",
-  "width:fit-content": "w-fit",
-  "height:fit-content": "h-fit",
-  "width:min-content": "w-min",
-  "height:min-content": "h-min",
-  "width:max-content": "w-max",
-  "height:max-content": "h-max",
-  "maxWidth:100%": "max-w-full",
-  "maxWidth:none": "max-w-none",
-  "maxHeight:100%": "max-h-full",
-  "maxHeight:none": "max-h-none",
-  "minWidth:0": "min-w-0",
-  "minHeight:0": "min-h-0",
-  "margin:auto": "m-auto",
-  "margin:0 auto": "mx-auto",
-  "marginLeft:auto": "ml-auto",
-  "marginRight:auto": "mr-auto",
-  "marginInline:auto": "mx-auto",
-  "borderRadius:50%": "rounded-full",
-  "borderRadius:9999px": "rounded-full",
-  "borderRadius:0": "rounded-none",
-  "flex:1": "flex-1",
-  "flex:none": "flex-none",
-  "flex:auto": "flex-auto",
-  "flexGrow:0": "grow-0",
-  "flexGrow:1": "grow",
-  "flexShrink:0": "shrink-0",
-  "flexShrink:1": "shrink",
-  "opacity:0": "opacity-0",
-  "opacity:1": "opacity-100",
-  "zIndex:0": "z-0",
-  "zIndex:10": "z-10",
-  "zIndex:20": "z-20",
-  "zIndex:30": "z-30",
-  "zIndex:40": "z-40",
-  "zIndex:50": "z-50",
-  "inset:0": "inset-0",
-  "top:0": "top-0",
-  "right:0": "right-0",
-  "bottom:0": "bottom-0",
-  "left:0": "left-0"
-};
-var arbitraryPrefixMap = {
-  // Spacing
-  padding: "p",
-  paddingTop: "pt",
-  paddingRight: "pr",
-  paddingBottom: "pb",
-  paddingLeft: "pl",
-  paddingInline: "px",
-  paddingBlock: "py",
-  margin: "m",
-  marginTop: "mt",
-  marginRight: "mr",
-  marginBottom: "mb",
-  marginLeft: "ml",
-  marginInline: "mx",
-  marginBlock: "my",
-  gap: "gap",
-  rowGap: "gap-y",
-  columnGap: "gap-x",
-  // Sizing
-  width: "w",
-  height: "h",
-  maxWidth: "max-w",
-  maxHeight: "max-h",
-  minWidth: "min-w",
-  minHeight: "min-h",
-  // Typography
-  fontSize: "text",
-  fontWeight: "font",
-  fontFamily: "font",
-  lineHeight: "leading",
-  letterSpacing: "tracking",
-  // Borders
-  borderRadius: "rounded",
-  borderTopLeftRadius: "rounded-tl",
-  borderTopRightRadius: "rounded-tr",
-  borderBottomLeftRadius: "rounded-bl",
-  borderBottomRightRadius: "rounded-br",
-  border: "border",
-  borderTop: "border-t",
-  borderRight: "border-r",
-  borderBottom: "border-b",
-  borderLeft: "border-l",
-  borderColor: "border",
-  // Colors
-  color: "text",
-  backgroundColor: "bg",
-  background: "bg",
-  backgroundImage: "bg",
-  // Effects
-  opacity: "opacity",
-  boxShadow: "shadow",
-  textShadow: "[text-shadow]",
-  filter: "[filter]",
-  backdropFilter: "backdrop",
-  transform: "[transform]",
-  transformOrigin: "origin",
-  transition: "transition",
-  mixBlendMode: "mix-blend",
-  clipPath: "[clip-path]",
-  // Positioning
-  top: "top",
-  right: "right",
-  bottom: "bottom",
-  left: "left",
-  inset: "inset",
-  zIndex: "z",
-  // Grid
-  gridTemplateColumns: "grid-cols",
-  gridTemplateRows: "grid-rows",
-  gridColumn: "col",
-  gridRow: "row",
-  gridAutoRows: "auto-rows",
-  gridAutoColumns: "auto-cols",
-  // Flexbox extras
-  flexGrow: "grow",
-  flexShrink: "shrink",
-  flexBasis: "basis",
-  order: "order",
-  flex: "flex",
-  // Aspect ratio
-  aspectRatio: "aspect",
-  // Outline
-  outline: "outline",
-  outlineWidth: "outline",
-  outlineOffset: "outline-offset",
-  outlineColor: "outline",
-  // Other
-  accentColor: "accent",
-  textIndent: "[text-indent]",
-  verticalAlign: "align",
-  overflowWrap: "[overflow-wrap]",
-  scrollBehavior: "scroll",
-  resize: "resize"
-};
-function propertyToTailwind(property, value) {
-  const strValue = String(value);
-  if (strValue === "") return null;
-  if (hasTemplateExpression(strValue)) return null;
-  const singleKey = `${property}:${strValue}`;
-  if (singleValueMatches[singleKey]) {
-    return singleValueMatches[singleKey];
-  }
-  if (exactMatches[property]?.[strValue]) {
-    return exactMatches[property][strValue];
-  }
-  if (property === "color" || property === "backgroundColor" || property === "borderColor") {
-    const prefix = property === "color" ? "text" : property === "backgroundColor" ? "bg" : "border";
-    if (strValue.includes("var(")) {
-      return `${prefix}-[${strValue}]`;
-    }
-    if (!strValue.match(/^[#\d]/) && !strValue.includes("rgb") && !strValue.includes("hsl")) {
-      return `${prefix}-[var(--${strValue})]`;
-    }
-  }
-  const twPrefix = arbitraryPrefixMap[property];
-  if (!twPrefix) {
-    const cssProp = property.replace(/([A-Z])/g, "-$1").toLowerCase();
-    const sanitized2 = strValue.replace(/\s+/g, "_");
-    return `[${cssProp}:${sanitized2}]`;
-  }
-  if (twPrefix.startsWith("[")) {
-    const sanitized2 = strValue.replace(/\s+/g, "_");
-    return `${twPrefix.slice(0, -1)}:${sanitized2}]`;
-  }
-  const sanitized = strValue.replace(/\s+/g, "_");
-  if (property === "fontFamily" && !sanitized.includes(",") && !sanitized.startsWith("'")) {
-    return `${twPrefix}-['${sanitized}']`;
-  }
-  return `${twPrefix}-[${sanitized}]`;
+function toKebabCase(prop) {
+  return prop.replace(/([A-Z])/g, "-$1").toLowerCase();
 }
-function stylesToTailwind(style) {
-  const classes = [];
-  const dynamicStyles = {};
+function styleObjectToCSS(style) {
+  const css = {};
   for (const [prop, value] of Object.entries(style)) {
     if (isStyleMapping(value)) continue;
-    const strValue = String(value);
-    if (hasTemplateExpression(strValue)) {
-      const cssProp = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
-      dynamicStyles[cssProp] = strValue;
-      continue;
-    }
-    const twClass = propertyToTailwind(prop, value);
-    if (twClass) {
-      classes.push(twClass);
-    }
-  }
-  return { classes, dynamicStyles };
-}
-function responsiveStylesToTailwind(style, breakpoints) {
-  if (!style) return { classes: [], dynamicStyles: {} };
-  const allClasses = [];
-  const allDynamicStyles = {};
-  if (isResponsiveStyle(style)) {
-    const responsive = style;
-    if (responsive.base) {
-      const { classes, dynamicStyles } = stylesToTailwind(responsive.base);
-      allClasses.push(...classes);
-      Object.assign(allDynamicStyles, dynamicStyles);
-    }
-    if (responsive.tablet) {
-      const bpValue = breakpoints.tablet?.breakpoint ?? 1024;
-      const prefix = `max-[${bpValue}px]:`;
-      const { classes, dynamicStyles } = stylesToTailwind(responsive.tablet);
-      allClasses.push(...classes.map((cls) => `${prefix}${cls}`));
-      Object.assign(allDynamicStyles, dynamicStyles);
-    }
-    if (responsive.mobile) {
-      const bpValue = breakpoints.mobile?.breakpoint ?? 540;
-      const prefix = `max-[${bpValue}px]:`;
-      const { classes, dynamicStyles } = stylesToTailwind(responsive.mobile);
-      allClasses.push(...classes.map((cls) => `${prefix}${cls}`));
-      Object.assign(allDynamicStyles, dynamicStyles);
-    }
-    for (const [bpName, bpStyle] of Object.entries(responsive)) {
-      if (bpName === "base" || bpName === "tablet" || bpName === "mobile" || !bpStyle) continue;
-      const bpValue = breakpoints[bpName]?.breakpoint;
-      if (!bpValue) continue;
-      const prefix = `max-[${bpValue}px]:`;
-      const { classes, dynamicStyles } = stylesToTailwind(bpStyle);
-      allClasses.push(...classes.map((cls) => `${prefix}${cls}`));
-      Object.assign(allDynamicStyles, dynamicStyles);
+    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);
     }
-  } else {
-    const { classes, dynamicStyles } = stylesToTailwind(style);
-    allClasses.push(...classes);
-    Object.assign(allDynamicStyles, dynamicStyles);
   }
-  return { classes: allClasses, dynamicStyles: allDynamicStyles };
-}
-
-// lib/server/astro/nodeToAstro.ts
-init_constants();
-function ind(ctx) {
-  return "  ".repeat(ctx.indent);
-}
-function isStyleMapping2(value) {
-  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
-}
-function isLinkMapping(value) {
-  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
-}
-function isHtmlMapping(value) {
-  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
-}
-function isResponsiveStyle2(style) {
-  return "base" in style || "tablet" in style || "mobile" in style;
-}
-function escapeJSX(s) {
-  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escapeTemplateLiteral(s) {
-  return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+  return css;
 }
 function collectStyleMappings(style) {
   if (!style) return [];
   const result = [];
-  if (isResponsiveStyle2(style)) {
-    const responsive = style;
-    for (const [bp, bpStyle] of Object.entries(responsive)) {
-      if (!bpStyle) continue;
-      for (const [prop, value] of Object.entries(bpStyle)) {
-        if (isStyleMapping2(value)) {
-          result.push({ property: prop, mapping: value, breakpoint: bp });
+  if (isResponsiveStyle(style)) {
+    const base = style.base;
+    if (base) {
+      for (const [prop, value] of Object.entries(base)) {
+        if (isStyleMapping(value)) {
+          result.push({ property: prop, mapping: value });
         }
       }
     }
   } else {
     for (const [prop, value] of Object.entries(style)) {
-      if (isStyleMapping2(value)) {
+      if (isStyleMapping(value)) {
         result.push({ property: prop, mapping: value });
       }
     }
   }
   return result;
 }
-function mappingToClassListEntries(mapping, property, breakpointPrefix, ctx) {
-  const entries = [];
-  const values = Object.entries(mapping.values);
-  if (values.length === 0) return entries;
-  const propRef = ctx.isComponentDef ? mapping.prop : mapping.prop;
-  if (values.length === 2) {
-    const [[val1, css1], [val2, css2]] = values;
-    const cls1 = getClassForValue(property, css1, breakpointPrefix);
-    const cls2 = getClassForValue(property, css2, breakpointPrefix);
-    if (cls1 && cls2) {
-      entries.push(`${propRef} === ${JSON.stringify(coerceValue(val1))} ? '${cls1}' : '${cls2}'`);
-    }
-  } else {
-    for (const [val, cssValue] of values) {
-      const cls = getClassForValue(property, cssValue, breakpointPrefix);
-      if (cls) {
-        entries.push(`${propRef} === ${JSON.stringify(coerceValue(val))} && '${cls}'`);
+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 (isResponsiveStyle(style)) {
+      const responsive = style;
+      if (responsive.base) {
+        primaryClass.base = styleObjectToCSS(responsive.base);
       }
-    }
-  }
-  return entries;
-}
-function coerceValue(val) {
-  if (val === "true") return true;
-  if (val === "false") return false;
-  return val;
-}
-function getClassForValue(property, value, breakpointPrefix) {
-  const twClass = propertyToTailwind(property, value);
-  if (!twClass) return null;
-  return breakpointPrefix ? `${breakpointPrefix}${twClass}` : twClass;
-}
-function buildClassAndStyleExpression(style, interactiveStyles, elementClass, ctx) {
-  const result = style ? responsiveStylesToTailwind(style, ctx.breakpoints) : { classes: [], dynamicStyles: {} };
-  const staticClasses = result.classes;
-  const dynamicStyles = result.dynamicStyles;
-  if (elementClass) {
-    staticClasses.unshift(elementClass);
-  }
-  const conditionals = [];
-  const mappings = collectStyleMappings(style);
-  for (const { property, mapping, breakpoint } of mappings) {
-    const bpValue = breakpoint === "tablet" ? ctx.breakpoints.tablet?.breakpoint ?? 1024 : breakpoint === "mobile" ? ctx.breakpoints.mobile?.breakpoint ?? 540 : 0;
-    const prefix = bpValue ? `max-[${bpValue}px]:` : "";
-    const entries = mappingToClassListEntries(mapping, property, prefix, ctx);
-    conditionals.push(...entries);
-  }
-  let styleAttr = "";
-  if (Object.keys(dynamicStyles).length > 0 && ctx.isComponentDef) {
-    const styleParts = [];
-    for (const [cssProp, value] of Object.entries(dynamicStyles)) {
-      const resolved = value.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
-      styleParts.push(`${cssProp}: \${${resolved.includes("${") ? resolved.replace(/\$\{(.+?)\}/g, "$1") : `'${resolved}'`}}`);
-    }
-    const entries = [];
-    for (const [cssProp, value] of Object.entries(dynamicStyles)) {
-      const resolved = value.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
-      entries.push(`${cssProp}: ${resolved}`);
-    }
-    styleAttr = ` style={\`${entries.join("; ")}\`}`;
-  }
-  if (interactiveStyles && interactiveStyles.length > 0 && ctx.isComponentDef && hasInteractiveStyleMappings(interactiveStyles)) {
-    const { mappings: mappings2 } = extractInteractiveStyleMappings(interactiveStyles);
-    if (mappings2.length > 0) {
-      const varParts = [];
-      for (const extracted of mappings2) {
-        const { mapping, variableIndex } = extracted;
-        const varName = `--is-${variableIndex}`;
-        const entries = Object.entries(mapping.values);
-        if (entries.length === 2) {
-          const [[val1, css1], [val2, css2]] = entries;
-          varParts.push(`'${varName}': ${mapping.prop} === ${JSON.stringify(coerceValue(val1))} ? '${css1}' : '${css2}'`);
-        } else {
-          const lookupEntries = entries.filter(([, v]) => v !== "").map(([k, v]) => `${JSON.stringify(coerceValue(k))}: '${v}'`).join(", ");
-          varParts.push(`'${varName}': ({${lookupEntries}})[${mapping.prop}] || ''`);
-        }
+      if (responsive.tablet) {
+        if (!primaryClass.breakpoints) primaryClass.breakpoints = {};
+        primaryClass.breakpoints.Tablet = styleObjectToCSS(responsive.tablet);
       }
-      if (varParts.length > 0) {
-        const existingStyleParts = styleAttr ? styleAttr.replace(/^ style=\{`/, "").replace(/`\}$/, "") : "";
-        const varStyleExpr = varParts.join(", ");
-        if (existingStyleParts) {
-          styleAttr = ` style={\`${existingStyleParts}; \${ Object.entries({${varStyleExpr}}).map(([k,v]) => \`\${k}:\${v}\`).join(';') }\`}`;
-        } else {
-          styleAttr = ` style={Object.entries({${varStyleExpr}}).map(([k,v]) => \`\${k}:\${v}\`).join(';')}`;
+      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 (isResponsiveStyle(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)
+        };
       }
     }
   }
-  let classExpr;
-  if (conditionals.length === 0) {
-    if (staticClasses.length === 0) {
-      classExpr = "";
-    } else {
-      classExpr = ` class="${staticClasses.join(" ")}"`;
-    }
-  } else {
-    const parts = [];
-    if (staticClasses.length > 0) {
-      parts.push(`'${staticClasses.join(" ")}'`);
+  const comboClasses = [];
+  const mappings = collectStyleMappings(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);
     }
-    parts.push(...conditionals);
-    classExpr = ` class:list={[${parts.join(", ")}]}`;
-  }
-  return { classExpr, styleAttr };
-}
-function resolveTemplate(text, ctx) {
-  if (!ctx.isComponentDef) {
-    return text;
-  }
-  const fullMatch = text.match(/^\{\{(.+)\}\}$/);
-  if (fullMatch) {
-    return `{${fullMatch[1].trim()}}`;
   }
-  return text.replace(/\{\{(.+?)\}\}/g, (_, expr) => `{${expr.trim()}}`);
+  return { primaryClass, comboClasses };
 }
-function hasTemplates(text) {
-  return /\{\{.+?\}\}/.test(text);
+function sanitizeClassName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
+
+// lib/server/webflow/nodeToWebflow.ts
 function buildElementClass(ctx, label) {
   return generateElementClassName({
     fileType: ctx.fileType,
@@ -738,621 +316,272 @@ function buildElementClass(ctx, label) {
     path: ctx.elementPath
   });
 }
-function buildAttributesString(attributes, ctx) {
-  if (!attributes) return "";
-  const parts = [];
-  for (const [key, value] of Object.entries(attributes)) {
-    if (typeof value === "boolean") {
-      if (value) parts.push(key);
-    } else {
-      const strVal = String(value);
-      if (hasTemplates(strVal) && ctx.isComponentDef) {
-        const fullMatch = strVal.match(/^\{\{(.+)\}\}$/);
-        if (fullMatch) {
-          parts.push(`${key}={${fullMatch[1].trim()}}`);
-        } else {
-          const resolved = strVal.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
-          parts.push(`${key}={\`${resolved}\`}`);
-        }
-      } else {
-        parts.push(`${key}="${escapeJSX(strVal)}"`);
-      }
-    }
+function resolveTemplate(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 parts.length > 0 ? " " + parts.join(" ") : "";
+  return current;
 }
-function formatPropValue(value) {
-  if (typeof value === "string") return `"${escapeJSX(value)}"`;
-  if (typeof value === "number") return `{${value}}`;
-  if (typeof value === "boolean") return `{${value}}`;
-  if (value === null || value === void 0) return `{undefined}`;
-  return `{${JSON.stringify(value)}}`;
+function hasTemplates(text) {
+  return /\{\{.+?\}\}/.test(text);
 }
-function nodeToAstro(node, ctx) {
-  if (node === null || node === void 0) return "";
+function nodeToWebflow(node, ctx, instanceProps) {
+  if (node === null || node === void 0) return [];
   if (typeof node === "string") {
-    if (hasTemplates(node) && ctx.isComponentDef) {
-      return `${ind(ctx)}${resolveTemplate(node, ctx)}
-`;
-    }
-    return `${ind(ctx)}${escapeJSX(node)}
-`;
+    const text = instanceProps ? resolveTemplate(node, instanceProps) : node;
+    return [{ tag: "span", textContent: text }];
   }
   if (typeof node === "number") {
-    return `${ind(ctx)}${node}
-`;
+    return [{ tag: "span", textContent: String(node) }];
   }
   if (Array.isArray(node)) {
-    let result = "";
+    const results = [];
     for (let i = 0; i < node.length; i++) {
       const child = node[i];
       const savedPath = [...ctx.elementPath];
       ctx.elementPath = [...ctx.elementPath, i];
-      result += nodeToAstro(child, ctx);
+      results.push(...nodeToWebflow(child, ctx, instanceProps));
       ctx.elementPath = savedPath;
     }
-    return result;
+    return results;
   }
   switch (node.type) {
     case NODE_TYPE.NODE:
-      return emitHtmlNode(node, ctx);
+      return [emitHtmlNode(node, ctx, instanceProps)];
     case NODE_TYPE.COMPONENT:
-      return emitComponentInstance(node, ctx);
+      return emitComponentInstance(node, ctx, instanceProps);
     case NODE_TYPE.SLOT:
-      return emitSlotMarker(node, ctx);
+      return emitSlotMarker(node, ctx, instanceProps);
     case NODE_TYPE.EMBED:
-      return emitEmbedNode(node, ctx);
+      return [emitEmbedNode(node, ctx, instanceProps)];
     case NODE_TYPE.LINK:
-      return emitLinkNode(node, ctx);
-    case NODE_TYPE.LOCALE_LIST:
-      return emitFallback(ctx);
+      return [emitLinkNode(node, ctx, instanceProps)];
     case NODE_TYPE.LIST:
     case "cms-list":
-      return emitFallback(ctx);
+    case NODE_TYPE.LOCALE_LIST:
+      return [{ tag: "div", attributes: { "data-meno-type": node.type } }];
     default:
-      return emitFallback(ctx);
+      return [];
   }
 }
-function emitHtmlNode(node, ctx) {
-  let tag = node.tag;
-  const label = node.label;
+function emitHtmlNode(node, ctx, instanceProps) {
+  const tag = hasTemplates(node.tag) && instanceProps ? resolveTemplate(node.tag, instanceProps) : node.tag;
   const style = node.style;
-  let isDynamic = false;
-  let dynamicTagVar = "";
-  if (hasTemplates(tag) && ctx.isComponentDef) {
-    isDynamic = true;
-    dynamicTagVar = `Tag_${ctx.elementPath.join("_")}`;
-    const resolved = tag.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
-    if (!ctx.dynamicTags) ctx.dynamicTags = /* @__PURE__ */ new Map();
-    ctx.dynamicTags.set(dynamicTagVar, resolved);
-    tag = dynamicTagVar;
-  }
-  const ifExpr = emitIfOpen(node, ctx);
-  let elementClass = null;
-  if (node.interactiveStyles && node.interactiveStyles.length > 0 || node.generateElementClass) {
-    elementClass = buildElementClass(ctx, label);
-  }
-  const { classExpr, styleAttr } = buildClassAndStyleExpression(style, node.interactiveStyles, elementClass, ctx);
-  const attrs = buildAttributesString(node.attributes, ctx);
-  const openClose = isDynamic ? dynamicTagVar : tag;
-  if (!isDynamic && isVoidElement(tag)) {
-    return `${ifExpr}${ind(ctx)}<${tag}${classExpr}${styleAttr}${attrs} />
-${emitIfClose(node, ctx)}`;
-  }
-  const children = emitChildren(node.children, ctx);
-  if (!children.trim() && !isDynamic) {
-    return `${ifExpr}${ind(ctx)}<${tag}${classExpr}${styleAttr}${attrs} />
-${emitIfClose(node, ctx)}`;
-  }
-  return `${ifExpr}${ind(ctx)}<${openClose}${classExpr}${styleAttr}${attrs}>
-` + children + `${ind(ctx)}</${openClose}>
-${emitIfClose(node, ctx)}`;
-}
-function emitComponentInstance(node, ctx) {
-  const name = node.component;
-  ctx.imports.add(name);
-  const ifExpr = emitIfOpen(node, ctx);
-  const propParts = [];
-  if (node.props) {
-    for (const [key, value] of Object.entries(node.props)) {
-      if (key === "children") continue;
-      if (typeof value === "string" && hasTemplates(value) && ctx.isComponentDef) {
-        const fullMatch = value.match(/^\{\{(.+)\}\}$/);
-        if (fullMatch) {
-          propParts.push(`${key}={${fullMatch[1].trim()}}`);
-        } else {
-          const resolved = value.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
-          propParts.push(`${key}={\`${resolved}\`}`);
-        }
-      } else {
-        propParts.push(`${key}=${formatPropValue(value)}`);
+  const interactiveStyles = node.interactiveStyles;
+  const needsClass = style || interactiveStyles && interactiveStyles.length > 0 || node.generateElementClass;
+  let className;
+  let comboClassNames;
+  if (needsClass) {
+    const elementClass = buildElementClass(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);
       }
     }
   }
-  if (node.style) {
-    const { classes: instanceClasses } = responsiveStylesToTailwind(node.style, ctx.breakpoints);
-    if (instanceClasses.length > 0) {
-      propParts.push(`class="${instanceClasses.join(" ")}"`);
-    }
-  }
-  const propsStr = propParts.length > 0 ? " " + propParts.join(" ") : "";
-  const children = emitChildren(node.children, ctx);
-  if (!children.trim()) {
-    return `${ifExpr}${ind(ctx)}<${name}${propsStr} />
-${emitIfClose(node, ctx)}`;
-  }
-  return `${ifExpr}${ind(ctx)}<${name}${propsStr}>
-` + children + `${ind(ctx)}</${name}>
-${emitIfClose(node, ctx)}`;
-}
-function emitSlotMarker(node, ctx) {
-  if (node.default) {
-    const defaultContent = emitChildren(node.default, ctx);
-    if (defaultContent.trim()) {
-      return `${ind(ctx)}<slot>
-` + defaultContent + `${ind(ctx)}</slot>
-`;
-    }
-  }
-  return `${ind(ctx)}<slot />
-`;
-}
-function emitEmbedNode(node, ctx) {
-  const ifExpr = emitIfOpen(node, ctx);
-  const style = node.style;
-  let elementClass = null;
-  if (node.interactiveStyles && node.interactiveStyles.length > 0 || node.generateElementClass) {
-    elementClass = buildElementClass(ctx, node.label);
-  }
-  const { classExpr, styleAttr } = buildClassAndStyleExpression(style, node.interactiveStyles, elementClass, ctx);
-  const attrs = buildAttributesString(node.attributes, ctx);
-  if (isHtmlMapping(node.html)) {
-    if (ctx.isComponentDef) {
-      const propRef = node.html.prop;
-      return `${ifExpr}${ind(ctx)}<div${classExpr.replace('"', '"oem ') || ' class="oem"'}${attrs}>
-${ind(ctx)}  <Fragment set:html={${propRef}} />
-${ind(ctx)}</div>
-${emitIfClose(node, ctx)}`;
+  const attributes = {};
+  if (node.attributes) {
+    for (const [key, value] of Object.entries(node.attributes)) {
+      if (instanceProps && typeof value === "string" && hasTemplates(value)) {
+        attributes[key] = resolveTemplate(value, instanceProps);
+      } else {
+        attributes[key] = value;
+      }
     }
   }
-  const htmlStr = typeof node.html === "string" ? node.html : "";
-  const escapedHtml = escapeTemplateLiteral(htmlStr);
-  let finalClassExpr = classExpr;
-  if (!classExpr.includes("oem")) {
-    if (classExpr) {
-      finalClassExpr = classExpr.replace(/class="/, 'class="oem ').replace(/class:list={\['/, "class:list={['oem ");
+  let children;
+  let textContent;
+  if (!isVoidElement(tag) && node.children) {
+    if (typeof node.children === "string") {
+      textContent = instanceProps ? resolveTemplate(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 ? resolveTemplate(text, instanceProps) : text;
     } else {
-      finalClassExpr = ' class="oem"';
+      const innerCtx = { ...ctx, elementPath: [...ctx.elementPath] };
+      children = convertChildren(node.children, innerCtx, instanceProps);
+      if (children.length === 0) children = void 0;
     }
   }
-  return `${ifExpr}${ind(ctx)}<div${finalClassExpr}${attrs}>
-${ind(ctx)}  <Fragment set:html={\`${escapedHtml}\`} />
-${ind(ctx)}</div>
-${emitIfClose(node, ctx)}`;
-}
-function emitLinkNode(node, ctx) {
-  const ifExpr = emitIfOpen(node, ctx);
-  const style = node.style;
-  let elementClass = null;
-  if (node.interactiveStyles && node.interactiveStyles.length > 0 || node.generateElementClass) {
-    elementClass = buildElementClass(ctx, node.label);
-  }
-  const { classExpr, styleAttr } = buildClassAndStyleExpression(style, node.interactiveStyles, elementClass, ctx);
-  let finalClassExpr = classExpr;
-  if (!classExpr.includes("olink")) {
-    if (classExpr) {
-      finalClassExpr = classExpr.replace(/class="/, 'class="olink ').replace(/class:list={\['/, "class:list={['olink ");
-    } else {
-      finalClassExpr = ' class="olink"';
+  let 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 emitComponentInstance(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;
     }
   }
-  let hrefAttr;
-  if (isLinkMapping(node.href)) {
-    if (ctx.isComponentDef) {
-      const propRef = node.href.prop;
-      hrefAttr = ` href={${propRef}.href}`;
-    } else {
-      hrefAttr = ' href="#"';
-    }
-  } else {
-    const href = typeof node.href === "string" ? node.href : "#";
-    if (hasTemplates(href) && ctx.isComponentDef) {
-      const fullMatch = href.match(/^\{\{(.+)\}\}$/);
-      if (fullMatch) {
-        hrefAttr = ` href={${fullMatch[1].trim()}}`;
+  if (node.props) {
+    for (const [key, value] of Object.entries(node.props)) {
+      if (key === "children") continue;
+      if (typeof value === "string" && hasTemplates(value) && parentProps) {
+        resolvedProps[key] = resolveTemplate(value, parentProps);
       } else {
-        const resolved = href.replace(/\{\{(.+?)\}\}/g, (_, expr) => `\${${expr.trim()}}`);
-        hrefAttr = ` href={\`${resolved}\`}`;
+        resolvedProps[key] = value;
       }
-    } else {
-      hrefAttr = ` href="${escapeJSX(href)}"`;
     }
   }
-  const attrs = buildAttributesString(node.attributes, ctx);
-  const children = emitChildren(node.children, ctx);
-  if (!children.trim()) {
-    return `${ifExpr}${ind(ctx)}<a${hrefAttr}${finalClassExpr}${styleAttr}${attrs} />
-${emitIfClose(node, ctx)}`;
-  }
-  return `${ifExpr}${ind(ctx)}<a${hrefAttr}${finalClassExpr}${styleAttr}${attrs}>
-` + children + `${ind(ctx)}</a>
-${emitIfClose(node, ctx)}`;
-}
-function emitFallback(ctx) {
-  const pathKey = ctx.elementPath.join(".");
-  const ssrHtml = ctx.ssrFallbacks.get(pathKey);
-  if (ssrHtml) {
-    const escaped = escapeTemplateLiteral(ssrHtml);
-    return `${ind(ctx)}<Fragment set:html={\`${escaped}\`} />
-`;
-  }
-  return `${ind(ctx)}{/* Complex node - SSR fallback not available */}
-`;
-}
-function emitIfOpen(node, ctx) {
-  const ifValue = node.if;
-  if (ifValue === void 0 || ifValue === true) return "";
-  if (typeof ifValue === "boolean") {
-    return ifValue ? "" : `${ind(ctx)}{/* hidden */}
-`;
-  }
-  if (typeof ifValue === "object" && ifValue._mapping && ctx.isComponentDef) {
-    return `${ind(ctx)}{${ifValue.prop} && (
-`;
-  }
-  if (typeof ifValue === "string" && ctx.isComponentDef) {
-    const fullMatch = ifValue.match(/^\{\{(.+)\}\}$/);
-    const expr = fullMatch ? fullMatch[1].trim() : ifValue.replace(/\{\{(.+?)\}\}/g, "$1");
-    return `${ind(ctx)}{${expr} && (
-`;
-  }
-  return "";
-}
-function emitIfClose(node, ctx) {
-  const ifValue = node.if;
-  if (ifValue === void 0 || ifValue === true) return "";
-  if (typeof ifValue === "boolean") return "";
-  if (typeof ifValue === "object" && ifValue._mapping && ctx.isComponentDef || typeof ifValue === "string" && ctx.isComponentDef) {
-    return `${ind(ctx)})}
-`;
-  }
-  return "";
-}
-function emitChildren(children, ctx) {
-  if (!children) return "";
-  const innerCtx = { ...ctx, indent: ctx.indent + 1, elementPath: [...ctx.elementPath] };
-  if (typeof children === "string") {
-    return nodeToAstro(children, innerCtx);
-  }
-  if (Array.isArray(children)) {
-    return nodeToAstro(children, innerCtx);
-  }
-  return nodeToAstro(children, innerCtx);
-}
-
-// lib/server/astro/componentEmitter.ts
-function propDefToTSType(def) {
-  switch (def.type) {
-    case "string":
-    case "rich-text":
-    case "file":
-      return "string";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "select":
-      if ("options" in def && def.options && def.options.length > 0) {
-        return def.options.map((o) => `'${o}'`).join(" | ");
-      }
-      return "string";
-    case "link":
-      return "{ href: string; target?: string }";
-    case "list":
-      return "any[]";
-    default:
-      return "any";
-  }
-}
-function formatDefault(def) {
-  if (!("default" in def) || def.default === void 0) return null;
-  const val = def.default;
-  if (typeof val === "string") return JSON.stringify(val);
-  if (typeof val === "number" || typeof val === "boolean") return String(val);
-  if (typeof val === "object" && val !== null && "_i18n" in val) {
-    for (const [key, v] of Object.entries(val)) {
-      if (key !== "_i18n" && typeof v === "string") return JSON.stringify(v);
-    }
-    return null;
-  }
-  if (typeof val === "object" && val !== null && "href" in val) {
-    return JSON.stringify(val);
-  }
-  if (Array.isArray(val)) {
-    return JSON.stringify(val);
-  }
-  return JSON.stringify(val);
-}
-function emitAstroComponent(name, def, allComponents, breakpoints = DEFAULT_BREAKPOINTS) {
-  const comp = def.component;
-  const propDefs = comp.interface || {};
-  const structure = comp.structure;
-  if (!structure) {
-    return buildNoStructureComponent(name, comp);
-  }
-  const ctx = {
-    imports: /* @__PURE__ */ new Set(),
-    isComponentDef: true,
-    componentProps: propDefs,
-    globalComponents: allComponents,
-    indent: 0,
-    ssrFallbacks: /* @__PURE__ */ new Map(),
-    elementPath: [0],
+  const body = structured?.structure || compDef.node;
+  if (!body) return [];
+  const compCtx = {
+    ...ctx,
     fileType: "component",
-    fileName: name,
-    breakpoints
+    fileName: node.component,
+    elementPath: [0],
+    slotChildren: node.children
   };
-  const templateBody = nodeToAstro(structure, ctx);
-  const frontmatter = buildFrontmatter(name, propDefs, ctx.imports, ctx.dynamicTags);
-  const styleSection = comp.css ? `
-<style>
-${comp.css}
-</style>
-` : "";
-  const scriptSection = comp.javascript ? `
-<script>
-${comp.javascript}
-</script>
-` : "";
-  return `---
-${frontmatter}---
-${templateBody}${styleSection}${scriptSection}`;
+  return nodeToWebflow(body, compCtx, resolvedProps);
 }
-function buildFrontmatter(componentName, propDefs, imports, dynamicTags) {
-  const lines = [];
-  for (const imp of Array.from(imports).sort()) {
-    lines.push(`import ${imp} from './${imp}.astro';`);
-  }
-  if (lines.length > 0) lines.push("");
-  const propEntries = Object.entries(propDefs);
-  if (propEntries.length > 0) {
-    lines.push("interface Props {");
-    for (const [propName, propDef] of propEntries) {
-      if (propName === "children") continue;
-      const tsType = propDefToTSType(propDef);
-      const optional = "default" in propDef && propDef.default !== void 0;
-      lines.push(`  ${propName}${optional ? "?" : ""}: ${tsType};`);
-    }
-    lines.push("}");
-    lines.push("");
-    const destructParts = [];
-    for (const [propName, propDef] of propEntries) {
-      if (propName === "children") continue;
-      const defaultVal = formatDefault(propDef);
-      if (defaultVal !== null) {
-        destructParts.push(`${propName} = ${defaultVal}`);
-      } else {
-        destructParts.push(propName);
-      }
-    }
-    if (destructParts.length > 0) {
-      if (destructParts.length <= 3 && destructParts.join(", ").length < 80) {
-        lines.push(`const { ${destructParts.join(", ")} } = Astro.props;`);
-      } else {
-        lines.push("const {");
-        for (const part of destructParts) {
-          lines.push(`  ${part},`);
-        }
-        lines.push("} = Astro.props;");
-      }
-    }
+function emitSlotMarker(node, ctx, instanceProps) {
+  if (ctx.slotChildren) {
+    const parentCtx = {
+      ...ctx,
+      slotChildren: void 0
+      // prevent infinite slot nesting
+    };
+    return convertChildren(ctx.slotChildren, parentCtx, instanceProps);
   }
-  if (dynamicTags && dynamicTags.size > 0) {
-    lines.push("");
-    for (const [varName, templateExpr] of dynamicTags) {
-      lines.push(`const ${varName} = \`${templateExpr}\`;`);
-    }
+  if (node.default) {
+    return convertChildren(node.default, ctx, instanceProps);
   }
-  if (lines.length > 0) lines.push("");
-  return lines.join("\n");
-}
-function buildNoStructureComponent(name, comp) {
-  let content = "---\n---\n<slot />\n";
-  if (comp.css) content += `
-<style>
-${comp.css}
-</style>
-`;
-  if (comp.javascript) content += `
-<script>
-${comp.javascript}
-</script>
-`;
-  return content;
-}
-
-// lib/server/astro/pageEmitter.ts
-function escapeTemplateLiteral2(s) {
-  return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+  return [];
 }
-function escapeJSX2(s) {
-  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
-}
-function componentImportPath(fileDepth, componentName) {
-  const ups = "../".repeat(fileDepth + 1);
-  return `${ups}components/${componentName}.astro`;
-}
-function emitAstroPage(options) {
-  const {
-    pageData,
-    globalComponents,
-    title,
-    meta,
-    locale,
-    theme,
-    fontPreloads,
-    libraryTags,
-    scriptPaths,
-    layoutImportPath: layoutImportPath2,
-    fileDepth,
-    ssrFallbacks,
-    pageName,
-    breakpoints: breakpointsOpt
-  } = options;
-  const breakpoints = breakpointsOpt ?? DEFAULT_BREAKPOINTS;
-  const root = pageData.root;
-  if (!root) {
-    return buildEmptyPage(layoutImportPath2, title, meta, locale, theme, fontPreloads, libraryTags, scriptPaths);
+function emitEmbedNode(node, ctx, instanceProps) {
+  const style = node.style;
+  const interactiveStyles = node.interactiveStyles;
+  let className;
+  if (style || interactiveStyles && interactiveStyles.length > 0) {
+    const elementClass = buildElementClass(ctx, node.label);
+    const { primaryClass } = mapStylesToWebflow(
+      elementClass,
+      style,
+      interactiveStyles,
+      ctx.breakpoints
+    );
+    className = primaryClass.name;
+    ctx.styleClasses.set(primaryClass.name, primaryClass);
   }
-  const ctx = {
-    imports: /* @__PURE__ */ new Set(),
-    isComponentDef: false,
-    componentProps: {},
-    globalComponents,
-    indent: 1,
-    // inside BaseLayout
-    ssrFallbacks,
-    elementPath: [0],
-    fileType: "page",
-    fileName: pageName,
-    breakpoints
+  const htmlStr = typeof node.html === "string" ? node.html : "";
+  const element = {
+    tag: "div",
+    rawHtml: htmlStr
   };
-  const templateBody = nodeToAstro(root, ctx);
-  const importLines = [];
-  importLines.push(`import BaseLayout from '${layoutImportPath2}';`);
-  const componentImports = Array.from(ctx.imports).sort();
-  for (const comp of componentImports) {
-    const path = componentImportPath(fileDepth, comp);
-    importLines.push(`import ${comp} from '${path}';`);
-  }
-  const scriptsArrayLiteral = scriptPaths.length > 0 ? `[${scriptPaths.map((s) => `"${s}"`).join(", ")}]` : "[]";
-  const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral2(libraryTags.headCSS || "")}\`, headJS: \`${escapeTemplateLiteral2(libraryTags.headJS || "")}\`, bodyEndJS: \`${escapeTemplateLiteral2(libraryTags.bodyEndJS || "")}\` }`;
-  const escapedMeta = escapeTemplateLiteral2(meta);
-  const escapedFontPreloads = escapeTemplateLiteral2(fontPreloads);
-  return `---
-${importLines.join("\n")}
----
-<BaseLayout
-  title="${escapeJSX2(title)}"
-  meta={\`${escapedMeta}\`}
-  scripts={${scriptsArrayLiteral}}
-  locale="${locale}"
-  theme="${theme}"
-  fontPreloads={\`${escapedFontPreloads}\`}
-  libraryTags={${libraryTagsLiteral}}
->
-${templateBody}</BaseLayout>
-`;
-}
-function buildEmptyPage(layoutImport, title, meta, locale, theme, fontPreloads, libraryTags, scriptPaths) {
-  const escapedMeta = escapeTemplateLiteral2(meta);
-  const escapedFontPreloads = escapeTemplateLiteral2(fontPreloads);
-  const scriptsArrayLiteral = scriptPaths.length > 0 ? `[${scriptPaths.map((s) => `"${s}"`).join(", ")}]` : "[]";
-  const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral2(libraryTags.headCSS || "")}\`, headJS: \`${escapeTemplateLiteral2(libraryTags.headJS || "")}\`, bodyEndJS: \`${escapeTemplateLiteral2(libraryTags.bodyEndJS || "")}\` }`;
-  return `---
-import BaseLayout from '${layoutImport}';
----
-<BaseLayout
-  title="${escapeJSX2(title)}"
-  meta={\`${escapedMeta}\`}
-  scripts={${scriptsArrayLiteral}}
-  locale="${locale}"
-  theme="${theme}"
-  fontPreloads={\`${escapedFontPreloads}\`}
-  libraryTags={${libraryTagsLiteral}}
->
-</BaseLayout>
-`;
-}
-
-// lib/server/astro/cssCollector.ts
-function isStyleMapping3(value) {
-  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
+  if (className) element.className = className;
+  return element;
 }
-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 emitLinkNode(node, ctx, instanceProps) {
+  const style = node.style;
+  const interactiveStyles = node.interactiveStyles;
+  let className;
+  if (style || interactiveStyles && interactiveStyles.length > 0) {
+    const elementClass = buildElementClass(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 && hasTemplates(node.href) ? resolveTemplate(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);
   }
-}
-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);
-    }
+  if (Array.isArray(children)) {
+    return nodeToWebflow(children, ctx, instanceProps);
   }
-  return classes;
+  return nodeToWebflow(children, ctx, instanceProps);
 }
 
-// build-astro.ts
-function hashContent2(content) {
-  return createHash("sha256").update(content).digest("hex").slice(0, 8);
-}
-function copyDirectory(src, dest) {
-  if (!existsSync(src)) return;
-  if (!existsSync(dest)) mkdirSync(dest, { recursive: true });
-  const files = readdirSync(src);
-  for (const file of files) {
-    const srcPath = join(src, file);
-    const destPath = join(dest, file);
-    const stat = statSync(srcPath);
-    if (stat.isDirectory()) copyDirectory(srcPath, destPath);
-    else copyFileSync(srcPath, destPath);
+// lib/server/webflow/buildWebflow.ts
+function scanJSONFiles(dir, prefix = "") {
+  const results = [];
+  if (!existsSync(dir)) return results;
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".json")) {
+      results.push(prefix ? `${prefix}/${entry.name}` : entry.name);
+    } else if (entry.isDirectory()) {
+      results.push(...scanJSONFiles(join(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name));
+    }
   }
+  return results;
 }
 function isCMSPage(pageData) {
   return pageData.meta?.source === "cms" && !!pageData.meta?.cms;
@@ -1364,132 +593,81 @@ function buildCMSItemPath(urlPattern, item, slugField, locale, i18nConfig) {
   }
   return urlPattern.replace("{{slug}}", String(slug));
 }
-function scanJSONFiles(dir, prefix = "") {
+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 = join(projectRoot, dir);
+    if (!existsSync(fullDir)) continue;
+    const files = scanJSONFiles(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 (!existsSync(dir)) return results;
   const entries = readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    if (entry.isFile() && entry.name.endsWith(".json")) {
-      results.push(prefix ? `${prefix}/${entry.name}` : entry.name);
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isFile()) {
+      results.push(relativePath);
     } else if (entry.isDirectory()) {
-      results.push(...scanJSONFiles(join(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name));
+      results.push(...scanAllFiles(join(dir, entry.name), relativePath));
     }
   }
   return results;
 }
-function layoutImportPath(fileDepth) {
-  const ups = "../".repeat(fileDepth + 1);
-  return `${ups}layouts/BaseLayout.astro`;
-}
-function escapeTemplateLiteral3(s) {
-  return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
-}
-function cmsFieldToZod(field) {
-  switch (field.type) {
-    case "string":
-    case "text":
-    case "rich-text":
-      return "z.string()";
-    case "number":
-      return "z.number()";
-    case "boolean":
-      return "z.boolean()";
-    case "date":
-      return "z.coerce.date()";
-    case "select":
-      if (field.options && field.options.length > 0) {
-        const opts = field.options.map((o) => `'${o.replace(/'/g, "\\'")}'`).join(", ");
-        return `z.enum([${opts}])`;
-      }
-      return "z.string()";
-    case "image":
-    case "file":
-      return "z.string()";
-    case "reference":
-      return "z.string()";
-    default:
-      return "z.string()";
+function 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;
 }
-function buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths) {
-  const escapedMeta = escapeTemplateLiteral3(result.meta);
-  const escapedHTML = escapeTemplateLiteral3(result.html);
-  const escapedFontPreloads = escapeTemplateLiteral3(fontPreloads);
-  const scriptsArrayLiteral = scriptPaths.length > 0 ? `[${scriptPaths.map((s) => `"${s}"`).join(", ")}]` : "[]";
-  const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral3(libraryTags.headCSS || "")}\`, headJS: \`${escapeTemplateLiteral3(libraryTags.headJS || "")}\`, bodyEndJS: \`${escapeTemplateLiteral3(libraryTags.bodyEndJS || "")}\` }`;
-  return `---
-import BaseLayout from '${importPath}';
----
-<BaseLayout
-  title="${result.title.replace(/"/g, "&quot;")}"
-  meta={\`${escapedMeta}\`}
-  scripts={${scriptsArrayLiteral}}
-  locale="${result.locale}"
-  theme="${defaultTheme}"
-  fontPreloads={\`${escapedFontPreloads}\`}
-  libraryTags={${libraryTagsLiteral}}
->
-  <Fragment set:html={\`<div id="root">${escapedHTML}</div>\`} />
-</BaseLayout>
-`;
-}
-async function buildAstroProject(projectRoot, outputDir) {
-  const startTime = Date.now();
-  console.log("\u{1F3D7}\uFE0F  Building Astro export...\n");
+async function buildWebflowPayload(projectRoot) {
   configService.reset();
   const projectConfig = await loadProjectConfig();
   const siteUrl = projectConfig.siteUrl?.replace(/\/$/, "") || "";
   const i18nConfig = await loadI18nConfig();
-  console.log(`\u{1F310} Locales: ${i18nConfig.locales.map((l) => l.code).join(", ")} (default: ${i18nConfig.defaultLocale})
-`);
   await migrateTemplatesDirectory();
-  const { components, warnings, errors: compErrors } = await loadComponentDirectory(projectPaths.components());
+  const { components } = await loadComponentDirectory(projectPaths.components());
   const globalComponents = {};
   components.forEach((value, key) => {
     globalComponents[key] = value;
   });
-  for (const w of warnings) console.warn(`  Warning: ${w}`);
-  for (const e of compErrors) console.error(`  Error: ${e}`);
-  console.log(`Loaded ${components.size} global component(s)
-`);
   const cmsProvider = new FileSystemCMSProvider(projectPaths.templates(), projectPaths.cms());
   const cmsService = new CMSService(cmsProvider);
   await cmsService.initialize();
-  console.log("CMS service initialized\n");
   const themeConfig = await colorService.loadThemeConfig();
   const variablesConfig = await variableService.loadConfig();
   const breakpoints = await loadBreakpointConfig();
   const responsiveScales = await loadResponsiveScalesConfig();
   await configService.load();
-  const globalLibraries = configService.getLibraries();
-  const componentLibraries = collectComponentLibraries(globalComponents);
-  const outDir = outputDir || join(projectPaths.project, "astro-export");
-  if (existsSync(outDir)) {
-    rmSync(outDir, { recursive: true, force: true });
-  }
-  mkdirSync(outDir, { recursive: true });
-  const srcDir = join(outDir, "src");
-  const pagesOutDir = join(srcDir, "pages");
-  const layoutsDir = join(srcDir, "layouts");
-  const stylesDir = join(srcDir, "styles");
-  const componentsOutDir = join(srcDir, "components");
-  const publicDir = join(outDir, "public");
-  const scriptsDir = join(publicDir, "_scripts");
-  for (const d of [srcDir, pagesOutDir, layoutsDir, stylesDir, componentsOutDir, publicDir]) {
-    mkdirSync(d, { recursive: true });
-  }
   const pagesDir = projectPaths.pages();
   if (!existsSync(pagesDir)) {
-    console.error("Pages directory not found!");
-    return { pages: 0, cmsPages: 0, collections: 0, errors: 1 };
+    return emptyPayload();
   }
   const pageFiles = scanJSONFiles(pagesDir);
   if (pageFiles.length === 0) {
-    console.warn("No pages found in ./pages directory");
-    return { pages: 0, cmsPages: 0, collections: 0, errors: 0 };
+    return emptyPayload();
   }
-  console.log(`Found ${pageFiles.length} page(s) to process
-`);
   const slugMappings = [];
   for (const file of pageFiles) {
     const pageName = file.replace(".json", "");
@@ -1505,61 +683,16 @@ async function buildAstroProject(projectRoot, outputDir) {
     } catch {
     }
   }
-  const allResults = [];
-  const allInteractiveStyles = /* @__PURE__ */ new Map();
-  const allComponentCSS = /* @__PURE__ */ new Set();
-  const jsContents = /* @__PURE__ */ new Map();
-  let errorCount = 0;
-  function mergeInteractiveStyles(source) {
-    for (const [key, value] of source) {
-      if (!allInteractiveStyles.has(key)) {
-        allInteractiveStyles.set(key, value);
-      }
-    }
-  }
-  function processRenderResult(result, urlPath, astroFilePath, fileDepth, pageData, pageName, isCMSPage2) {
-    mergeInteractiveStyles(result.interactiveStylesMap);
-    if (result.componentCSS) {
-      allComponentCSS.add(result.componentCSS);
-    }
-    if (result.javascript) {
-      const hash = hashContent2(result.javascript);
-      if (!jsContents.has(hash)) {
-        jsContents.set(hash, result.javascript);
-      }
-    }
-    allResults.push({
-      html: result.html,
-      meta: result.meta,
-      title: result.title,
-      javascript: result.javascript,
-      componentCSS: result.componentCSS,
-      locale: result.locale,
-      interactiveStylesMap: result.interactiveStylesMap,
-      urlPath,
-      fileDepth,
-      astroFilePath,
-      pageData,
-      pageName,
-      isCMSPage: isCMSPage2
-    });
-  }
+  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(join(pagesDir, file));
-    if (!pageContent) {
-      console.warn(`  Skipping ${basePath} (empty file)`);
-      errorCount++;
-      continue;
-    }
+    if (!pageContent) continue;
     try {
       const pageData = parseJSON(pageContent);
-      const isDevBuild = process.env.MENO_DEV_BUILD === "true";
-      if (pageData.meta?.draft === true && !isDevBuild) {
-        console.log(`  Skipping draft: ${basePath}`);
-        continue;
-      }
+      if (pageData.meta?.draft === true) continue;
       const slugs = pageData.meta?.slugs;
       for (const localeConfig of i18nConfig.locales) {
         const locale = localeConfig.code;
@@ -1573,9 +706,6 @@ async function buildAstroProject(projectRoot, outputDir) {
           slug = basePath.substring(1);
         }
         const urlPath = isDefault ? slug === "" ? "/" : `/${slug}` : slug === "" ? `/${locale}` : `/${locale}/${slug}`;
-        const astroFileName = slug === "" ? "index.astro" : `${slug}.astro`;
-        const astroFilePath = isDefault ? astroFileName : `${locale}/${astroFileName}`;
-        const fileDepth = astroFilePath.split("/").length - 1;
         const result = await renderPageSSR(
           pageData,
           globalComponents,
@@ -1585,60 +715,79 @@ async function buildAstroProject(projectRoot, outputDir) {
           i18nConfig,
           slugMappings,
           void 0,
-          // cmsContext
           cmsService,
           true
-          // isProductionBuild
         );
-        processRenderResult(result, urlPath, astroFilePath, fileDepth, pageData, pageName, false);
-        console.log(`  Rendered: ${urlPath}`);
+        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 rendering ${basePath}:`, error?.message || error);
-      errorCount++;
+      console.error(`Error processing ${basePath}:`, error?.message);
     }
   }
   const templatesDir = projectPaths.templates();
-  const templateSchemas = [];
-  let cmsPageCount = 0;
+  const cmsCollections = [];
   if (existsSync(templatesDir)) {
     const templateFiles = readdirSync(templatesDir).filter((f) => f.endsWith(".json"));
-    if (templateFiles.length > 0) {
-      console.log(`
-Processing ${templateFiles.length} CMS template(s)...
-`);
-    }
     for (const file of templateFiles) {
       const templateContent = await loadJSONFile(join(templatesDir, file));
       if (!templateContent) continue;
       try {
         const pageData = parseJSON(templateContent);
-        const isDevBuild = process.env.MENO_DEV_BUILD === "true";
-        if (pageData.meta?.draft === true && !isDevBuild) {
-          console.log(`  Skipping draft template: ${file}`);
-          continue;
-        }
-        if (!isCMSPage(pageData)) {
-          console.warn(`  ${file} is in templates/ but missing meta.source: "cms"`);
-          continue;
-        }
+        if (pageData.meta?.draft === true) continue;
+        if (!isCMSPage(pageData)) continue;
         const cmsSchema = pageData.meta.cms;
-        templateSchemas.push(cmsSchema);
-        console.log(`  CMS Collection: ${cmsSchema.id}`);
         const items = await cmsService.queryItems({ collection: cmsSchema.id });
-        if (items.length === 0) {
-          console.log(`    No items found in cms/${cmsSchema.id}/`);
-          continue;
+        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);
         }
-        console.log(`    Found ${items.length} item(s)`);
+        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;
-            const isDefault = locale === i18nConfig.defaultLocale;
-            const isDevBuild2 = process.env.MENO_DEV_BUILD === "true";
-            if (!isDevBuild2 && isItemDraftForLocale(item, locale)) {
-              continue;
-            }
+            if (isItemDraftForLocale(item, locale)) continue;
             const itemPath = buildCMSItemPath(cmsSchema.urlPattern, item, cmsSchema.slugField, locale, i18nConfig);
             const itemWithUrl = { ...item, _url: itemPath };
             const result = await renderPageSSR(
@@ -1653,293 +802,53 @@ Processing ${templateFiles.length} CMS template(s)...
               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 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 || error);
-        errorCount++;
+        console.error(`Error processing template ${file}:`, error?.message);
       }
     }
   }
-  const mappingClasses = collectAllMappingClasses(globalComponents, breakpoints);
-  const fontCSS = generateFontCSS();
   const themeColorCSS = generateThemeColorVariablesCSS(themeConfig);
   const variablesCSS = generateVariablesCSS(variablesConfig, breakpoints, responsiveScales);
-  const interactiveCSS = generateAllInteractiveCSS(allInteractiveStyles, breakpoints);
-  const componentCSSCombined = Array.from(allComponentCSS).join("\n");
-  const baseCSS = `@layer base {
-  * { margin: 0; padding: 0; box-sizing: border-box; }
-  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', sans-serif; }
-  button { background: none; border: none; padding: 0; font: inherit; cursor: pointer; outline: inherit; }
-  img { display: block; width: 100%; height: 100%; }
-  picture { display: block; }
-  .olink { text-decoration: none; display: block; }
-  .oem { display: inline-block; }
-}`;
-  const tailwindDirectives = `@tailwind base;
-@tailwind components;
-@tailwind utilities;`;
-  const globalCSS = [tailwindDirectives, fontCSS, themeColorCSS, variablesCSS, baseCSS, componentCSSCombined, interactiveCSS].filter(Boolean).join("\n\n");
-  await writeFile2(join(stylesDir, "global.css"), globalCSS, "utf-8");
-  console.log(`
-Generated global.css (${(globalCSS.length / 1024).toFixed(1)} KB)`);
-  const fontPreloads = generateFontPreloadTags();
-  const mergedLibraries = mergeLibraries(globalLibraries, componentLibraries);
-  const buildLibraries = filterLibrariesByContext(mergedLibraries, "build");
-  const libraryTags = generateLibraryTags(buildLibraries);
-  const baseLayoutContent = `---
-import '../styles/global.css';
-
-interface Props {
-  title: string;
-  meta?: string;
-  scripts?: string[];
-  locale?: string;
-  theme?: string;
-  fontPreloads?: string;
-  libraryTags?: { headCSS?: string; headJS?: string; bodyEndJS?: string };
-}
-
-const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.default || "light"}', fontPreloads = '', libraryTags = {} } = Astro.props;
----
-<!DOCTYPE html>
-<html lang={locale} data-theme={theme}>
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <Fragment set:html={fontPreloads} />
-  <Fragment set:html={libraryTags.headCSS || ''} />
-  <Fragment set:html={libraryTags.headJS || ''} />
-  <Fragment set:html={meta} />
-  <title>{title}</title>
-</head>
-<body>
-  <slot />
-  {scripts.map((s) => <script src={s} />)}
-  <Fragment set:html={libraryTags.bodyEndJS || ''} />
-</body>
-</html>
-`;
-  await writeFile2(join(layoutsDir, "BaseLayout.astro"), baseLayoutContent, "utf-8");
-  console.log("Generated BaseLayout.astro");
-  let componentFileCount = 0;
-  for (const [compName, compDef] of Object.entries(globalComponents)) {
-    try {
-      const astroContent = emitAstroComponent(compName, compDef, globalComponents, breakpoints);
-      await writeFile2(join(componentsOutDir, `${compName}.astro`), astroContent, "utf-8");
-      componentFileCount++;
-    } catch (error) {
-      console.warn(`  Warning: could not generate component ${compName}: ${error?.message}`);
-    }
-  }
-  console.log(`Generated ${componentFileCount} component .astro file(s)`);
-  const defaultTheme = themeConfig.default || "light";
-  for (const result of allResults) {
-    const importPath = layoutImportPath(result.fileDepth);
-    const scriptPaths = [];
-    if (result.javascript) {
-      const hash = hashContent2(result.javascript);
-      const scriptFile = `${hash}.js`;
-      const scriptPublicPath = `/_scripts/${scriptFile}`;
-      if (!existsSync(scriptsDir)) {
-        mkdirSync(scriptsDir, { recursive: true });
-      }
-      const fullScriptPath = join(scriptsDir, scriptFile);
-      if (!existsSync(fullScriptPath)) {
-        await writeFile2(fullScriptPath, result.javascript, "utf-8");
-      }
-      scriptPaths.push(scriptPublicPath);
-    }
-    let astroContent;
-    if (result.pageData && !result.isCMSPage) {
-      try {
-        astroContent = emitAstroPage({
-          pageData: result.pageData,
-          globalComponents,
-          title: result.title,
-          meta: result.meta,
-          locale: result.locale,
-          theme: defaultTheme,
-          fontPreloads,
-          libraryTags,
-          scriptPaths,
-          layoutImportPath: importPath,
-          fileDepth: result.fileDepth,
-          ssrFallbacks: /* @__PURE__ */ new Map(),
-          // SSR fallbacks for complex nodes
-          pageName: result.pageName || "index",
-          breakpoints
-        });
-      } catch (error) {
-        console.warn(`  Warning: component emission failed for ${result.urlPath}, using SSR fallback: ${error?.message}`);
-        astroContent = buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths);
-      }
-    } else {
-      astroContent = buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths);
-    }
-    const astroFileFull = join(pagesOutDir, result.astroFilePath);
-    const astroFileDir = astroFileFull.substring(0, astroFileFull.lastIndexOf("/"));
-    if (!existsSync(astroFileDir)) {
-      mkdirSync(astroFileDir, { recursive: true });
-    }
-    await writeFile2(astroFileFull, astroContent, "utf-8");
-  }
-  console.log(`Generated ${allResults.length} .astro page file(s)`);
-  let collectionCount = 0;
-  if (templateSchemas.length > 0) {
-    const contentDir = join(srcDir, "content");
-    mkdirSync(contentDir, { recursive: true });
-    const collectionDefs = [];
-    for (const schema of templateSchemas) {
-      const collectionDir = join(contentDir, schema.id);
-      mkdirSync(collectionDir, { recursive: true });
-      const cmsItemsDir = join(projectPaths.cms(), schema.id);
-      if (existsSync(cmsItemsDir)) {
-        const itemFiles = readdirSync(cmsItemsDir).filter((f) => f.endsWith(".json"));
-        for (const itemFile of itemFiles) {
-          try {
-            const rawContent = await readFile(join(cmsItemsDir, itemFile), "utf-8");
-            const item = JSON.parse(rawContent);
-            const resolved = {};
-            for (const [key, value] of Object.entries(item)) {
-              if (isI18nValue(value)) {
-                resolved[key] = resolveI18nValue(value, i18nConfig.defaultLocale, i18nConfig);
-              } else {
-                resolved[key] = value;
-              }
-            }
-            await writeFile2(
-              join(collectionDir, itemFile),
-              JSON.stringify(resolved, null, 2),
-              "utf-8"
-            );
-          } catch (err) {
-            console.warn(`    Warning: could not process CMS item ${itemFile}: ${err?.message}`);
-          }
-        }
-      }
-      const fieldDefs = [];
-      if (schema.fields) {
-        for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
-          const zodType = cmsFieldToZod(fieldDef);
-          const optional = fieldDef.required ? "" : ".optional()";
-          fieldDefs.push(`    ${fieldName}: ${zodType}${optional}`);
-        }
-      }
-      collectionDefs.push(`  '${schema.id}': defineCollection({
-    type: 'data',
-    schema: z.object({
-${fieldDefs.join(",\n")}
-    })
-  })`);
-      collectionCount++;
-    }
-    const configContent = `import { z, defineCollection } from 'astro:content';
-
-const collections = {
-${collectionDefs.join(",\n")}
-};
-
-export { collections };
-`;
-    await writeFile2(join(contentDir, "config.ts"), configContent, "utf-8");
-    console.log(`Generated ${collectionCount} content collection(s) with config.ts`);
-  }
-  const assetDirs = ["fonts", "images", "icons", "videos", "assets"];
-  let copiedAssets = 0;
-  for (const dir of assetDirs) {
-    const srcAssetDir = join(projectPaths.project, dir);
-    if (existsSync(srcAssetDir)) {
-      copyDirectory(srcAssetDir, join(publicDir, dir));
-      copiedAssets++;
-    }
-  }
-  const librariesDir = join(projectPaths.project, "libraries");
-  if (existsSync(librariesDir)) {
-    copyDirectory(librariesDir, join(publicDir, "libraries"));
-    copiedAssets++;
-  }
-  if (copiedAssets > 0) {
-    console.log(`Copied ${copiedAssets} asset director${copiedAssets === 1 ? "y" : "ies"} to public/`);
-  }
-  const packageJson = {
-    name: "astro-export",
-    type: "module",
-    version: "0.0.1",
-    private: true,
-    scripts: {
-      dev: "astro dev",
-      start: "astro dev",
-      build: "astro build",
-      preview: "astro preview"
-    },
-    dependencies: {
-      "astro": "^4.0.0",
-      "@astrojs/sitemap": "^3.0.0",
-      "@astrojs/tailwind": "^5.0.0",
-      "tailwindcss": "^3.4.0"
-    }
-  };
-  await writeFile2(join(outDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf-8");
-  const astroConfig = `import { defineConfig } from 'astro/config';
-import sitemap from '@astrojs/sitemap';
-import tailwind from '@astrojs/tailwind';
-
-export default defineConfig({${siteUrl ? `
-  site: '${siteUrl}',` : ""}
-  integrations: [sitemap(), tailwind({ applyBaseStyles: false })],
-});
-`;
-  const safelistArray = Array.from(mappingClasses);
-  const safelistLiteral = safelistArray.length > 0 ? `
-  safelist: [
-${safelistArray.map((c) => `    '${c}'`).join(",\n")}
-  ],` : "";
-  const tailwindConfig = `/** @type {import('tailwindcss').Config} */
-export default {
-  content: ['./src/**/*.{astro,html,js,jsx,md,mdx,svelte,ts,tsx,vue}'],${safelistLiteral}
-  theme: {
-    extend: {},
-  },
-  plugins: [],
-};
-`;
-  await writeFile2(join(outDir, "tailwind.config.mjs"), tailwindConfig, "utf-8");
-  await writeFile2(join(outDir, "astro.config.mjs"), astroConfig, "utf-8");
-  const tsConfig = {
-    extends: "astro/tsconfigs/strict"
+  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
   };
-  await writeFile2(join(outDir, "tsconfig.json"), JSON.stringify(tsConfig, null, 2), "utf-8");
-  console.log("Generated package.json, astro.config.mjs, tailwind.config.mjs, tsconfig.json");
-  const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
-  const totalPages = allResults.length;
-  console.log("\n" + "=".repeat(50));
-  console.log("Astro export complete!");
-  console.log(`  Pages: ${totalPages - cmsPageCount}`);
-  if (cmsPageCount > 0) {
-    console.log(`  CMS pages: ${cmsPageCount}`);
-  }
-  if (collectionCount > 0) {
-    console.log(`  Content collections: ${collectionCount}`);
-  }
-  if (errorCount > 0) {
-    console.log(`  Errors: ${errorCount}`);
-  }
-  console.log(`  Time: ${elapsed}s`);
-  console.log(`  Output: ${outDir}`);
-  console.log("");
+}
+function emptyPayload() {
   return {
-    pages: totalPages - cmsPageCount,
-    cmsPages: cmsPageCount,
-    collections: collectionCount,
-    errors: errorCount
+    version: 1,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pages: [],
+    styles: [],
+    cms: [],
+    assets: []
   };
 }
 
@@ -1964,12 +873,12 @@ export {
   SERVE_PORT,
   VariableService,
   WebSocketManager,
-  buildAstroProject,
   buildAttributes,
   buildComponentHTML,
   buildImageMetadataMap,
   buildLineMap,
   buildStaticPages,
+  buildWebflowPayload,
   bundleFile,
   clearJSValidationCache,
   collectComponentCSS,
@@ -1988,8 +897,12 @@ export {
   extractPageMeta,
   fileExists,
   generateBuildErrorPage,
+  generateFontCSS,
+  generateFontPreloadTags,
   generateMetaTags,
   generateSSRHTML,
+  generateThemeColorVariablesCSS,
+  generateVariablesCSS,
   getFileSize,
   getJSValidationErrors,
   getMimeType,
@@ -2008,13 +921,20 @@ export {
   isBun,
   jsonResponse,
   lineMapToObject,
+  loadBreakpointConfig,
+  loadComponentDirectory,
+  loadI18nConfig,
+  loadJSONFile,
   loadProjectConfig,
+  loadResponsiveScalesConfig,
   logError,
   logRequest,
   logResponseTime,
+  mapPageNameToPath,
   migrateTemplatesDirectory,
   minifyJS,
   packagePaths,
+  parseJSON,
   processCMSPropsTemplate,
   processCMSTemplate,
   projectPaths,