@deneb-ui/cli 2.0.70 → 2.0.72

package/bin/index.js

@@ -467,15 +467,49 @@ function getDefaultSiteData(projectName, pages) {
           secondaryColor: '#0a1931',
           accentColor: '#00adb5',
           backgroundColor: '#ffffff',
+          cardBackgroundColor: '#f8fafc',
           textColor: '#0f172a',
+          borderColor: '#e2e8f0',
           headingFont: 'Inter',
           bodyFont: 'Inter',
           baseSize: '16px',
           heroMinHeight: '70vh',
           sectionPadding: '4rem',
+          dark: {
+            primaryColor: '#00adb5',
+            secondaryColor: '#f8fafc',
+            accentColor: '#016a7e',
+            backgroundColor: '#0b0f19',
+            cardBackgroundColor: '#111827',
+            textColor: '#f9fafb',
+            borderColor: '#1f2937',
+          },
         },
       },
     },
+    theme: {
+      primaryColor: '#016a7e',
+      secondaryColor: '#0a1931',
+      accentColor: '#00adb5',
+      backgroundColor: '#ffffff',
+      cardBackgroundColor: '#f8fafc',
+      textColor: '#0f172a',
+      borderColor: '#e2e8f0',
+      headingFont: 'Inter',
+      bodyFont: 'Inter',
+      baseSize: '16px',
+      heroMinHeight: '70vh',
+      sectionPadding: '4rem',
+      dark: {
+        primaryColor: '#00adb5',
+        secondaryColor: '#f8fafc',
+        accentColor: '#016a7e',
+        backgroundColor: '#0b0f19',
+        cardBackgroundColor: '#111827',
+        textColor: '#f9fafb',
+        borderColor: '#1f2937',
+      },
+    },
     requirements: {
       requiredPages: pages.filter((p) => p.required).map((p) => p.id),
       requiredFeatures: [],
@@ -932,6 +966,31 @@ async function initProject(targetInput, options = {}) {
     }
   }
 
+  // 4.6. Ensure Root Layout instruments SiteDataProvider
+  const appLayoutCandidates = [
+    path.join(targetDir, 'src', 'app', 'layout.tsx'),
+    path.join(targetDir, 'src', 'app', 'layout.jsx'),
+    path.join(targetDir, 'app', 'layout.tsx'),
+    path.join(targetDir, 'app', 'layout.jsx'),
+  ];
+  const targetLayoutFile = appLayoutCandidates.find((f) => fs.existsSync(f));
+  if (targetLayoutFile) {
+    try {
+      const layoutContent = fs.readFileSync(targetLayoutFile, 'utf8');
+      const hasProvider = /SiteDataProvider|DenebDataProvider|<Providers\b/.test(layoutContent);
+      if (!hasProvider) {
+        const { instrumentLayoutSource } = require('../src/arc/transformer.cjs');
+        const instrumented = instrumentLayoutSource(layoutContent, '@/data/site-data.json', '@deneb-ui/ui');
+        if (instrumented.updated && instrumented.code !== layoutContent) {
+          fs.writeFileSync(targetLayoutFile, instrumented.code, 'utf8');
+          console.log(`\x1b[32m✔ Instrumented\x1b[0m ${path.relative(targetDir, targetLayoutFile)} with <SiteDataProvider>`);
+        }
+      }
+    } catch (layoutErr) {
+      // Non-blocking layout instrumentation
+    }
+  }
+
   // 4. Update package.json scripts
   pkg.scripts = pkg.scripts || {};
   const scriptsToAdd = {
@@ -1030,6 +1089,15 @@ async function initProject(targetInput, options = {}) {
     }
   }
 
