@deneb-ui/cli 2.0.49 → 2.0.50

package/bin/index.js

@@ -233,8 +233,15 @@ function detectPages(projectDir) {
     }
   }
 
-  const hasContact = pages.some((p) => p.id === 'contact' || p.route === '/contact');
-  if (!hasContact) {
+  const contactExistsOnDisk = candidateDirs.some((cDir) =>
+    fs.existsSync(path.join(cDir, 'contact.tsx')) ||
+    fs.existsSync(path.join(cDir, 'contact.jsx')) ||
+    fs.existsSync(path.join(cDir, 'contact.js')) ||
+    fs.existsSync(path.join(cDir, 'contact', 'page.tsx')) ||
+    fs.existsSync(path.join(cDir, 'contact', 'page.jsx')) ||
+    fs.existsSync(path.join(cDir, 'contact', 'page.js'))
+  );
+  if (contactExistsOnDisk && !pages.some((p) => p.id === 'contact' || p.route === '/contact')) {
     pages.push({ id: 'contact', label: 'Contact', route: '/contact', required: true });
   }
 
@@ -597,7 +604,7 @@ function getComponentRegistry(importPkg) {
   };
 }
 
-function initProject(targetInput, options = {}) {
+async function initProject(targetInput, options = {}) {
   const targetDir = path.resolve(process.cwd(), targetInput || '.');
   const pkgPath = path.join(targetDir, 'package.json');
 
@@ -645,7 +652,7 @@ function initProject(targetInput, options = {}) {
       conversionRes = runUniversalTemplateConversion(targetDir, projectName, detectedPages, options);
     } else {
       const { runDenebArc } = require('../src/arc/index.cjs');
-      conversionRes = runDenebArc(targetDir, projectName, {
+      conversionRes = await runDenebArc(targetDir, projectName, {
         ...options,
         detectedPages,
       });
@@ -1048,7 +1055,10 @@ if (command === 'init') {
       targetInput = arg;
     }
   }
-  initProject(targetInput, { recipeName, dryRun, explain, legacy, telemetry, aiEnabled, aiDryRun });
+  initProject(targetInput, { recipeName, dryRun, explain, legacy, telemetry, aiEnabled, aiDryRun }).catch((err) => {
+    console.error(`\x1b[31mError:\x1b[0m ${err.message}`);
+    process.exit(1);
+  });
 } else if (command === 'create') {
   createTemplate(commandArgs[0]);
 } else if (command === 'add') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deneb-ui/cli",
-  "version": "2.0.49",
+  "version": "2.0.50",
   "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.49",
+    "@deneb-ui/core": "^2.0.50",
     "@octokit/rest": "^22.0.1",
     "adm-zip": "^0.6.0",
     "dotenv": "^17.4.2",

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

@@ -16,6 +16,8 @@ const { runDenebArc } = require('../index.cjs');
 const { parseSource } = require('../ast.cjs');
 const { loadFingerprintBoost } = require('../learning.cjs');
 const { classifyActionIntent } = require('../adapters.cjs');
+const { validateGeneratedCode } = require('../ai-agent.cjs');
+const { auditRuntimeIntegrity, healRuntimeIntegrity, runAiEvaluatorPipeline } = require('../ai-evaluator.cjs');
 
 test('field-paths recognizes list action CTA keys', () => {
   assert.equal(isListActionCtaKey('preOrderCta'), true);
@@ -875,3 +877,341 @@ export function ActionPage() {
   assert.deepEqual(errors, []);
 });
 
+test('parseSource parses TypeScript interface declarations without experimental syntax errors', () => {
+  const tsCode = `
+import React from 'react';
+import { EditableText } from './EditableText';
+
+export interface EditableTradeinSectionProps {
+  itemPath: string;
+  title: string;
+}
+
+export function EditableTradeinSection({ itemPath, title }: EditableTradeinSectionProps) {
+  return (
+    <div data-preview-item-path={itemPath}>
+      <EditableText as="h2" id={\`\${itemPath}.title\`} data-preview-field-path={\`\${itemPath}.title\`} defaultValue={title} />
+    </div>
+  );
+}
+`;
+  assert.doesNotThrow(() => {
+    parseSource(tsCode, 'EditableTradeinSection.tsx');
+  });
+});
+
+test('validateGeneratedCode catches data-preview-field-path placed on broad <div> containers', () => {
+  const invalidCode = `
+import React from 'react';
+import { EditableText } from './EditableText';
+
+export interface EditableCardProps {
+  itemPath: string;
+}
+
+export function EditableCard({ itemPath }: EditableCardProps) {
+  return (
+    <div data-preview-item-path={itemPath}>
+      <div data-preview-field-path={\`\${itemPath}.content\`}>Some broad content</div>
+    </div>
+  );
+}
+`;
+  const res = validateGeneratedCode(invalidCode, 'EditableCard.tsx');
+  assert.equal(res.passed, false);
+  assert.ok(res.errors.some((e) => e.includes('cannot be placed on broad <div> content containers')));
+});
+
+test('AST transformer wraps literal text inside <div> with <span> instead of placing field path on <div>', () => {
+  const code = `
+export function Card() {
+  return (
+    <div className="card">
+      <div className="title-row">In-Store VIP Lab</div>
+    </div>
+  );
+}
+`;
+  const profile = {
+    root: os.tmpdir(),
+    framework: 'nextjs',
+    router: 'next-app',
+    language: 'typescript',
+    cssSystems: ['tailwind'],
+    hasSrc: true,
+    aliasMap: { '@/*': ['src/*'] },
+  };
+
+  const analysis = analyzeFile({
+    code,
+    relativeFile: 'src/components/Card.tsx',
+    profile,
+    graph: { sharedFiles: [] },
+    ownerScope: 'home',
+    componentMeta: { name: 'Card', role: 'card' },
+  });
+  analysis.code = code;
+  analysis.relativeFile = 'src/components/Card.tsx';
+
+  const plan = planTransformations({ profile, analyses: [analysis] });
+  const res = applyFilePlan(plan.files[0], profile);
+  assert.equal(res.changed, true);
+  // The outer <div> must NOT have data-preview-field-path
+  assert.doesNotMatch(res.code, /<div[^>]*data-preview-field-path/);
+  // The inner text must be wrapped in a <span> with data-preview-field-path
+  assert.match(res.code, /<span[^>]*data-preview-field-path=/);
+});
+
+test('AI Evaluator audits and heals RSC duplicate SiteDataProvider in layout.tsx', async () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-eval-'));
+  const appDir = path.join(tmp, 'src', 'app');
+  fs.mkdirSync(appDir, { recursive: true });
+
+  const brokenLayout = `
+import { SiteDataProvider } from '@deneb-ui/ui';
+import { Providers } from '@/components/providers';
+import initialSiteData from '@/data/site-data.json';
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body>
+        <Providers>
+          <SiteDataProvider initialSiteData={initialSiteData}>
+            {children}
+          </SiteDataProvider>
+        </Providers>
+      </body>
+    </html>
+  );
+}
+`;
+  fs.writeFileSync(path.join(appDir, 'layout.tsx'), brokenLayout, 'utf8');
+
+  const profile = {
+    root: tmp,
+    framework: 'nextjs',
+    router: 'next-app',
+    appDir: 'src/app',
+    language: 'typescript',
+    jsxFiles: ['src/app/layout.tsx'],
+  };
+
+  const issues = auditRuntimeIntegrity(tmp, profile);
+  assert.equal(issues.length, 1);
+  assert.equal(issues[0].type, 'rsc-duplicate-provider');
+
+  const healRes = await healRuntimeIntegrity(tmp, profile, issues);
+  assert.equal(healRes.healedCount, 1);
+  assert.equal(healRes.remainingCount, 0);
+
+  const fixed = fs.readFileSync(path.join(appDir, 'layout.tsx'), 'utf8');
+  assert.doesNotMatch(fixed, /<SiteDataProvider/);
+  assert.match(fixed, /<Providers>\s*\{children\}\s*<\/Providers>/);
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+test('AI Evaluator detects missing component exports in page.tsx imports', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-eval-exp-'));
+  const appDir = path.join(tmp, 'src', 'app');
+  const compDir = path.join(tmp, 'src', 'components');
+  fs.mkdirSync(appDir, { recursive: true });
+  fs.mkdirSync(compDir, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(appDir, 'page.tsx'),
+    `import { ProductList, MissingHero } from '@/components/Widgets';\nexport default function Page() { return <div><ProductList /></div>; }`,
+    'utf8'
+  );
+
+  fs.writeFileSync(
+    path.join(compDir, 'Widgets.tsx'),
+    `export function ProductList() { return <div>Products</div>; }`,
+    'utf8'
+  );
+
+  const profile = {
+    root: tmp,
+    framework: 'nextjs',
+    router: 'next-app',
+    appDir: 'src/app',
+    language: 'typescript',
+    jsxFiles: ['src/app/page.tsx', 'src/components/Widgets.tsx'],
+  };
+
+  const issues = auditRuntimeIntegrity(tmp, profile);
+  assert.equal(issues.length, 1);
+  assert.equal(issues[0].type, 'missing-named-export');
+  assert.equal(issues[0].meta?.componentName, 'MissingHero');
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+test('AI Evaluator runAiEvaluatorPipeline passes on clean valid project', async () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-eval-clean-'));
+  const appDir = path.join(tmp, 'src', 'app');
+  fs.mkdirSync(appDir, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(appDir, 'layout.tsx'),
+    `import { Providers } from '@/components/providers';\nexport default function RootLayout({ children }: { children: React.ReactNode }) { return <html><body><Providers>{children}</Providers></body></html>; }`,
+    'utf8'
+  );
+
+  const profile = {
+    root: tmp,
+    framework: 'nextjs',
+    router: 'next-app',
+    appDir: 'src/app',
+    language: 'typescript',
+    jsxFiles: ['src/app/layout.tsx'],
+  };
+
+  const res = await runAiEvaluatorPipeline(tmp, profile);
+  assert.equal(res.passed, true);
+  assert.equal(res.issuesFound, 0);
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+test('AI Evaluator audits and heals missing global CSS stylesheet import in layout.tsx', async () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-eval-css-'));
+  const appDir = path.join(tmp, 'src', 'app');
+  fs.mkdirSync(appDir, { recursive: true });
+  fs.writeFileSync(path.join(appDir, 'globals.css'), '@import "tailwindcss";', 'utf8');
+
+  const unstyledLayout = `
+import { Providers } from '@/components/providers';
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return <html><body><Providers>{children}</Providers></body></html>;
+}
+`;
+  fs.writeFileSync(path.join(appDir, 'layout.tsx'), unstyledLayout, 'utf8');
+
+  const profile = {
+    root: tmp,
+    framework: 'nextjs',
+    router: 'next-app',
+    appDir: 'src/app',
+    language: 'typescript',
+    jsxFiles: ['src/app/layout.tsx'],
+  };
+
+  const issues = auditRuntimeIntegrity(tmp, profile);
+  assert.equal(issues.length, 1);
+  assert.equal(issues[0].type, 'missing-global-css-import');
+
+  const healRes = await healRuntimeIntegrity(tmp, profile, issues);
+  assert.equal(healRes.healedCount, 1);
+
+  const fixed = fs.readFileSync(path.join(appDir, 'layout.tsx'), 'utf8');
+  assert.match(fixed, /import\s+['"]\.\/globals\.css['"]/);
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+test('collections with nested arrays, objects, and TS as const convert to editable list contracts', () => {
+  const code = `
+const phones = [
+  {
+    name: 'iPhone 16 Pro Max',
+    brand: 'Apple',
+    subtitle: 'Grade 5 Titanium' as const,
+    price: 1199,
+    storageOptions: ['256GB', '512GB', '1TB'],
+    colors: [{ name: 'Desert Titanium', hex: '#bba795' }],
+  },
+  {
+    name: 'Galaxy S25 Ultra',
+    brand: 'Samsung',
+    subtitle: 'Armor Titanium' as const,
+    price: 1299,
+    storageOptions: ['256GB', '512GB'],
+    colors: [{ name: 'Titanium Gray', hex: '#5e6166' }],
+  },
+];
+
+export function FeaturedPhones() {
+  return (
+    <div className="phones-grid">
+      {phones.map((phone, idx) => (
+        <div key={phone.name} className="phone-card">
+          <h4>{phone.brand}</h4>
+          <h3>{phone.name}</h3>
+          <p>{phone.subtitle}</p>
+          <span>Rs {phone.price}</span>
+        </div>
+      ))}
+    </div>
+  );
+}
+`;
+
+  const profile = { framework: 'nextjs', router: 'next-app', appDir: 'src/app', language: 'typescript' };
+  const analysis = analyzeFile({
+    code,
+    relativeFile: 'src/components/FeaturedPhones.tsx',
+    profile,
+    graph: { sharedFiles: [] },
+    ownerScope: 'home',
+    componentMeta: { name: 'FeaturedPhones', role: 'shop' },
+  });
+
+  const collectionCandidate = analysis.candidates.find((c) => c.kind === 'collection');
+  assert.ok(collectionCandidate, 'collection with nested arrays and TS as const must be detected');
+  assert.equal(collectionCandidate.extra.objectItems, true);
+  assert.ok(collectionCandidate.confidence >= 0.8, 'collection must have high confidence');
+
+  const plan = planTransformations({
+    profile,
+    analyses: [analysis],
+  });
+
+  assert.equal(plan.files.length, 1);
+  const collectionTransform = plan.files[0].transformations.find((t) => t.fieldType === 'list');
+  assert.ok(collectionTransform, 'collection must be planned as list field');
+  assert.equal(collectionTransform.listField, 'home.phones');
+  assert.ok(collectionTransform.itemFields.some((f) => f.key === 'name'));
+  assert.ok(collectionTransform.itemFields.some((f) => f.key === 'price'));
+});
+
+test('proceed to order button is recognized as WhatsApp order split-action contract', () => {
+  const code = `
+export function CartDrawer() {
+  return (
+    <div className="cart-footer">
+      <button type="button" className="btn-primary w-full py-4 font-bold">
+        Proceed to Order · RS 1299
+      </button>
+    </div>
+  );
+}
+`;
+
+  const profile = { framework: 'nextjs', router: 'next-app', appDir: 'src/app', language: 'typescript' };
+  const analysis = analyzeFile({
+    code,
+    relativeFile: 'src/components/CartDrawer.tsx',
+    profile,
+    graph: { sharedFiles: [] },
+    ownerScope: 'home',
+    componentMeta: { name: 'CartDrawer', role: 'cart' },
+  });
+
+  const actionCandidate = analysis.candidates.find((c) => c.kind === 'split-action-contract');
+  assert.ok(actionCandidate, 'proceed to order must be recognized as split-action-contract');
+  assert.equal(actionCandidate.extra.action, 'whatsapp');
+
+  const plan = planTransformations({
+    profile,
+    analyses: [analysis],
+  });
+
+  const filePlan = plan.files[0];
+  const splitAction = filePlan.transformations.find((t) => t.operation === 'split-action-contract');
+  assert.ok(splitAction, 'split action must be planned');
+  assert.match(splitAction.urlField, /whatsapp/i);
+});
+

package/src/arc/adapters.cjs

@@ -193,7 +193,11 @@ function classifyActionIntent(text, href) {
   const h = String(href || '').trim().toLowerCase();
 
   // 1. WhatsApp
-  if (/wa\.me|whatsapp/i.test(h) || /\b(?:whatsapp|wa\.me)\b/i.test(t) || /order on whatsapp|chat on whatsapp|message on whatsapp/i.test(t)) {
+  if (
+    /wa\.me|whatsapp/i.test(h) ||
+    /\b(?:whatsapp|wa\.me)\b/i.test(t) ||
+    /order on whatsapp|chat on whatsapp|message on whatsapp|whatsapp order|order via whatsapp|proceed to order|proceed to checkout|complete order|confirm priority repair|book repair|schedule repair|confirm repair/i.test(t)
+  ) {
     return {
       action: 'whatsapp',
       defaultUrl: /^https?:\/\//i.test(h) && !h.includes('#') ? href : 'https://wa.me/1234567890',

package/src/arc/ai-agent.cjs

@@ -167,6 +167,12 @@ function validateGeneratedCode(code, filename) {
     errors.push('Missing data-preview-field-path markers — the component has no editable fields.');
   }
 
+  // 2b. data-preview-field-path cannot be placed on broad containers
+  const broadMatch = code.match(/<(div|section|article|aside|header|footer|nav|main|form|ul|ol|table|thead|tbody|tr)\b[^>]*\bdata-preview-field-path\s*=/i);
+  if (broadMatch) {
+    errors.push(`data-preview-field-path cannot be placed on broad <${broadMatch[1]}> content containers. Put the marker on the exact visible text, media, link, or control element (like <span>, <p>, <h1>, <a>, <button>, or <EditableText>).`);
+  }
+
   // 3. Must have data-preview-item-path on the root wrapper
   if (!code.includes('data-preview-item-path')) {
     errors.push('Missing data-preview-item-path on root wrapper element.');

package/src/arc/ai-evaluator.cjs

@@ -0,0 +1,450 @@
+'use strict';
+
+/**
+ * Deneb ARC — AI Evaluator & Self-Healing Engine
+ *
+ * Automatically audits the transformed project before finalizing `deneb init --ai`
+ * to guarantee that:
+ * 1. React Server Components (RSC) vs Client Component boundaries are strictly respected
+ *    (preventing "Element type is invalid: expected string/function but got: undefined").
+ * 2. Every imported component in page.tsx/layout.tsx is properly exported.
+ * 3. Fivora strict leaf contracts are satisfied (no field-path on broad containers).
+ * 4. Manifest routes correspond 1:1 with real page files on disk.
+ * 5. Uses ChatGPT (OpenAI API) to evaluate, explain, and self-heal any edge cases.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { parseSource, printSource, getJsxName, b } = require('./ast.cjs');
+const { BROAD_CONTENT_CONTAINERS } = require('./fivora-contract.cjs');
+const { callOpenAI, checkAiReady, loadEnv } = require('./ai-agent.cjs');
+const { recordEvaluatorFix } = require('./learning.cjs');
+
+/**
+ * Audit runtime integrity of the transformed project.
+ *
+ * @param {string} projectDir - Root path of the project being transformed
+ * @param {object} profile - Project profile from scanner.cjs
+ * @returns {Array<{ type: string, file: string, message: string, severity: 'error' | 'warning', meta?: any }>}
+ */
+function auditRuntimeIntegrity(projectDir, profile) {
+  const issues = [];
+
+  // 1. Check RSC Provider Boundaries in layout.tsx
+  const layoutFile = profile.appDir ? path.join(projectDir, 'src', 'app', 'layout.tsx') : null;
+  const altLayout = profile.appDir ? path.join(projectDir, 'app', 'layout.tsx') : null;
+  const targetLayout = (layoutFile && fs.existsSync(layoutFile)) ? layoutFile : ((altLayout && fs.existsSync(altLayout)) ? altLayout : null);
+
+  if (targetLayout) {
+    const layoutCode = fs.readFileSync(targetLayout, 'utf8');
+    const isServerComponent = !/['"]use client['"]/.test(layoutCode.slice(0, 300));
+
+    if (isServerComponent) {
+      // Check if client-only SiteDataProvider or createContext is directly rendered in Server Component
+      const hasSiteDataImport = /import\s+.*?\bSiteDataProvider\b.*?from\s+['"]@deneb-ui\/(?:ui|core)['"]/.test(layoutCode);
+      const rendersSiteDataProvider = /<SiteDataProvider\b/.test(layoutCode);
+      const hasProvidersWrapper = /<Providers\b/.test(layoutCode) || /from\s+['"]@\/components\/providers['"]/.test(layoutCode);
+
+      if (rendersSiteDataProvider && hasProvidersWrapper) {
+        issues.push({
+          type: 'rsc-duplicate-provider',
+          file: path.relative(projectDir, targetLayout).replace(/\\/g, '/'),
+          absPath: targetLayout,
+          message: 'Server layout renders <SiteDataProvider> inside <Providers>, causing undefined component in React Server Components.',
+          severity: 'error',
+          meta: { hasProvidersWrapper, hasSiteDataImport },
+        });
+      } else if (rendersSiteDataProvider && hasSiteDataImport) {
+        issues.push({
+          type: 'rsc-unwrapped-provider',
+          file: path.relative(projectDir, targetLayout).replace(/\\/g, '/'),
+          absPath: targetLayout,
+          message: 'Server layout renders client-only <SiteDataProvider> without a "use client" boundary.',
+          severity: 'error',
+          meta: { hasProvidersWrapper, hasSiteDataImport },
+        });
+      }
+    }
+
+    // Check Global CSS Import in layout.tsx
+    const hasCssImport = /import\s+['"][^'"]+\.css['"]/.test(layoutCode);
+    if (!hasCssImport) {
+      const cssCandidates = [
+        path.join(path.dirname(targetLayout), 'globals.css'),
+        path.join(path.dirname(targetLayout), 'global.css'),
+        path.join(projectDir, 'src', 'app', 'globals.css'),
+        path.join(projectDir, 'src', 'styles', 'globals.css'),
+        path.join(projectDir, 'styles', 'globals.css'),
+      ];
+      const foundCss = cssCandidates.find((c) => fs.existsSync(c));
+      if (foundCss) {
+        const relPath = path.relative(path.dirname(targetLayout), foundCss).replace(/\\/g, '/');
+        const relImport = relPath.startsWith('.') ? relPath : `./${relPath}`;
+        issues.push({
+          type: 'missing-global-css-import',
+          file: path.relative(projectDir, targetLayout).replace(/\\/g, '/'),
+          absPath: targetLayout,
+          message: `Root layout is missing global stylesheet import (${path.basename(foundCss)}), which would cause unstyled HTML.`,
+          severity: 'error',
+          meta: { cssRel: relImport },
+        });
+      }
+    }
+  }
+
+  // 2. Check Component Export / Import Integrity in page.tsx
+  const pageFiles = [
+    path.join(projectDir, 'src', 'app', 'page.tsx'),
+    path.join(projectDir, 'app', 'page.tsx'),
+    path.join(projectDir, 'src', 'pages', 'index.tsx'),
+    path.join(projectDir, 'pages', 'index.tsx'),
+  ];
+  const targetPage = pageFiles.find((p) => fs.existsSync(p));
+
+  if (targetPage) {
+    const pageCode = fs.readFileSync(targetPage, 'utf8');
+    const importRegex = /import\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+    let match;
+
+    while ((match = importRegex.exec(pageCode)) !== null) {
+      const clause = match[1].trim();
+      const specifier = match[2].trim();
+
+      if (!specifier.startsWith('@/') && !specifier.startsWith('.')) continue;
+
+      let resolvedFile = null;
+      if (specifier.startsWith('@/')) {
+        const candidate = path.join(projectDir, 'src', specifier.slice(2));
+        for (const ext of ['', '.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts']) {
+          if (fs.existsSync(candidate + ext) && !fs.statSync(candidate + ext).isDirectory()) {
+            resolvedFile = candidate + ext;
+            break;
+          }
+        }
+      } else {
+        const candidate = path.resolve(path.dirname(targetPage), specifier);
+        for (const ext of ['', '.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts']) {
+          if (fs.existsSync(candidate + ext) && !fs.statSync(candidate + ext).isDirectory()) {
+            resolvedFile = candidate + ext;
+            break;
+          }
+        }
+      }
+
+      if (!resolvedFile || resolvedFile.endsWith('.json') || resolvedFile.endsWith('.css')) continue;
+
+      const targetSrc = fs.readFileSync(resolvedFile, 'utf8');
+
+      // Check named imports
+      const namedMatch = clause.match(/\{([^}]+)\}/);
+      if (namedMatch) {
+        const names = namedMatch[1].split(',').map((s) => s.trim().split(/\s+as\s+/)[0]);
+        for (const name of names) {
+          if (!name || name === 'type') continue;
+          const re = new RegExp(`\\bexport\\s+(?:const|function|class|interface|type)\\s+${name}\\b|\\bexport\\s*\\{[^}]*\\b${name}\\b`);
+          if (!re.test(targetSrc)) {
+            issues.push({
+              type: 'missing-named-export',
+              file: path.relative(projectDir, resolvedFile).replace(/\\/g, '/'),
+              absPath: resolvedFile,
+              message: `Component "${name}" imported in ${path.basename(targetPage)} is not exported from ${path.basename(resolvedFile)}.`,
+              severity: 'error',
+              meta: { componentName: name, importerFile: targetPage },
+            });
+          }
+        }
+      }
+
+      // Check default imports
+      const defaultMatch = clause.match(/^([A-Za-z0-9_$]+)(?:\s*,|\s*$)/);
+      if (defaultMatch && !clause.includes('{')) {
+        const defName = defaultMatch[1];
+        if (defName !== 'type' && !/export\s+default\b/.test(targetSrc)) {
+          issues.push({
+            type: 'missing-default-export',
+            file: path.relative(projectDir, resolvedFile).replace(/\\/g, '/'),
+            absPath: resolvedFile,
+            message: `File ${path.basename(resolvedFile)} lacks a default export for "${defName}".`,
+            severity: 'error',
+            meta: { componentName: defName, importerFile: targetPage },
+          });
+        }
+      }
+    }
+  }
+
+  // 3. Check for broad container markers across all component files
+  for (const relFile of profile.jsxFiles || []) {
+    const absPath = path.join(projectDir, relFile);
+    if (!fs.existsSync(absPath)) continue;
+    const src = fs.readFileSync(absPath, 'utf8');
+
+    const broadRegex = /<(div|section|article|aside|header|footer|nav|main|form|ul|ol|table|thead|tbody|tr)\b([^>]*\bdata-preview-field-path\s*=[^>]*)/gi;
+    let bMatch;
+    while ((bMatch = broadRegex.exec(src)) !== null) {
+      issues.push({
+        type: 'broad-container-field-marker',
+        file: relFile.replace(/\\/g, '/'),
+        absPath,
+        message: `data-preview-field-path cannot be placed on broad <${bMatch[1]}> in ${relFile}.`,
+        severity: 'error',
+        meta: { tag: bMatch[1], snippet: bMatch[0].slice(0, 80) },
+      });
+    }
+  }
+
+  // 4. Check manifest routes vs disk
+  const manifestPath = path.join(projectDir, 'fivora-template.json');
+  if (fs.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+      for (const p of manifest.pages || []) {
+        if (!p || !p.route) continue;
+        if (p.route === '/') continue;
+
+        const cleanRoute = p.route.replace(/^\/+/, '');
+        const exists =
+          fs.existsSync(path.join(projectDir, 'src', 'app', cleanRoute, 'page.tsx')) ||
+          fs.existsSync(path.join(projectDir, 'src', 'app', cleanRoute, 'page.jsx')) ||
+          fs.existsSync(path.join(projectDir, 'app', cleanRoute, 'page.tsx')) ||
+          fs.existsSync(path.join(projectDir, 'app', cleanRoute, 'page.jsx')) ||
+          fs.existsSync(path.join(projectDir, 'src', 'pages', `${cleanRoute}.tsx`)) ||
+          fs.existsSync(path.join(projectDir, 'src', 'pages', `${cleanRoute}.jsx`)) ||
+          fs.existsSync(path.join(projectDir, 'pages', `${cleanRoute}.tsx`)) ||
+          fs.existsSync(path.join(projectDir, 'pages', `${cleanRoute}.jsx`));
+
+        if (!exists) {
+          issues.push({
+            type: 'orphan-manifest-route',
+            file: 'fivora-template.json',
+            absPath: manifestPath,
+            message: `Manifest page "${p.id}" route "${p.route}" has no page file on disk.`,
+            severity: 'error',
+            meta: { pageId: p.id, route: p.route },
+          });
+        }
+      }
+    } catch {
+      // ignore JSON parse error
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Heals detected runtime integrity issues automatically.
+ * Applies deterministic AST fixes for known patterns, and uses ChatGPT API for complex self-healing.
+ *
+ * @param {string} projectDir
+ * @param {object} profile
+ * @param {Array} issues
+ * @param {object} options
+ * @returns {Promise<{ healedCount: number, remainingCount: number, log: string[] }>}
+ */
+async function healRuntimeIntegrity(projectDir, profile, issues, options = {}) {
+  let healedCount = 0;
+  const log = [];
+
+  for (const issue of issues) {
+    // Healing Pattern 1: RSC Duplicate or Server-rendered SiteDataProvider in layout.tsx
+    if (issue.type === 'rsc-duplicate-provider' && issue.absPath && fs.existsSync(issue.absPath)) {
+      try {
+        let code = fs.readFileSync(issue.absPath, 'utf8');
+
+        // If <Providers> exists, unwrap the redundant <SiteDataProvider> from layout.tsx
+        code = code.replace(
+          /<SiteDataProvider\s+initialSiteData=\{[^}]+\}>([\s\S]*?)<\/SiteDataProvider>/g,
+          '$1'
+        );
+        // Remove unused SiteDataProvider and initialSiteData imports
+        code = code.replace(/import\s+.*?\bSiteDataProvider\b.*?from\s+['"]@deneb-ui\/(?:ui|core)['"];?\n?/g, '');
+        code = code.replace(/import\s+initialSiteData\s+from\s+['"][^'"]+['"];?\n?/g, '');
+
+        fs.writeFileSync(issue.absPath, code, 'utf8');
+        healedCount++;
+        recordEvaluatorFix({
+          projectDir,
+          issueType: issue.type,
+          file: issue.file,
+          action: 'remove-redundant-server-site-data-provider',
+          success: true,
+        });
+        log.push(`Healed RSC boundary: removed redundant <SiteDataProvider> from server component ${issue.file}`);
+      } catch (err) {
+        log.push(`Failed to heal ${issue.file}: ${err.message}`);
+      }
+      continue;
+    }
+
+    // Healing Pattern 1b: Missing global CSS stylesheet import in layout.tsx
+    if (issue.type === 'missing-global-css-import' && issue.absPath && fs.existsSync(issue.absPath)) {
+      try {
+        let code = fs.readFileSync(issue.absPath, 'utf8');
+        const cssImport = `import "${issue.meta?.cssRel || './globals.css'}";\n`;
+        const firstImportIdx = code.indexOf('import ');
+        if (firstImportIdx !== -1) {
+          const nextLineIdx = code.indexOf('\n', firstImportIdx);
+          code = code.slice(0, nextLineIdx + 1) + cssImport + code.slice(nextLineIdx + 1);
+        } else {
+          code = cssImport + code;
+        }
+        fs.writeFileSync(issue.absPath, code, 'utf8');
+        healedCount++;
+        recordEvaluatorFix({
+          projectDir,
+          issueType: issue.type,
+          file: issue.file,
+          action: 'restore-global-css-import',
+          success: true,
+        });
+        log.push(`Healed layout styles: restored ${issue.meta?.cssRel || './globals.css'} import in ${issue.file}`);
+      } catch (err) {
+        log.push(`Failed to heal global CSS import in ${issue.file}: ${err.message}`);
+      }
+      continue;
+    }
+
+    // Healing Pattern 2: Broad container field path
+    if (issue.type === 'broad-container-field-marker' && issue.absPath && fs.existsSync(issue.absPath)) {
+      try {
+        let code = fs.readFileSync(issue.absPath, 'utf8');
+        // Replace <div ... data-preview-field-path="..."> with <span className="block..." ...>
+        code = code.replace(
+          /<div\b([^>]*\bdata-preview-field-path\s*=[^>]*)>([\s\S]*?)<\/div>/gi,
+          (match, attrs, inner) => {
+            let nextAttrs = attrs;
+            if (/className\s*=\s*['"]/.test(nextAttrs)) {
+              nextAttrs = nextAttrs.replace(/className\s*=\s*(['"])/, 'className=$1block ');
+            } else {
+              nextAttrs = ` className="block"${nextAttrs}`;
+            }
+            return `<span${nextAttrs}>${inner}</span>`;
+          }
+        );
+        fs.writeFileSync(issue.absPath, code, 'utf8');
+        healedCount++;
+        recordEvaluatorFix({
+          projectDir,
+          issueType: issue.type,
+          file: issue.file,
+          action: 'convert-broad-container-to-inline-span',
+          success: true,
+        });
+        log.push(`Healed broad container: converted <${issue.meta?.tag || 'div'}> to inline-block <span data-preview-field-path> in ${issue.file}`);
+      } catch (err) {
+        log.push(`Failed to heal broad container in ${issue.file}: ${err.message}`);
+      }
+      continue;
+    }
+
+    // Healing Pattern 3: Orphan manifest route
+    if (issue.type === 'orphan-manifest-route' && issue.absPath && fs.existsSync(issue.absPath)) {
+      try {
+        const manifest = JSON.parse(fs.readFileSync(issue.absPath, 'utf8'));
+        if (Array.isArray(manifest.pages)) {
+          manifest.pages = manifest.pages.filter((p) => p.id !== issue.meta?.pageId && p.route !== issue.meta?.route);
+          fs.writeFileSync(issue.absPath, JSON.stringify(manifest, null, 2), 'utf8');
+          healedCount++;
+          recordEvaluatorFix({
+            projectDir,
+            issueType: issue.type,
+            file: issue.file,
+            action: 'prune-orphan-manifest-route',
+            success: true,
+          });
+          log.push(`Healed manifest: pruned non-existent route "${issue.meta?.route}" (${issue.meta?.pageId})`);
+        }
+      } catch (err) {
+        log.push(`Failed to heal manifest route: ${err.message}`);
+      }
+      continue;
+    }
+
+    // Healing Pattern 4: AI-Assisted Self-Healing for missing exports or complex issues
+    if (issue.type.startsWith('missing-') && options.aiEnabled && issue.absPath && fs.existsSync(issue.absPath)) {
+      loadEnv(projectDir);
+      const aiReady = checkAiReady();
+      if (aiReady.ready) {
+        try {
+          const fileSrc = fs.readFileSync(issue.absPath, 'utf8');
+          const prompt = `You are a senior React/TypeScript engineer on the DENEB UI team.
+Fix this export error in the file:
+ERROR: ${issue.message}
+
+FILE SOURCE:
+\`\`\`tsx
+${fileSrc}
+\`\`\`
+
+INSTRUCTIONS:
+1. Ensure the component "${issue.meta?.componentName}" is properly exported with a named export \`export function ${issue.meta?.componentName}()\` or proper export syntax.
+2. Preserve all existing JSX, props, logic, and styling.
+3. Output ONLY the raw TypeScript (.tsx) code. No markdown fences, no explanations.`;
+
+          const aiResult = await callOpenAI(prompt);
+          if (aiResult && aiResult.content) {
+            fs.writeFileSync(issue.absPath, aiResult.content, 'utf8');
+            healedCount++;
+            recordEvaluatorFix({
+              projectDir,
+              issueType: issue.type,
+              file: issue.file,
+              action: 'ai-generate-missing-export',
+              success: true,
+            });
+            log.push(`AI healed export in ${issue.file}: added export for ${issue.meta?.componentName}`);
+          }
+        } catch (err) {
+          log.push(`AI heal failed for ${issue.file}: ${err.message}`);
+        }
+      }
+    }
+  }
+
+  // Re-audit after healing to calculate remaining issues
+  const remaining = auditRuntimeIntegrity(projectDir, profile);
+  return {
+    healedCount,
+    remainingCount: remaining.length,
+    remainingIssues: remaining,
+    log,
+  };
+}
+
+/**
+ * Complete evaluation pipeline called by `init --ai`.
+ *
+ * @param {string} projectDir - Project directory
+ * @param {object} profile - Project profile
+ * @param {object} [options] - Options (aiEnabled, etc.)
+ * @returns {Promise<{ passed: boolean, issuesFound: number, healed: number, log: string[] }>}
+ */
+async function runAiEvaluatorPipeline(projectDir, profile, options = {}) {
+  const initialIssues = auditRuntimeIntegrity(projectDir, profile);
+
+  if (initialIssues.length === 0) {
+    return {
+      passed: true,
+      issuesFound: 0,
+      healed: 0,
+      log: ['All runtime integrity checks passed cleanly.'],
+    };
+  }
+
+  const healResult = await healRuntimeIntegrity(projectDir, profile, initialIssues, options);
+
+  return {
+    passed: healResult.remainingCount === 0,
+    issuesFound: initialIssues.length,
+    healed: healResult.healedCount,
+    remainingIssues: healResult.remainingIssues,
+    log: healResult.log,
+  };
+}
+
+module.exports = {
+  auditRuntimeIntegrity,
+  healRuntimeIntegrity,
+  runAiEvaluatorPipeline,
+};

package/src/arc/ai-prompts.cjs

@@ -124,6 +124,7 @@ Your task is to create an editable wrapper component for an existing component.
 10. **Use \`'use strict'\` is NOT needed** — this is a .tsx file.
 11. **Do NOT import React hooks** like useState, useEffect, useContext. The component must be stateless.
 12. **Do NOT import useSiteData** — the wrapper component does not need it directly.
+13. **NEVER place data-preview-field-path on <div>, <section>, <article>, or broad containers**. ` + '`data-preview-field-path`' + ` must ONLY be on leaf text/media/control elements (<span>, <p>, <h1>-<h6>, <a>, <button>, EditableText, EditableImage).
 
 ## REFERENCE PATTERN (follow this structure exactly):
 

package/src/arc/ast.cjs

@@ -20,9 +20,17 @@ const BABEL_PLUGIN_SETS = [
   ['jsx'],
 ];
 
-function parseWithBabel(code) {
+function parseWithBabel(code, filePath = 'file.tsx') {
+  const isTs =
+    /\.(tsx|ts|mts|cts)$/i.test(filePath) ||
+    /(?:interface\s+[A-Za-z0-9_$]+|type\s+[A-Za-z0-9_$]+\s*=|:\s*(?:string|number|boolean|any|void|unknown|React\.)|as\s+[A-Za-z0-9_$]+)/.test(code);
+
+  const pluginSets = isTs
+    ? BABEL_PLUGIN_SETS.filter((set) => set.includes('typescript'))
+    : BABEL_PLUGIN_SETS;
+
   let lastError = null;
-  for (const plugins of BABEL_PLUGIN_SETS) {
+  for (const plugins of pluginSets) {
     try {
       return babelParser.parse(code, {
         sourceType: 'unambiguous',
@@ -52,7 +60,7 @@ function parseSource(code, filePath = 'file.tsx') {
     ...options,
     parser: {
       parse(source) {
-        return parseWithBabel(source);
+        return parseWithBabel(source, filePath);
       },
     },
   });

package/src/arc/index.cjs

@@ -39,6 +39,7 @@ const printer = require('./printer.cjs');
 const { classifyComponents } = require('./component-registry.cjs');
 const { checkAiReady, adaptComponent, generateDocsPage, loadEnv } = require('./ai-agent.cjs');
 const { checkGithubReady, createComponentPR } = require('./pr-agent.cjs');
+const { runAiEvaluatorPipeline } = require('./ai-evaluator.cjs');
 
 function parseArcOptions(raw = {}) {
   return {
@@ -341,7 +342,33 @@ async function runDenebArcAsync(projectDir, projectName, options = {}) {
     }
   }
 
-  return runArcTransformations(projectDir, projectName, opts, profile, graph, analyses, runId, startedAt);
+  const result = runArcTransformations(projectDir, projectName, opts, profile, graph, analyses, runId, startedAt);
+
+  if (!opts.dryRun && result && result.outcome === 'success') {
+    printer.printAiEvaluatorStart();
+    try {
+      const evalResult = await runAiEvaluatorPipeline(projectDir, profile, {
+        dryRun: opts.aiDryRun,
+        aiEnabled: opts.aiEnabled,
+      });
+      if (evalResult.healed > 0) {
+        for (const logItem of evalResult.log) {
+          printer.printAiEvaluatorHealed(logItem);
+        }
+      }
+      if (evalResult.remainingIssues && evalResult.remainingIssues.length > 0) {
+        for (const issue of evalResult.remainingIssues) {
+          printer.printAiEvaluatorIssue(`${issue.file}: ${issue.message}`);
+        }
+      } else {
+        printer.printAiEvaluatorPass('All runtime integrity checks passed (RSC boundaries, exports, Fivora contracts).');
+      }
+    } catch (err) {
+      printer.warn(`AI Evaluator audit encountered an issue: ${err.message}`);
+    }
+  }
+
+  return result;
 }
 
 function runDenebArcSync(projectDir, projectName, options = {}) {

package/src/arc/learning.cjs

@@ -199,8 +199,38 @@ function redactSecrets(value) {
     .replace(/-----BEGIN [A-Z ]+PRIVATE KEY-----[\s\S]*?-----END [A-Z ]+PRIVATE KEY-----/g, '***REDACTED KEY***');
 }
 
+function recordEvaluatorFix({ projectDir, issueType, file, action, success = true }) {
+  const record = {
+    engineVersion: ARC_VERSION,
+    type: 'evaluator-fix',
+    timestamp: new Date().toISOString(),
+    issueType,
+    file,
+    action,
+    success: Boolean(success),
+  };
+  try {
+    if (projectDir) {
+      fs.mkdirSync(path.dirname(experiencePath(projectDir)), { recursive: true });
+      const local = loadJsonArray(experiencePath(projectDir));
+      writeJson(experiencePath(projectDir), [...local, record].slice(-400));
+    }
+  } catch {
+    // ignore
+  }
+  try {
+    fs.mkdirSync(path.dirname(localStorePath()), { recursive: true });
+    const global = loadJsonArray(localStorePath());
+    writeJson(localStorePath(), [...global, record].slice(-800));
+  } catch {
+    // ignore
+  }
+  return record;
+}
+
 module.exports = {
   recordExperience,
+  recordEvaluatorFix,
   loadFingerprintBoost,
   registryArchitecture,
   redactSecrets,

package/src/arc/planner.cjs

@@ -177,8 +177,16 @@ function planTransformations({ profile, analyses, recipe }) {
         }));
         transform.items = candidate.value.map((item) => item.value);
         transform.itemParam = extra.itemParam;
-        transform.indexParam = extra.indexParam;
-        if (!transform.itemFields.length || !extra.objectItems) transform.decision = 'skip';
+        if (!transform.itemFields.length && extra.objectItems && candidate.value?.length > 0) {
+          const sample = candidate.value[0]?.value || {};
+          transform.itemFields = Object.keys(sample)
+            .filter((k) => typeof sample[k] === 'string' || typeof sample[k] === 'number')
+            .map((k) => ({
+              key: k,
+              type: typeof sample[k] === 'number' ? 'number' : /image|photo|avatar/i.test(k) ? 'image' : /url|link/i.test(k) ? 'url' : 'text',
+            }));
+        }
+        if (!transform.itemFields.length || !extra.objectItems || extra.hasComponentRef) transform.decision = 'skip';
       } else {
         transform.field = buildFieldPath({
           scope,

package/src/arc/printer.cjs

@@ -202,6 +202,22 @@ function printAiSummary(adapted, skipped, totalTokens) {
   console.log(`\n  ${C.cyan}⚡${C.reset} AI Agent Summary: ${C.green}${adapted} adapted${C.reset}, ${C.yellow}${skipped} skipped${C.reset}, ~${totalTokens.toLocaleString()} tokens used`);
 }
 
+function printAiEvaluatorStart() {
+  console.log(`\n  ${C.cyan}⚡${C.reset} ${C.bold}AI Evaluator:${C.reset} Running pre-flight runtime integrity audit...`);
+}
+
+function printAiEvaluatorPass(message) {
+  console.log(`    ${C.green}✓${C.reset} ${message}`);
+}
+
+function printAiEvaluatorHealed(message) {
+  console.log(`    ${C.cyan}🔧${C.reset} ${C.bold}Auto-healed:${C.reset} ${message}`);
+}
+
+function printAiEvaluatorIssue(message) {
+  console.log(`    ${C.yellow}⚠${C.reset} ${message}`);
+}
+
 module.exports = {
   printBanner,
   printProfile,
@@ -223,6 +239,10 @@ module.exports = {
   printAiSkipped,
   printAiPr,
   printAiSummary,
+  printAiEvaluatorStart,
+  printAiEvaluatorPass,
+  printAiEvaluatorHealed,
+  printAiEvaluatorIssue,
   ok,
   warn,
   info,

package/src/arc/semantic.cjs

@@ -49,35 +49,53 @@ function isStaticSkipText(text) {
   return false;
 }
 
+function unwrapTypeCasts(node) {
+  let curr = node;
+  while (
+    curr &&
+    (curr.type === 'TSAsExpression' ||
+      curr.type === 'TSTypeAssertion' ||
+      curr.type === 'TypeCastExpression' ||
+      curr.type === 'TSNonNullExpression')
+  ) {
+    curr = curr.expression;
+  }
+  return curr;
+}
+
 function collectStringBindings(ast) {
   const bindings = new Map();
   recast.types.visit(ast, {
     visitVariableDeclarator(pathNode) {
       const node = pathNode.node;
       if (node.id && node.id.type === 'Identifier' && node.init) {
-        if (node.init.type === 'StringLiteral' || node.init.type === 'Literal' && typeof node.init.value === 'string') {
-          bindings.set(node.id.name, String(node.init.value));
+        const init = unwrapTypeCasts(node.init);
+        if (init.type === 'StringLiteral' || (init.type === 'Literal' && typeof init.value === 'string')) {
+          bindings.set(node.id.name, String(init.value));
         }
-        if (node.init.type === 'ArrayExpression') {
+        if (init.type === 'ArrayExpression') {
           const items = [];
-          let allLiteral = true;
-          for (const el of node.init.elements || []) {
+          for (const el of init.elements || []) {
             if (!el) continue;
-            if (el.type === 'StringLiteral' || (el.type === 'Literal' && typeof el.value === 'string')) {
-              items.push({ type: 'string', value: String(el.value) });
-            } else if (el.type === 'ObjectExpression') {
-              const obj = objectLiteralToPlain(el);
-              if (obj) items.push({ type: 'object', value: obj });
-              else allLiteral = false;
-            } else {
-              allLiteral = false;
+            const inner = unwrapTypeCasts(el);
+            if (inner.type === 'StringLiteral' || (inner.type === 'Literal' && typeof inner.value === 'string')) {
+              items.push({ type: 'string', value: String(inner.value) });
+            } else if (inner.type === 'ObjectExpression') {
+              const obj = objectLiteralToPlain(inner);
+              if (obj && Object.keys(obj).length > 0) {
+                items.push({ type: 'object', value: obj });
+              }
             }
           }
-          if (allLiteral && items.length) bindings.set(node.id.name, { kind: 'array', items });
+          if (items.length > 0) {
+            bindings.set(node.id.name, { kind: 'array', items });
+          }
         }
-        if (node.init.type === 'ObjectExpression') {
-          const obj = objectLiteralToPlain(node.init);
-          if (obj) bindings.set(node.id.name, { kind: 'object', value: obj });
+        if (init.type === 'ObjectExpression') {
+          const obj = objectLiteralToPlain(init);
+          if (obj && Object.keys(obj).length > 0) {
+            bindings.set(node.id.name, { kind: 'object', value: obj });
+          }
         }
       }
       this.traverse(pathNode);
@@ -90,18 +108,57 @@ function objectLiteralToPlain(node) {
   if (!node || node.type !== 'ObjectExpression') return null;
   const out = {};
   for (const prop of node.properties || []) {
-    if (prop.type !== 'ObjectProperty' && prop.type !== 'Property') return null;
+    if (prop.type !== 'ObjectProperty' && prop.type !== 'Property') continue;
     const key = prop.key && (prop.key.name || prop.key.value);
-    if (!key || prop.computed) return null;
-    const val = prop.value;
+    if (!key || prop.computed) continue;
+    const val = unwrapTypeCasts(prop.value);
+    if (!val) continue;
+
     if (val.type === 'StringLiteral' || (val.type === 'Literal' && typeof val.value === 'string')) {
       out[key] = String(val.value);
     } else if (val.type === 'NumericLiteral' || (val.type === 'Literal' && typeof val.value === 'number')) {
       out[key] = val.value;
     } else if (val.type === 'BooleanLiteral' || (val.type === 'Literal' && typeof val.value === 'boolean')) {
       out[key] = val.value;
-    } else {
-      return null;
+    } else if (val.type === 'NullLiteral' || (val.type === 'Literal' && val.value === null)) {
+      out[key] = null;
+    } else if (val.type === 'TemplateLiteral' && (!val.expressions || val.expressions.length === 0)) {
+      out[key] = val.quasis?.map((q) => q.value?.cooked || q.value?.raw || '').join('') || '';
+    } else if (val.type === 'Identifier') {
+      if (/^[A-Z]/.test(val.name)) {
+        // Component references (e.g. icon: Truck, Icon: ShieldCheck) are not merchant content
+        return null;
+      }
+      out[key] = val.name;
+    } else if (val.type === 'UnaryExpression' && val.argument) {
+      if (val.operator === '-' && (val.argument.type === 'NumericLiteral' || typeof val.argument.value === 'number')) {
+        out[key] = -val.argument.value;
+      } else if (val.operator === '!' && (val.argument.type === 'BooleanLiteral' || typeof val.argument.value === 'boolean')) {
+        out[key] = !val.argument.value;
+      }
+    } else if (val.type === 'ArrayExpression') {
+      const arr = [];
+      for (const el of val.elements || []) {
+        if (!el) continue;
+        const inner = unwrapTypeCasts(el);
+        if (!inner) continue;
+        if (inner.type === 'StringLiteral' || (inner.type === 'Literal' && typeof inner.value === 'string')) {
+          arr.push(String(inner.value));
+        } else if (inner.type === 'NumericLiteral' || (inner.type === 'Literal' && typeof inner.value === 'number')) {
+          arr.push(inner.value);
+        } else if (inner.type === 'BooleanLiteral' || (inner.type === 'Literal' && typeof inner.value === 'boolean')) {
+          arr.push(inner.value);
+        } else if (inner.type === 'ObjectExpression') {
+          const nestedObj = objectLiteralToPlain(inner);
+          if (nestedObj) arr.push(nestedObj);
+        } else if (inner.type === 'Identifier') {
+          arr.push(inner.name);
+        }
+      }
+      out[key] = arr;
+    } else if (val.type === 'ObjectExpression') {
+      const nestedObj = objectLiteralToPlain(val);
+      if (nestedObj) out[key] = nestedObj;
     }
   }
   return out;
@@ -262,16 +319,47 @@ function collectItemFieldUsage(callback, itemParam) {
     usage.set(property, role);
   }
 
-  function memberProperty(expr) {
-    if (!expr || expr.type !== 'MemberExpression' || expr.computed) return null;
-    if (expr.object?.type !== 'Identifier' || expr.object.name !== itemParam) return null;
-    return expr.property?.name || null;
+  function findItemMemberProperties(expr) {
+    const props = [];
+    if (!expr) return props;
+    if (expr.type === 'MemberExpression' && !expr.computed) {
+      if (expr.object?.type === 'Identifier' && expr.object.name === itemParam) {
+        if (expr.property?.name) props.push(expr.property.name);
+      } else if (expr.object?.type === 'MemberExpression') {
+        const sub = findItemMemberProperties(expr.object);
+        if (sub.length > 0 && expr.property?.name) {
+          props.push(expr.property.name);
+        }
+      }
+    } else if (expr.type === 'LogicalExpression' || expr.type === 'BinaryExpression') {
+      props.push(...findItemMemberProperties(expr.left));
+      props.push(...findItemMemberProperties(expr.right));
+    } else if (expr.type === 'ConditionalExpression') {
+      props.push(...findItemMemberProperties(expr.test));
+      props.push(...findItemMemberProperties(expr.consequent));
+      props.push(...findItemMemberProperties(expr.alternate));
+    } else if (expr.type === 'TemplateLiteral') {
+      for (const sub of expr.expressions || []) {
+        props.push(...findItemMemberProperties(sub));
+      }
+    }
+    return props;
   }
 
+  let usesItemAsComponent = false;
   recast.types.visit(callback, {
+    visitJSXOpeningElement(pathNode) {
+      const name = pathNode.node.name;
+      if (name?.type === 'JSXMemberExpression') {
+        if (name.object?.type === 'Identifier' && name.object.name === itemParam) {
+          usesItemAsComponent = true;
+        }
+      }
+      this.traverse(pathNode);
+    },
     visitJSXExpressionContainer(pathNode) {
-      const property = memberProperty(pathNode.node.expression);
-      if (property) {
+      const properties = findItemMemberProperties(pathNode.node.expression);
+      for (const property of properties) {
         const parent = pathNode.parent?.node || pathNode.parent?.value;
         if (parent?.type === 'JSXAttribute') {
           const attribute = parent.name?.name;
@@ -290,7 +378,7 @@ function collectItemFieldUsage(callback, itemParam) {
     },
   });
 
-  return usage;
+  return { usage, usesItemAsComponent };
 }
 
 function classNameOf(node) {
@@ -592,13 +680,14 @@ function analyzeFile({ code, relativeFile, profile, graph, ownerScope, component
         bindings.get(mapInfo.objectName)?.kind === 'array'
       ) {
         const arr = bindings.get(mapInfo.objectName);
-        const itemUsage = collectItemFieldUsage(mapInfo.callback, mapInfo.itemParam);
+        const { usage: itemUsage, usesItemAsComponent } = collectItemFieldUsage(mapInfo.callback, mapInfo.itemParam);
         const objectItems = arr.items.every((item) => item.type === 'object');
         const boundProperties = [...itemUsage.keys()];
         const convertible =
+          !usesItemAsComponent &&
           objectItems &&
           boundProperties.length > 0 &&
-          arr.items.every((item) => boundProperties.every((key) => key in item.value));
+          arr.items.some((item) => boundProperties.some((key) => key in item.value));
 
         candidates.push({
           ...baseMeta,
@@ -612,11 +701,18 @@ function analyzeFile({ code, relativeFile, profile, graph, ownerScope, component
             indexParam: mapInfo.indexParam,
             itemFields: [...itemUsage.entries()].map(([key, role]) => ({ key, role })),
             objectItems,
+            hasComponentRef: usesItemAsComponent,
           },
           confidence: convertible
             ? confidenceFor('collection', { staticCollection: true })
-            : 0.3,
-          reason: convertible ? 'static-array-map' : 'collection-shape-not-uniform',
+            : usesItemAsComponent
+              ? 0.2
+              : 0.82,
+          reason: usesItemAsComponent
+            ? 'collection-holds-component-ref'
+            : convertible
+              ? 'static-array-map'
+              : 'collection-shape-partial',
           fingerprint: fingerprintCandidate({ tag: name, kind: 'collection', size: arr.items.length }),
         });
       }

package/src/arc/transformer.cjs

@@ -24,6 +24,7 @@ const {
   b,
 } = require('./ast.cjs');
 const { toPosix } = require('./fs-utils.cjs');
+const { BROAD_CONTENT_CONTAINERS } = require('./fivora-contract.cjs');
 
 function findElementByLoc(ast, loc) {
   let found = null;
@@ -222,6 +223,11 @@ function applyTransformToElement(pathNode, transform) {
     return;
   }
   if (transform.operation === 'extract-text') {
+    const tagName = getJsxName(node);
+    if (BROAD_CONTENT_CONTAINERS.has(tagName)) {
+      wrapLiteralTextChildren(node, transform.field, transform.fallback);
+      return;
+    }
     ensurePreviewPath(node, transform.field);
     ensureStyleAttrs(node, transform.field, inferButtonKind(transform.tag));
     replaceTextChildren(node, transform.field, transform.fallback, transform.fieldType || 'text');
@@ -851,7 +857,7 @@ function instrumentLayoutSource(code, siteDataImport, providerImport = '@deneb-u
     ensureDefaultImport(ast, siteDataImport, jsonIdent);
   }
 
-  const hasProvider = /SiteDataProvider|DenebDataProvider/.test(code);
+  const hasProvider = /SiteDataProvider|DenebDataProvider|<Providers\b/.test(code);
   let wrapped = hasProvider;
 
   if (!hasProvider) {