meno-core 1.0.6 → 1.0.8

package/build-static.ts

@@ -150,6 +150,37 @@ function getDisplayPath(
   return slug === "" ? `/${locale}` : `/${locale}/${slug}`;
 }
 
+/**
+ * Generate robots.txt with sensible defaults
+ */
+async function generateRobotsTxt(siteUrl: string, distDir: string): Promise<void> {
+  const content = `User-agent: *
+Allow: /
+
+Sitemap: ${siteUrl}/sitemap.xml
+`;
+  await writeFile(join(distDir, 'robots.txt'), content, 'utf-8');
+}
+
+/**
+ * Generate sitemap.xml from collected URLs
+ */
+async function generateSitemap(urls: string[], siteUrl: string, distDir: string): Promise<void> {
+  // Sort URLs for deterministic output
+  const sortedUrls = [...urls].sort();
+
+  const urlEntries = sortedUrls
+    .map(url => `  <url><loc>${siteUrl}${url}</loc></url>`)
+    .join('\n');
+
+  const content = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urlEntries}
+</urlset>
+`;
+  await writeFile(join(distDir, 'sitemap.xml'), content, 'utf-8');
+}
+
 /**
  * Clean dist directory, keeping only production files
  */
@@ -232,7 +263,8 @@ async function buildCMSTemplates(
   i18nConfig: I18nConfig,
   slugMappings: SlugMap[],
   distDir: string,
-  cmsService: CMSService
+  cmsService: CMSService,
+  generatedUrls: Set<string>
 ): Promise<{ success: number; errors: number }> {
   let successCount = 0;
   let errorCount = 0;
@@ -313,6 +345,7 @@ async function buildCMSTemplates(
           await writeFile(outputPath, finalHtml, 'utf-8');
 
           const displayPath = locale === i18nConfig.defaultLocale ? itemPath : `/${locale}${itemPath}`;
+          generatedUrls.add(displayPath);
           console.log(`   ✅ ${displayPath}`);
           successCount++;
         }
@@ -333,7 +366,11 @@ async function buildStaticPages(): Promise<void> {
   console.log("🏗️  Building static HTML files...\n");
 
   // Load project config first
-  await loadProjectConfig();
+  const projectConfig = await loadProjectConfig();
+  const siteUrl = (projectConfig as { siteUrl?: string }).siteUrl?.replace(/\/$/, ''); // Remove trailing slash
+
+  // Track all generated URLs for sitemap
+  const generatedUrls = new Set<string>();
 
   // Load i18n config for multi-locale build
   const i18nConfig = await loadI18nConfig();
@@ -483,6 +520,7 @@ async function buildStaticPages(): Promise<void> {
 
         await writeFile(outputPath, finalHtml, "utf-8");
 
+        generatedUrls.add(urlPath);
         console.log(`✅ Built: ${urlPath} → ${outputPath}`);
         successCount++;
       }
@@ -501,11 +539,21 @@ async function buildStaticPages(): Promise<void> {
     i18nConfig,
     slugMappings,
     distDir,
-    cmsService
+    cmsService,
+    generatedUrls
   );
   successCount += cmsResult.success;
   errorCount += cmsResult.errors;
 
+  // Generate SEO files (robots.txt and sitemap.xml)
+  if (siteUrl) {
+    await generateRobotsTxt(siteUrl, distDir);
+    await generateSitemap([...generatedUrls], siteUrl, distDir);
+    console.log(`\n🔍 SEO files generated (robots.txt, sitemap.xml)`);
+  } else {
+    console.warn(`\n⚠️  Skipping SEO files: siteUrl not configured in project.config.json`);
+  }
+
   console.log("\n" + "=".repeat(50));
   console.log(`✨ Build complete!`);
   console.log(`   ✅ Success: ${successCount}`);
@@ -520,6 +568,9 @@ async function buildStaticPages(): Promise<void> {
   if (existsSync(functionsDir)) {
     console.log(`   - functions/ (Cloudflare Pages Functions)`);
   }
+  if (siteUrl) {
+    console.log(`   - robots.txt, sitemap.xml (SEO)`);
+  }
   console.log(`   - No React, no client-router ✓`);
 }
 

package/lib/client/core/ComponentBuilder.ts

@@ -26,7 +26,7 @@ import { processItemTemplate, processItemPropsTemplate, hasItemTemplates, type V
 import { DEFAULT_I18N_CONFIG, resolveI18nValue } from "../../shared/i18n";
 import { getChildPath, pathToString } from "../../shared/pathArrayUtils";
 import { responsiveStylesToClasses } from "../../shared/utilityClassMapper";
-import { processCMSTemplate, processCMSPropsTemplate } from "./cmsTemplateProcessor";
+import { processCMSTemplate, processCMSPropsTemplate, RAW_HTML_PREFIX } from "./cmsTemplateProcessor";
 import type { PrefetchService } from "../services/PrefetchService";
 import { generateElementClassName, type ElementClassContext } from "../../shared/elementClassName";
 import type { InteractiveStyles } from "../../shared/types/styles";
@@ -318,8 +318,10 @@ export class ComponentBuilder {
 
   /**
    * Process text node with CMS and item templates
+   * Returns a ReactElement with dangerouslySetInnerHTML for raw HTML content (rich-text),
+   * or a plain string for regular text content.
    */
-  private processTextNode(text: string, ctx: BuilderContext): string {
+  private processTextNode(text: string, ctx: BuilderContext): string | ReactElement {
     let result = text;
 
     // Process CMS templates
@@ -338,6 +340,12 @@ export class ComponentBuilder {
       result = processItemTemplate(result, effectiveTemplateContext, i18nResolver);
     }
 
+    // Check for raw HTML marker (from rich-text fields) - render with dangerouslySetInnerHTML
+    if (result.startsWith(RAW_HTML_PREFIX)) {
+      const rawHtml = result.slice(RAW_HTML_PREFIX.length);
+      return h('span', { dangerouslySetInnerHTML: { __html: rawHtml } });
+    }
+
     return result;
   }
 
@@ -536,7 +544,15 @@ export class ComponentBuilder {
       delete extractedAttributes.className;
     }
 
-    return { ...result, ...extractedAttributes };
+    // Convert boolean true to empty string for React compatibility
+    // React strips boolean true for non-standard attributes, but SSR outputs them as presence-only
+    // Using empty string makes React render the attribute (e.g., cmsrt="" matches [cmsrt] selector)
+    const normalizedAttributes: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(extractedAttributes)) {
+      normalizedAttributes[key] = value === true ? '' : value;
+    }
+
+    return { ...result, ...normalizedAttributes };
   }
 
   /**

package/lib/client/core/builders/cmsListBuilder.ts

@@ -6,7 +6,7 @@
 import { createElement as h } from "react";
 import type { ReactElement } from "react";
 import type { CMSListNode, CMSItem } from "../../../shared/types/cms";
-import type { InteractiveStyles } from "../../../shared/types";
+import type { InteractiveStyles, StyleObject, ResponsiveStyleObject } from "../../../shared/types";
 import { singularize } from "../../../shared/types/cms";
 import { buildTemplateContext, resolveItemsTemplate } from "../../../shared/itemTemplateUtils";
 import { extractAttributesFromNode } from "../../../shared/attributeNodeUtils";
@@ -14,6 +14,7 @@ import { responsiveStylesToClasses } from "../../../shared/utilityClassMapper";
 import { pathToString } from "../../../shared/pathArrayUtils";
 import { generateElementClassName, type ElementClassContext } from "../../../shared/elementClassName";
 import { InteractiveStylesRegistry } from "../../InteractiveStylesRegistry";
+import { hasInteractiveStyleMappings, extractInteractiveStyleMappings, resolveExtractedMappings } from "../../../shared/interactiveStyleMappings";
 import type { ElementRegistry } from "../../elementRegistry";
 import type { BuilderContext, BuildResult, BuildChildrenContext } from "./types";
 
@@ -60,7 +61,18 @@ export function buildCMSList(
     'data-element-path': pathToString(elementPath),
     'data-cms-list': 'true',
     'data-collection': node.collection || '',
-    ref: (el: HTMLElement | null) => deps.elementRegistry.register(elementPath, el, effectiveParentComponentName, false)
+    ref: (el: HTMLElement | null) => {
+      deps.elementRegistry.register(elementPath, el, effectiveParentComponentName, false);
+      // Apply CSS variables for interactive styles
+      if (el) {
+        const cssVariables = InteractiveStylesRegistry.getVariables(elementPath);
+        if (cssVariables && Object.keys(cssVariables).length > 0) {
+          for (const [varName, value] of Object.entries(cssVariables)) {
+            el.style.setProperty(varName, value);
+          }
+        }
+      }
+    }
   };
 
   // Start building className
@@ -97,9 +109,32 @@ export function buildCMSList(
     // Prepend element class
     classNames.unshift(elementClass);
 
-    // Register interactive styles
+    // Register interactive styles with mapping support
     if (nodeInteractiveStyles && nodeInteractiveStyles.length > 0) {
-      InteractiveStylesRegistry.set(elementClass, nodeInteractiveStyles);
+      if (ctx.componentResolvedProps && hasInteractiveStyleMappings(nodeInteractiveStyles)) {
+        const { resolvedStyles, mappings } = extractInteractiveStyleMappings(nodeInteractiveStyles);
+        const cssVariables = resolveExtractedMappings(mappings, ctx.componentResolvedProps);
+        InteractiveStylesRegistry.set(elementClass, resolvedStyles);
+        if (Object.keys(cssVariables).length > 0) {
+          InteractiveStylesRegistry.setVariables(elementPath, cssVariables);
+        }
+      } else {
+        InteractiveStylesRegistry.set(elementClass, nodeInteractiveStyles);
+      }
+
+      // Apply preview classes when previewProp is set and truthy
+      if (ctx.componentResolvedProps) {
+        const previewClasses: string[] = [];
+        for (const rule of nodeInteractiveStyles) {
+          if (rule.previewProp && ctx.componentResolvedProps[rule.previewProp] === true) {
+            const styleClasses = responsiveStylesToClasses(rule.style as StyleObject | ResponsiveStyleObject);
+            previewClasses.push(...styleClasses);
+          }
+        }
+        if (previewClasses.length > 0) {
+          classNames.push(...previewClasses);
+        }
+      }
     }
   }
 

package/lib/client/core/builders/embedBuilder.ts

@@ -11,6 +11,7 @@ import { responsiveStylesToClasses } from "../../../shared/utilityClassMapper";
 import { pathToString } from "../../../shared/pathArrayUtils";
 import { generateElementClassName, type ElementClassContext } from "../../../shared/elementClassName";
 import { InteractiveStylesRegistry } from "../../InteractiveStylesRegistry";
+import { hasInteractiveStyleMappings, extractInteractiveStyleMappings, resolveExtractedMappings } from "../../../shared/interactiveStyleMappings";
 import DOMPurify from "isomorphic-dompurify";
 import type { ElementRegistry } from "../../elementRegistry";
 import type { BuilderContext } from "./types";
@@ -60,7 +61,18 @@ export function buildEmbed(
     key,
     'data-element-path': pathToString(elementPath),
     'data-embed-node': 'true',
-    ref: (el: HTMLElement | null) => deps.elementRegistry.register(elementPath, el, effectiveParentComponentName, false),
+    ref: (el: HTMLElement | null) => {
+      deps.elementRegistry.register(elementPath, el, effectiveParentComponentName, false);
+      // Apply CSS variables for interactive styles
+      if (el) {
+        const cssVariables = InteractiveStylesRegistry.getVariables(elementPath);
+        if (cssVariables && Object.keys(cssVariables).length > 0) {
+          for (const [varName, value] of Object.entries(cssVariables)) {
+            el.style.setProperty(varName, value);
+          }
+        }
+      }
+    },
     dangerouslySetInnerHTML: { __html: sanitizedHtml }
   };
 
@@ -103,9 +115,32 @@ export function buildEmbed(
     // Prepend element class
     classNames.unshift(elementClass);
 
-    // Register interactive styles
+    // Register interactive styles with mapping support
     if (nodeInteractiveStyles && nodeInteractiveStyles.length > 0) {
-      InteractiveStylesRegistry.set(elementClass, nodeInteractiveStyles);
+      if (ctx.componentResolvedProps && hasInteractiveStyleMappings(nodeInteractiveStyles)) {
+        const { resolvedStyles, mappings } = extractInteractiveStyleMappings(nodeInteractiveStyles);
+        const cssVariables = resolveExtractedMappings(mappings, ctx.componentResolvedProps);
+        InteractiveStylesRegistry.set(elementClass, resolvedStyles);
+        if (Object.keys(cssVariables).length > 0) {
+          InteractiveStylesRegistry.setVariables(elementPath, cssVariables);
+        }
+      } else {
+        InteractiveStylesRegistry.set(elementClass, nodeInteractiveStyles);
+      }
+
+      // Apply preview classes when previewProp is set and truthy
+      if (ctx.componentResolvedProps) {
+        const previewClasses: string[] = [];
+        for (const rule of nodeInteractiveStyles) {
+          if (rule.previewProp && ctx.componentResolvedProps[rule.previewProp] === true) {
+            const styleClasses = responsiveStylesToClasses(rule.style as StyleObject | ResponsiveStyleObject);
+            previewClasses.push(...styleClasses);
+          }
+        }
+        if (previewClasses.length > 0) {
+          classNames.push(...previewClasses);
+        }
+      }
     }
   }
 

package/lib/client/core/builders/localeListBuilder.ts

@@ -11,6 +11,7 @@ import { responsiveStylesToClasses } from "../../../shared/utilityClassMapper";
 import { pathToString } from "../../../shared/pathArrayUtils";
 import { generateElementClassName, type ElementClassContext } from "../../../shared/elementClassName";
 import { InteractiveStylesRegistry } from "../../InteractiveStylesRegistry";
+import { hasInteractiveStyleMappings, extractInteractiveStyleMappings, resolveExtractedMappings } from "../../../shared/interactiveStyleMappings";
 import type { ElementRegistry } from "../../elementRegistry";
 import type { BuilderContext } from "./types";
 
@@ -49,7 +50,18 @@ export function buildLocaleList(
     key,
     'data-element-path': pathToString(elementPath),
     'data-locale-list': 'true',
-    ref: (el: HTMLElement | null) => deps.elementRegistry.register(elementPath, el, effectiveParentComponentName, false)
+    ref: (el: HTMLElement | null) => {
+      deps.elementRegistry.register(elementPath, el, effectiveParentComponentName, false);
+      // Apply CSS variables for interactive styles
+      if (el) {
+        const cssVariables = InteractiveStylesRegistry.getVariables(elementPath);
+        if (cssVariables && Object.keys(cssVariables).length > 0) {
+          for (const [varName, value] of Object.entries(cssVariables)) {
+            el.style.setProperty(varName, value);
+          }
+        }
+      }
+    }
   };
 
   // Add CMS item index path for elements inside CMS lists
@@ -91,9 +103,32 @@ export function buildLocaleList(
     // Prepend element class
     classNames.unshift(elementClass);
 
-    // Register interactive styles
+    // Register interactive styles with mapping support
     if (nodeInteractiveStyles && nodeInteractiveStyles.length > 0) {
-      InteractiveStylesRegistry.set(elementClass, nodeInteractiveStyles);
+      if (ctx.componentResolvedProps && hasInteractiveStyleMappings(nodeInteractiveStyles)) {
+        const { resolvedStyles, mappings } = extractInteractiveStyleMappings(nodeInteractiveStyles);
+        const cssVariables = resolveExtractedMappings(mappings, ctx.componentResolvedProps);
+        InteractiveStylesRegistry.set(elementClass, resolvedStyles);
+        if (Object.keys(cssVariables).length > 0) {
+          InteractiveStylesRegistry.setVariables(elementPath, cssVariables);
+        }
+      } else {
+        InteractiveStylesRegistry.set(elementClass, nodeInteractiveStyles);
+      }
+
+      // Apply preview classes when previewProp is set and truthy
+      if (ctx.componentResolvedProps) {
+        const previewClasses: string[] = [];
+        for (const rule of nodeInteractiveStyles) {
+          if (rule.previewProp && ctx.componentResolvedProps[rule.previewProp] === true) {
+            const styleClasses = responsiveStylesToClasses(rule.style as StyleObject | ResponsiveStyleObject);
+            previewClasses.push(...styleClasses);
+          }
+        }
+        if (previewClasses.length > 0) {
+          classNames.push(...previewClasses);
+        }
+      }
     }
   }
 

package/lib/client/core/builders/objectLinkBuilder.ts

@@ -11,6 +11,7 @@ import { responsiveStylesToClasses } from "../../../shared/utilityClassMapper";
 import { pathToString } from "../../../shared/pathArrayUtils";
 import { generateElementClassName, type ElementClassContext } from "../../../shared/elementClassName";
 import { InteractiveStylesRegistry } from "../../InteractiveStylesRegistry";
+import { hasInteractiveStyleMappings, extractInteractiveStyleMappings, resolveExtractedMappings } from "../../../shared/interactiveStyleMappings";
 import type { ElementRegistry } from "../../elementRegistry";
 import type { BuilderContext, BuildResult, BuildChildrenContext } from "./types";
 
@@ -55,7 +56,18 @@ export function buildObjectLink(
     key,
     'data-element-path': pathToString(elementPath),
     'data-object-link-node': 'true',
-    ref: (el: HTMLElement | null) => deps.elementRegistry.register(elementPath, el, effectiveParentComponentName, false)
+    ref: (el: HTMLElement | null) => {
+      deps.elementRegistry.register(elementPath, el, effectiveParentComponentName, false);
+      // Apply CSS variables for interactive styles
+      if (el) {
+        const cssVariables = InteractiveStylesRegistry.getVariables(elementPath);
+        if (cssVariables && Object.keys(cssVariables).length > 0) {
+          for (const [varName, value] of Object.entries(cssVariables)) {
+            el.style.setProperty(varName, value);
+          }
+        }
+      }
+    }
   };
 
   // Add CMS item index path for elements inside CMS lists
@@ -97,9 +109,32 @@ export function buildObjectLink(
     // Prepend element class
     classNames.unshift(elementClass);
 
-    // Register interactive styles
+    // Register interactive styles with mapping support
     if (nodeInteractiveStyles && nodeInteractiveStyles.length > 0) {
-      InteractiveStylesRegistry.set(elementClass, nodeInteractiveStyles);
+      if (ctx.componentResolvedProps && hasInteractiveStyleMappings(nodeInteractiveStyles)) {
+        const { resolvedStyles, mappings } = extractInteractiveStyleMappings(nodeInteractiveStyles);
+        const cssVariables = resolveExtractedMappings(mappings, ctx.componentResolvedProps);
+        InteractiveStylesRegistry.set(elementClass, resolvedStyles);
+        if (Object.keys(cssVariables).length > 0) {
+          InteractiveStylesRegistry.setVariables(elementPath, cssVariables);
+        }
+      } else {
+        InteractiveStylesRegistry.set(elementClass, nodeInteractiveStyles);
+      }
+
+      // Apply preview classes when previewProp is set and truthy
+      if (ctx.componentResolvedProps) {
+        const previewClasses: string[] = [];
+        for (const rule of nodeInteractiveStyles) {
+          if (rule.previewProp && ctx.componentResolvedProps[rule.previewProp] === true) {
+            const styleClasses = responsiveStylesToClasses(rule.style as StyleObject | ResponsiveStyleObject);
+            previewClasses.push(...styleClasses);
+          }
+        }
+        if (previewClasses.length > 0) {
+          classNames.push(...previewClasses);
+        }
+      }
     }
   }
 

package/lib/client/core/cmsTemplateProcessor.ts

@@ -8,6 +8,12 @@
 import type { I18nValue, I18nConfig } from '../../shared/types';
 import { getI18nConfig } from '../i18nConfigService';
 import { isRichTextMarker, richTextMarkerToHtml } from '../../shared/propResolver';
+import { tiptapToHtml } from '../../shared/richtext/tiptapToHtml';
+import { isTiptapDocument } from '../../shared/richtext/types';
+import { RAW_HTML_PREFIX } from '../../shared/constants';
+
+// Re-export for backward compatibility
+export { RAW_HTML_PREFIX };
 
 /**
  * Check if a value is an I18nValue object
@@ -86,8 +92,14 @@ export function processCMSTemplate(
       return '';
     }
     // Handle rich-text markers - extract HTML content for interpolation
+    // Mark with RAW_HTML_PREFIX so renderer knows not to escape
     if (typeof value === 'object' && '__richtext__' in value && typeof (value as unknown as { html: string }).html === 'string') {
-      return (value as unknown as { html: string }).html;
+      return RAW_HTML_PREFIX + (value as unknown as { html: string }).html;
+    }
+    // Handle raw TipTap documents (fallback if not preprocessed)
+    // Mark with RAW_HTML_PREFIX so renderer knows not to escape
+    if (isTiptapDocument(value)) {
+      return RAW_HTML_PREFIX + tiptapToHtml(value);
     }
     return String(value);
   });

package/lib/client/routing/Router.tsx

@@ -29,6 +29,18 @@ import { parseLocaleFromPath, setStoredLocale, DEFAULT_I18N_CONFIG } from "../..
 import { fetchI18nConfig, setI18nConfig as setCachedI18nConfig } from "../i18nConfigService";
 import { IFRAME_MESSAGE_TYPES } from "../../shared/constants";
 
+/** SSR-serialized CMS context for client-side hydration */
+interface SSRCMSContext {
+  item: Record<string, unknown>;
+  templatePath: string;
+}
+
+declare global {
+  interface Window {
+    __MENO_CMS__?: SSRCMSContext;
+  }
+}
+
 /**
  * Router component props
  */
@@ -123,6 +135,11 @@ export function Router(props: RouterProps = {}): ReactElement {
   // Don't block rendering waiting for CMS context - render immediately and re-render when context arrives
   const [awaitingCmsContext, setAwaitingCmsContext] = useState(false);
   const [collectionItemsMap, setCollectionItemsMap] = useState<Record<string, CMSItem[]>>({});
+  // Store CMS template path for HMR reloads (so we don't lose it after initial load)
+  const [cmsTemplatePath, setCmsTemplatePath] = useState<string | null>(null);
+
+  // Track if initial mount used SSR CMS context (to skip redundant path-based load)
+  const ssrCmsHandledRef = useRef(false);
 
   // Create RouteLoader instance
   const routeLoader = useRef(new RouteLoader({
@@ -312,9 +329,11 @@ export function Router(props: RouterProps = {}): ReactElement {
   }, [componentTree, currentPath, services]);
 
   // Load components function using RouteLoader
+  // For CMS pages, use the stored template path instead of the URL path
   const loadComponents = useCallback(async (path: string) => {
-    await routeLoader.loadComponents(path);
-  }, []);
+    const pathToLoad = cmsTemplatePath || path;
+    await routeLoader.loadComponents(pathToLoad);
+  }, [cmsTemplatePath]);
 
   // Handle navigation
   useEffect(() => {
@@ -330,16 +349,37 @@ export function Router(props: RouterProps = {}): ReactElement {
   }, [loadComponents]);
 
   useEffect(() => {
+    // Check for SSR-serialized CMS context (from window.__MENO_CMS__)
+    // If present, use the template path instead of the CMS URL to avoid 404
+    const ssrCmsContext = window.__MENO_CMS__;
+    if (ssrCmsContext) {
+      // Set CMS context from SSR
+      setCmsContext(ssrCmsContext.item);
+      // Store template path for HMR reloads
+      setCmsTemplatePath(ssrCmsContext.templatePath);
+      // Mark that we're handling SSR CMS (to skip path-based load below)
+      ssrCmsHandledRef.current = true;
+      // Clear to prevent stale data on SPA navigation
+      delete window.__MENO_CMS__;
+    }
+
     // Initial load
     routeLoader.loadPages();
     routeLoader.loadGlobalComponents().then(() => {
-      loadComponents(currentPath);
+      // Use template path for CMS pages, otherwise use the current URL path
+      const pathToLoad = ssrCmsContext ? ssrCmsContext.templatePath : currentPath;
+      loadComponents(pathToLoad);
     });
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []); // Only run on mount - currentPath handled by separate effect below
 
   // Reload when path changes
   useEffect(() => {
+    // Skip initial mount if SSR CMS context was handled (template already loading)
+    if (ssrCmsHandledRef.current) {
+      ssrCmsHandledRef.current = false;
+      return;
+    }
     setShowNotFound(false); // Reset not found state when path changes
     loadComponents(currentPath);
   }, [currentPath, loadComponents]);

package/lib/client/templateEngine.ts

@@ -16,6 +16,7 @@ import { isRichTextMarker, richTextMarkerToHtml } from '../shared/propResolver';
 import { isTiptapDocument, tiptapToHtml } from '../shared/richtext';
 import { hasItemTemplates } from '../shared/itemTemplateUtils';
 import { safeEvaluate } from '../shared/expressionEvaluator';
+import { RAW_HTML_PREFIX } from '../shared/constants';
 
 // Re-export for backward compatibility
 export { isResponsiveStyle };
@@ -327,9 +328,10 @@ export function processStructure(
       // Use evaluateTemplate to preserve type (objects, arrays, numbers)
       if (/^\{\{.+\}\}$/.test(structure)) {
         const result = evaluateTemplate(structure, evalContext);
-        // Check for rich-text marker - convert to inline embed node
+        // Check for rich-text marker - extract HTML content with RAW_HTML_PREFIX
+        // The prefix signals to ComponentBuilder.processTextNode to render as HTML
         if (isRichTextMarker(result)) {
-          return { type: NODE_TYPE.EMBED, html: result.html, inline: true } as any;
+          return RAW_HTML_PREFIX + richTextMarkerToHtml(result);
         }
         if (typeof result === 'string' || typeof result === 'number') {
           return result;
@@ -391,11 +393,24 @@ export function processStructure(
         return null;
       }
       
-      // Preserve type from input structure, default to "node" if not present or invalid
+      // Check if this is a valid node structure or a plain object (like props)
       const inputNode = structure as ComponentNode;
-      const preservedType = inputNode.type && isValidNodeType(inputNode.type)
-        ? inputNode.type
-        : NODE_TYPE.NODE;
+      const hasValidNodeType = inputNode.type && isValidNodeType(inputNode.type);
+
+      // If no valid node type, treat as plain object and process values recursively
+      // This handles props objects like { text: "{{text}}", isMarginBottom: false }
+      if (!hasValidNodeType) {
+        const result: Record<string, unknown> = {};
+        for (const [key, value] of Object.entries(structure)) {
+          const processedValue = processStructure(value as any, context, viewportWidth, instanceChildren, preserveResponsiveStyles, depth + 1);
+          if (processedValue !== null && processedValue !== undefined) {
+            result[key] = processedValue;
+          }
+        }
+        return result as any;
+      }
+
+      const preservedType = inputNode.type;
 
       // Create base processed object based on type
       let processed: ComponentNode;

package/lib/server/fileWatcher.ts

@@ -13,12 +13,14 @@ export interface FileWatchCallbacks {
   onComponentChange?: () => Promise<void>;
   onPageChange?: (pagePath: string) => Promise<void>;
   onColorsChange?: () => Promise<void>;
+  onCMSChange?: (collection: string) => Promise<void>;
 }
 
 export class FileWatcher {
   private componentsWatcher: FSWatcher | null = null;
   private pagesWatcher: FSWatcher | null = null;
   private colorsWatcher: FSWatcher | null = null;
+  private cmsWatcher: FSWatcher | null = null;
   
   constructor(private callbacks: FileWatchCallbacks) {}
   
@@ -98,12 +100,37 @@ export class FileWatcher {
   }
 
   /**
-   * Start watching both directories
+   * Start watching CMS directory
+   * Watches for changes in CMS content files (cms/{collection}/*.json)
+   */
+  watchCMS(dirPath: string = projectPaths.cms()): void {
+    if (!existsSync(dirPath)) {
+      return;
+    }
+
+    this.cmsWatcher = watch(
+      dirPath,
+      { recursive: true },
+      async (event, filename) => {
+        if (filename && filename.endsWith('.json')) {
+          // Extract collection from path: "blog/my-post.json" -> "blog"
+          const collection = filename.split('/')[0];
+          if (this.callbacks.onCMSChange) {
+            await this.callbacks.onCMSChange(collection);
+          }
+        }
+      }
+    );
+  }
+
+  /**
+   * Start watching all directories
    */
   watchAll(): void {
     this.watchComponents();
     this.watchPages();
     this.watchColors();
+    this.watchCMS();
   }
   
   /**
@@ -124,13 +151,18 @@ export class FileWatcher {
       this.colorsWatcher.close();
       this.colorsWatcher = null;
     }
+
+    if (this.cmsWatcher) {
+      this.cmsWatcher.close();
+      this.cmsWatcher = null;
+    }
   }
   
   /**
    * Check if watchers are active
    */
   isWatching(): boolean {
-    return this.componentsWatcher !== null || this.pagesWatcher !== null;
+    return this.componentsWatcher !== null || this.pagesWatcher !== null || this.cmsWatcher !== null;
   }
 }