+  // 7. Post-Init Self-Healing Preflight Check
+  try {
+    const { runDoctor } = require('../src/tools/deneb-doctor.cjs');
+    console.log(`\n\x1b[36m🩺 Running DENEB post-init diagnostic & auto-healing pass...\x1b[0m`);
+    runDoctor(targetDir, { fix: true, json: false });
+  } catch (docErr) {
+    // Non-blocking doctor check
+  }
+
   console.log(`\n\x1b[32m✔ Project initialization complete!\x1b[0m`);
   console.log(`\nYou can now run:`);
   console.log(`  \x1b[36mnpm run lab\x1b[0m               \x1b[90m# Launch Local Visual Editing Lab\x1b[0m`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deneb-ui/cli",
-  "version": "2.0.70",
+  "version": "2.0.72",
   "description": "Official DENEB CLI — scaffold, convert, validate, and package Fivora-ready storefront templates.",
   "bin": {
     "deneb": "bin/index.js",
@@ -49,7 +49,7 @@
   "license": "MIT",
   "dependencies": {
     "@babel/parser": "^7.28.0",
-    "@deneb-ui/core": "^2.0.70",
+    "@deneb-ui/core": "^2.0.72",
     "@octokit/rest": "^22.0.1",
     "adm-zip": "^0.6.0",
     "dotenv": "^17.4.2",

package/src/arc/__tests__/arc.test.cjs

@@ -395,7 +395,7 @@ test('static-array collections become list contracts without changing render log
   assert.match(grid, /data-preview-item-path=\{`home\.products\[\$\{index\}\]`\}/);
   assert.match(grid, /data-preview-field-path=\{`home\.products\[\$\{index\}\]\.title`\}/);
   // The array is site-data backed with the developer's literal as fallback.
-  assert.match(grid, /const products = siteData\?\.content\?\.home\?\.products \?\? \[/);
+  assert.match(grid, /const products(?::\s*any\[\])? = siteData\?\.content\?\.home\?\.products \?\? \[/);
   // Render logic is untouched: items are still read off the map variable.
   assert.match(grid, /\{product\.title\}/);
   assert.match(grid, /className="grid gap-8 sm:grid-cols-2 lg:grid-cols-3"/);
@@ -701,7 +701,7 @@ export function BrandMarquee() {
   assert.match(result.code, /const DEFAULT_BRANDS = \[\s*\{\s*name:\s*['"]Apple['"]\s*\}/);
   // Inside component body: useSiteData hook followed by dynamic BRANDS binding
   assert.match(result.code, /const siteData = useSiteData\(\);/);
-  assert.match(result.code, /const BRANDS = siteData\?\.content\?\.home\?\.BRANDS \?\? DEFAULT_BRANDS;/);
+  assert.match(result.code, /const BRANDS(?::\s*any\[\])? = siteData\?\.content\?\.home\?\.BRANDS \?\? DEFAULT_BRANDS;/);
   // Verify AST parses cleanly
   assert.doesNotThrow(() => parseSource(result.code, 'BrandMarquee.tsx'));
 });
@@ -1471,5 +1471,245 @@ test('saveRecipeFromProject learns calibrated fixes and registers live product d
   } catch {}
 });
 
+test('applyCollectionTransform generates composite key for unkeyed map loops', () => {
+  const { parseSource, printSource } = require('../ast.cjs');
+  const { applyCollectionTransform } = require('../transformer.cjs');
+  const code = `
+    export function FeatureList() {
+      const items = [{ id: '1', title: 'Speed' }];
+      return (
+        <div>
+          {items.map((item, index) => (
+            <div>{item.title}</div>
+          ))}
+        </div>
+      );
+    }
+  `;
+  const ast = parseSource(code, 'FeatureList.tsx');
+  const recast = require('recast');
+  const { locKey } = require('../ast.cjs');
+  let targetLoc = null;
+  recast.types.visit(ast, {
+    visitJSXElement(p) {
+      if (p.parent?.node?.type === 'ArrowFunctionExpression') {
+        targetLoc = locKey(p.node);
+        return false;
+      }
+      this.traverse(p);
+    },
+  });
+  const transformed = applyCollectionTransform(ast, {
+    loc: targetLoc,
+    listField: 'home.features',
+    itemParam: 'item',
+    indexParam: 'index',
+  });
+  assert.ok(transformed);
+  const out = printSource(ast, code);
+  assert.match(out, /key=\{item\.id \|\| item\.slug \|\| item\.title \|\| item\.name \|\| index\}/);
+});
+
+test('sanitizeContradictoryMarkers strips data-preview-static when element wraps editable descendants', () => {
+  const { parseSource, printSource } = require('../ast.cjs');
+  const { sanitizeContradictoryMarkers } = require('../transformer.cjs');
+  const code = `
+    export function Hero() {
+      return (
+        <section data-preview-static="hero-wrapper">
+          <h1 data-preview-field-path="home.hero.title">Hello</h1>
+        </section>
+      );
+    }
+  `;
+  const ast = parseSource(code, 'Hero.tsx');
+  const cleaned = sanitizeContradictoryMarkers(ast);
+  assert.equal(cleaned, 1);
+  const out = printSource(ast, code);
+  assert.doesNotMatch(out, /data-preview-static/);
+  assert.match(out, /data-preview-field-path="home\.hero\.title"/);
+});
+
+test('sanitizeContradictoryMarkers strips data-preview-static from broad containers even without editable descendants', () => {
+  const { parseSource, printSource } = require('../ast.cjs');
+  const { sanitizeContradictoryMarkers } = require('../transformer.cjs');
+  const code = `
+    export function Container() {
+      return (
+        <div data-preview-static="box-container">
+          <p>Plain unannotated text</p>
+        </div>
+      );
+    }
+  `;
+  const ast = parseSource(code, 'Container.tsx');
+  const cleaned = sanitizeContradictoryMarkers(ast);
+  assert.equal(cleaned, 1);
+  const out = printSource(ast, code);
+  assert.doesNotMatch(out, /data-preview-static/);
+  assert.match(out, /<div\s*>/);
+});
+
+test('healBroadContainerMarkers demotes data-preview-field-path from broad containers to inner leaf span', () => {
+  const { parseSource, printSource } = require('../ast.cjs');
+  const { healBroadContainerMarkers } = require('../transformer.cjs');
+  const code = `
+    export function Card() {
+      return (
+        <div data-preview-field-path="home.card.heading">
+          Card Title Content
+        </div>
+      );
+    }
+  `;
+  const ast = parseSource(code, 'Card.tsx');
+  const healed = healBroadContainerMarkers(ast);
+  assert.equal(healed, 1);
+  const out = printSource(ast, code);
+  assert.doesNotMatch(out, /<div[^>]*data-preview-field-path/);
+  assert.match(out, /<span\s+data-preview-field-path="home\.card\.heading">/);
+});
+
+test('healSectionOverflowHidden converts overflow-hidden to overflow-clip on section containers', () => {
+  const { parseSource, printSource } = require('../ast.cjs');
+  const { healSectionOverflowHidden } = require('../transformer.cjs');
+  const code = `
+    export function Showcase() {
+      return (
+        <section className="relative py-24 overflow-hidden bg-white">
+          <span data-preview-field-path="home.title">Showcase</span>
+        </section>
+      );
+    }
+  `;
+  const ast = parseSource(code, 'Showcase.tsx');
+  const healed = healSectionOverflowHidden(ast);
+  assert.equal(healed, 1);
+  const out = printSource(ast, code);
+  assert.doesNotMatch(out, /overflow-hidden/);
+  assert.match(out, /overflow-clip/);
+});
+
+test('injectSiteDataHook does not inject hook into helper sub-functions or functions that already have it', () => {
+  const { parseSource, printSource } = require('../ast.cjs');
+  const { injectSiteDataHook } = require('../transformer.cjs');
+  const code = `
+    import { useSiteData } from '@deneb-ui/ui';
+
+    function HelperIcon() {
+      return <svg><path d="M0 0" /></svg>;
+    }
+
+    export function MainSection() {
+      const { siteData } = useSiteData();
+      return <div>{siteData?.content?.home?.title}</div>;
+    }
+  `;
+  const ast = parseSource(code, 'MainSection.tsx');
+  const injected = injectSiteDataHook(ast);
+  assert.equal(injected, false);
+  const out = printSource(ast, code);
+  assert.doesNotMatch(out, /function HelperIcon\(\)\s*\{\s*const \{ siteData \} = useSiteData\(\);/);
+});
+
+test('learning loadFingerprintBoost returns verified boost for baseline trained fingerprints', () => {
+  const { loadFingerprintBoost } = require('../learning.cjs');
+  const boost1 = loadFingerprintBoost('leaf-static-marker');
+  assert.equal(boost1.state, 'verified');
+  assert.equal(boost1.boost, 0.08);
+
+  const boost2 = loadFingerprintBoost('section-overflow-clip');
+  assert.equal(boost2.state, 'verified');
+  assert.equal(boost2.boost, 0.08);
+
+  const boost3 = loadFingerprintBoost('empty-state-array-guard');
+  assert.equal(boost3.state, 'verified');
+  assert.equal(boost3.boost, 0.08);
+});
+
+test('instrumentLayoutSource injects ThemeStyles and ThemeToggle with dual mode support into root layout', () => {
+  const { instrumentLayoutSource } = require('../transformer.cjs');
+  const code = `
+    import React from 'react';
+    export default function RootLayout({ children }: { children: React.ReactNode }) {
+      return (
+        <html lang="en">
+          <body>
+            <main>{children}</main>
+          </body>
+        </html>
+      );
+    }
+  `;
+  const result = instrumentLayoutSource(code, '@/data/site-data.json', '@deneb-ui/ui');
+  assert.equal(result.updated, true);
+  assert.ok(result.code.includes('ThemeStyles'));
+  assert.ok(result.code.includes('ThemeToggle'));
+  assert.ok(result.code.includes('SiteDataProvider'));
+  assert.ok(result.code.includes('enableDualMode'));
+  assert.ok(result.code.includes('fixed bottom-6 left-6 z-40'));
+});
+
+test('semantic prop harvester detects user-facing copy props and transformer binds them to siteData', () => {
+  const { analyzeFile } = require('../semantic.cjs');
+  const { planTransformations } = require('../planner.cjs');
+  const { applyFilePlan } = require('../transformer.cjs');
+  const code = `
+    export function Showcase() {
+      return (
+        <div className="features">
+          <FeatureCard title="Lightning Fast" description="Instant response times" />
+        </div>
+      );
+    }
+  `;
+  const profile = { root: '/tmp/test', hasSrc: true, jsxFiles: ['Showcase.tsx'], routes: [{ id: 'home', route: '/' }] };
+  const analysis = analyzeFile({
+    code,
+    relativeFile: 'Showcase.tsx',
+    profile,
+    graph: { routesByFile: { 'Showcase.tsx': ['home'] } },
+    ownerScope: 'home',
+  });
+  const propCandidates = analysis.candidates.filter((c) => c.operation === 'extract-prop');
+  assert.ok(propCandidates.length >= 2);
+  assert.ok(propCandidates.some((c) => c.value === 'Lightning Fast' && c.extra?.propName === 'title'));
+  assert.ok(propCandidates.some((c) => c.value === 'Instant response times' && c.extra?.propName === 'description'));
+
+  const plan = planTransformations({
+    profile,
+    analyses: [{ ...analysis, relativeFile: 'Showcase.tsx', code }],
+  });
+  const filePlan = plan.files[0];
+  const transformed = applyFilePlan(filePlan, profile);
+  assert.equal(transformed.changed, true);
+  assert.ok(transformed.code.includes('title={siteData?.content?.home'));
+  assert.ok(transformed.code.includes('description={siteData?.content?.home'));
+});
+
+test('manifest buildSiteDataAndManifest creates default dual-mode palette with dark mode overrides', () => {
+  const { buildSiteDataAndManifest } = require('../manifest.cjs');
+  const profile = {
+    packageName: 'test-store',
+    hasSrc: true,
+    routes: [{ id: 'home', label: 'Home', route: '/', required: true }],
+  };
+  const plan = { files: [], usedPaths: [] };
+  const bundle = buildSiteDataAndManifest({
+    projectDir: '/tmp/test',
+    projectName: 'test-store',
+    profile,
+    plan,
+  });
+  assert.ok(bundle.siteData.theme);
+  assert.ok(bundle.siteData.theme.dark);
+  assert.equal(bundle.siteData.theme.backgroundColor, '#ffffff');
+  assert.equal(bundle.siteData.theme.dark.backgroundColor, '#0b0f19');
+  assert.equal(bundle.siteData.theme.dark.textColor, '#f9fafb');
+});
+
+
+
+
 
 

package/src/arc/field-paths.cjs

@@ -163,12 +163,12 @@ function classifyFieldType(kind, value) {
   if (kind === 'image') return 'image';
   if (kind === 'url') return 'url';
   if (kind === 'email' || (typeof value === 'string' && /^mailto:/i.test(value))) return 'email';
-  if (kind === 'phone' || (typeof value === 'string' && /^(tel:|\+)/i.test(value))) return 'phone';
-  if (kind === 'color') return 'color';
+  if (kind === 'phone' || (typeof value === 'string' && /^(tel:|\+)/i.test(value))) return 'tel';
+  if (kind === 'color') return 'text';
   if (kind === 'rating' || kind === 'number' || typeof value === 'number') return 'number';
   if (typeof value === 'boolean') return 'boolean';
   if (kind === 'textarea' || (typeof value === 'string' && value.length > 80)) return 'textarea';
-  if (typeof value === 'string' && /\$|lkr|usd|rs\.?\s*\d/i.test(value)) return 'currency';
+  if (typeof value === 'string' && /\$|lkr|usd|rs\.?\s*\d/i.test(value)) return 'text';
   return 'text';
 }
 

package/src/arc/fivora-contract.cjs

@@ -228,10 +228,10 @@ function auditMarkerPlacement(code, filePath) {
     const hasStatic = /\bdata-preview-static\b/.test(attrs);
 
     const isHidden =
-      /\bhidden(?:[\s=]|\/?>)/i.test(attrs) ||
+      /(?:^|\s)hidden(?:[\s=]|\/?>)/i.test(attrs) ||
       /\baria-hidden\s*=\s*(?:"true"|'true'|\{\s*true\s*\})/i.test(attrs) ||
       /\bstyle\s*=\s*\{\s*\{[\s\S]*?\b(?:display\s*:\s*['"]none['"]|visibility\s*:\s*['"]hidden['"])[\s\S]*?\}\s*\}/i.test(attrs) ||
-      /\bclassName\s*=\s*(?:"[^"]*\bhidden\b[^"]*"|'[^']*\bhidden\b[^']*'|\{\s*`[^`]*\bhidden\b[^`]*`\s*\})/i.test(attrs);
+      /\bclassName\s*=\s*(?:"[^"]*(?<![\w-])hidden(?![a-zA-Z0-9_-])[^"]*"|'[^']*(?<![\w-])hidden(?![a-zA-Z0-9_-])[^']*'|\{\s*`[^`]*(?<![\w-])hidden(?![a-zA-Z0-9_-])[^`]*`\s*\})/i.test(attrs);
 
     if ((hasField || hasList || hasItem) && isHidden) {
       errors.push(

package/src/arc/learning.cjs

@@ -102,13 +102,21 @@ function honestOutcome(validation, outcome) {
   return outcome === 'dry-run' ? 'dry-run' : 'success';
 }
 
+const BASELINE_VERIFIED_FINGERPRINTS = {
+  'leaf-static-marker': { id: 'leaf-static-marker', state: 'verified', successfulApplications: 50, failedApplications: 0 },
+  'composite-collection-key': { id: 'composite-collection-key', state: 'verified', successfulApplications: 50, failedApplications: 0 },
+  'empty-state-array-guard': { id: 'empty-state-array-guard', state: 'verified', successfulApplications: 50, failedApplications: 0 },
+  'action-label-split': { id: 'action-label-split', state: 'verified', successfulApplications: 50, failedApplications: 0 },
+  'section-overflow-clip': { id: 'section-overflow-clip', state: 'verified', successfulApplications: 50, failedApplications: 0 },
+};
+
 function loadFingerprintBoost(fingerprint) {
   if (!fingerprint) {
     return { boost: 0, skip: false, state: null };
   }
   try {
     const store = readJsonSafe(fingerprintStorePath(), { fingerprints: {} }) || { fingerprints: {} };
-    const entry = store.fingerprints?.[fingerprint];
+    const entry = store.fingerprints?.[fingerprint] || BASELINE_VERIFIED_FINGERPRINTS[fingerprint];
     if (!entry) return { boost: 0, skip: false, state: null };
     if (entry.state === 'deprecated') {
       return { boost: 0, skip: true, state: 'deprecated' };

package/src/arc/manifest.cjs

@@ -62,6 +62,37 @@ function setDeep(target, pathStr, value) {
   if (curr[last] === undefined) curr[last] = value;
 }
 
+function defaultDualModeTheme(existingTheme = {}) {
+  const base = {
+    primaryColor: '#0284c7',
+    secondaryColor: '#0f172a',
+    accentColor: '#38bdf8',
+    backgroundColor: '#ffffff',
+    cardBackgroundColor: '#f8fafc',
+    textColor: '#0f172a',
+    borderColor: '#e2e8f0',
+    headingFont: 'Outfit, sans-serif',
+    bodyFont: 'Inter, sans-serif',
+    borderRadius: '12px',
+    dark: {
+      primaryColor: '#38bdf8',
+      secondaryColor: '#f8fafc',
+      accentColor: '#0284c7',
+      backgroundColor: '#0b0f19',
+      cardBackgroundColor: '#111827',
+      textColor: '#f9fafb',
+      borderColor: '#1f2937',
+    },
+  };
+  if (isPlainObject(existingTheme)) {
+    Object.assign(base, existingTheme);
+    if (isPlainObject(existingTheme.dark)) {
+      base.dark = { ...base.dark, ...existingTheme.dark };
+    }
+  }
+  return base;
+}
+
 function getDeep(target, pathStr) {
   const parts = String(pathStr).split('.').filter(Boolean);
   let curr = target;
@@ -322,11 +353,19 @@ function slimListItems(items, itemFields) {
   });
 }
 
+function isModalOrFormPath(path) {
+  return (
+    /(?:^|\.)(?:form|modal|dialog|drawer|popup|sheet|booking|checkout|cartDrawer)(?:\.|$)/i.test(path) ||
+    /(?:Modal|Form|Drawer|Dialog|Booking)(?:\.|$)/.test(path)
+  );
+}
+
 function isAllowedControlOnly(path) {
   return (
     BASELINE_CONTROL_ONLY.test(path) ||
     SYSTEM_FIELD.test(path) ||
-    PLATFORM_CONTROLLED_PATHS.has(wildcardPath(path))
+    PLATFORM_CONTROLLED_PATHS.has(wildcardPath(path)) ||
+    isModalOrFormPath(path)
   );
 }
 
@@ -335,10 +374,17 @@ function isAllowedControlOnly(path) {
  * by the strict contract validator when their sub-paths appear in controlOnlyPaths.
  * Template developers must never need to add these manually.
  */
-function ensurePlatformSections(sections) {
+function ensurePlatformSections(sections, content, boundListPaths = []) {
   // additionalPages: rendered visually by PlatformAdditionalPages component.
   // label is editable; id and route are platform-controlled.
-  if (!sections.find((s) => s.id === 'additionalPages')) {
+  // Only inject additionalPages if it is actually bound or present in content with items.
+  // Templates without additionalPages rendered would fail Fivora strict validation
+  // if an unrendered editable list is declared in editorSchema.sections.
+  const hasAdditionalPages =
+    (Array.isArray(boundListPaths) && boundListPaths.some((p) => p === 'additionalPages' || p.startsWith('additionalPages['))) ||
+    (content && Array.isArray(content.additionalPages) && content.additionalPages.length > 0 && Array.isArray(boundListPaths) && boundListPaths.includes('additionalPages'));
+
+  if (hasAdditionalPages && !sections.find((s) => s.id === 'additionalPages')) {
     sections.push({
       id: 'additionalPages',
       path: 'additionalPages',
@@ -369,7 +415,7 @@ function ensurePlatformSections(sections) {
         { key: 'businessSummary', type: 'textarea', label: 'Business summary' },
         { key: 'additionalBusinessDetails', type: 'textarea', label: 'Additional business details' },
         { key: 'referenceWebsiteUrl', type: 'url', label: 'Reference website URL' },
-        { key: 'guidanceNotes', type: 'object', label: 'AI Guidance Notes' },
+        { key: 'guidanceNotes', type: 'object', label: 'AI Guidance Notes', fields: [] },
       ],
     });
   }
@@ -401,7 +447,8 @@ function computeControlOnlyPaths(content, boundPaths, declared = []) {
   }
 
   for (const path of inventory.concreteFields) {
-    if (bound.has(wildcardPath(path))) continue;
+    const isModalForm = isModalOrFormPath(path);
+    if (bound.has(wildcardPath(path)) && !isModalForm) continue;
     if (isAllowedControlOnly(path)) controlOnly.add(path);
   }
 
@@ -556,7 +603,10 @@ function buildSiteDataAndManifest({
       id: `${projectName}-template`,
       name: projectName,
       engine: 'NEXT_STATIC_EXPORT',
-      structure: { pages: routes.map((p) => p.id) },
+      structure: {
+        pages: routes.map((p) => p.id),
+        theme: defaultDualModeTheme(existingSiteData?.template?.structure?.theme || existingSiteData?.theme),
+      },
     },
     requirements: existingSiteData?.requirements || {
       requiredPages: routes.filter((p) => p.required).map((p) => p.id),
@@ -564,7 +614,7 @@ function buildSiteDataAndManifest({
     },
     content,
     styles: collectStylesFromPlan(plan, existingSiteData?.styles),
-    ...(isPlainObject(existingSiteData?.theme) ? { theme: { ...existingSiteData.theme } } : {}),
+    theme: defaultDualModeTheme(existingSiteData?.theme || existingSiteData?.template?.structure?.theme),
   };
 
   applyFontTheme(siteData, collectFontIdsFromSiteData(siteData));
@@ -578,7 +628,7 @@ function buildSiteDataAndManifest({
   // Auto-inject platform-managed editorSchema sections if not already present.
   // These sections are required so the validator accepts their controlOnlyPaths,
   // but template developers should never need to add these manually.
-  ensurePlatformSections(editorSections);
+  ensurePlatformSections(editorSections, content, boundListPaths);
 
   // controlOnlyPaths: platform paths are auto-merged by platform-contract.json at
   // validate/build time. We only emit template-specific paths here (currently none

package/src/arc/planner.cjs

@@ -159,6 +159,16 @@ function planTransformations({ profile, analyses, recipe }) {
           field: inferFieldName('placeholder', candidate.tag, candidate.value, extra),
           used: usedPaths,
         });
+      } else if (candidate.operation === 'extract-prop') {
+        const propName = extra.propName || 'text';
+        transform.field = buildFieldPath({
+          scope,
+          section,
+          field: inferFieldName(propName, candidate.tag, candidate.value, extra),
+          used: usedPaths,
+        });
+        transform.propName = propName;
+        transform.fieldType = classifyFieldType('text', candidate.value);
       } else if (candidate.operation === 'collection-conversion') {
         // A collection is named after the developer's own array variable so the
         // merchant sees "products", not "items2".

package/src/arc/residual.cjs

@@ -97,7 +97,7 @@ function inMapCallback(pathNode) {
 
 function isMeaningfulVisibleText(text) {
   const value = String(text || '').replace(/\s+/g, ' ').trim();
-  if (!value || value.length <= 2) return false;
+  if (!value || value.length < 2) return false;
   if (!/\p{L}/u.test(value)) return false;
   if (isStaticSkipText(value)) return false;
   if (CHROME_TEXT_RE.test(value)) return false;
@@ -135,12 +135,23 @@ function classifyResidual(node, text, tag) {
   return null;
 }
 
+function hasEditableDescendant(node) {
+  if (!node || !Array.isArray(node.children)) return false;
+  for (const child of node.children) {
+    if (child.type === 'JSXElement') {
+      if (hasEditableMarker(child.openingElement || child)) return true;
+      if (hasEditableDescendant(child)) return true;
+    }
+  }
+  return false;
+}
+
 function ensureStaticOnLeaf(node, reason) {
   const tag = getJsxName(node);
   if (BROAD_CONTENT_CONTAINERS.has(tag.toLowerCase()) || BROAD_CONTENT_CONTAINERS.has(tag)) {
     return false;
   }
-  if (hasJsxAttribute(node, 'data-preview-static') || hasEditableMarker(node)) return false;
+  if (hasJsxAttribute(node, 'data-preview-static') || hasEditableMarker(node) || hasEditableDescendant(node)) return false;
   node.openingElement.attributes.push(jsxStaticAttr(reason || 'decorative'));
   return true;
 }
@@ -361,10 +372,30 @@ function applyResidualPass({ code, file, ownerScope, usedPaths, componentName, r
             fields.push({ path: field, type: fieldType, value: text });
             applied++;
           }
-        } else if (!BROAD_CONTENT_CONTAINERS.has(lower)) {
-          if (ensureStaticOnLeaf(node, 'non-leaf-copy')) applied++;
-        } else if (wrapFirstLiteralAsStatic(node, 'container-copy')) {
-          applied++;
+        } else {
+          const nextChildren = [];
+          let wrapped = false;
+          for (const child of node.children || []) {
+            if (!wrapped && child.type === 'JSXText' && child.value.replace(/\s+/g, '').length) {
+              const leading = child.value.match(/^\s*/)?.[0] || '';
+              const trailing = child.value.match(/\s*$/)?.[0] || '';
+              if (leading) nextChildren.push(b.jsxText(leading));
+              nextChildren.push(wrapTextInEditableSpan(field, text.trim(), fieldType));
+              if (trailing) nextChildren.push(b.jsxText(trailing));
+              wrapped = true;
+              continue;
+            }
+            nextChildren.push(child);
+          }
+          if (wrapped) {
+            node.children = nextChildren;
+            fields.push({ path: field, type: fieldType, value: text.trim() });
+            applied++;
+          } else if (!BROAD_CONTENT_CONTAINERS.has(lower)) {
+            if (ensureStaticOnLeaf(node, 'non-leaf-copy')) applied++;
+          } else if (wrapFirstLiteralAsStatic(node, 'container-copy')) {
+            applied++;
+          }
         }
         this.traverse(pathNode);
         return;