@deneb-ui/cli 2.0.91 → 2.0.93

package/package.json

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

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

@@ -21,6 +21,44 @@ const { classifyActionIntent } = require('../adapters.cjs');
 const { validateGeneratedCode } = require('../ai-agent.cjs');
 const { auditRuntimeIntegrity, healRuntimeIntegrity, runAiEvaluatorPipeline } = require('../ai-evaluator.cjs');
 
+test('DENEB preflight rejects a Next router destination with a duplicated base path before install', () => {
+  const starter = path.resolve(
+    __dirname,
+    '../../../../../packages/create-template/template'
+  );
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-navigation-preflight-'));
+  fs.cpSync(starter, tempDir, { recursive: true });
+  const componentDir = path.join(tempDir, 'src', 'components');
+  fs.mkdirSync(componentDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(componentDir, 'BrokenNavigation.tsx'),
+    "router.push(withBasePath(pageRoute('about')));\n"
+  );
+
+  try {
+    const validator = path.resolve(
+      __dirname,
+      '../../tools/deneb-template-validator.cjs'
+    );
+    const result = require('node:child_process').spawnSync(
+      process.execPath,
+      [validator, 'validate', tempDir, '--skip-install', '--skip-build'],
+      { encoding: 'utf8' }
+    );
+    const output = `${result.stdout ?? ''}\n${result.stderr ?? ''}`;
+
+    assert.equal(result.status, 1);
+    assert.match(
+      output,
+      /Template navigation validation failed before dependency installation\./
+    );
+    assert.match(output, /src\/components\/BrokenNavigation\.tsx:1/);
+    assert.doesNotMatch(output, /Install dependencies/);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
 test('field-paths recognizes list action CTA keys', () => {
   assert.equal(isListActionCtaKey('preOrderCta'), true);
   assert.equal(isListActionCtaKey('addToTrayCta'), true);
@@ -3885,4 +3923,3 @@ test('ARC v3 Phase 18: formatBlockedExplanationTerminal renders actionable remed
 
 
 
-

package/src/arc/__tests__/composite-fragments.test.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { parseSource, printSource } = require('../ast.cjs');
+const { replaceTextChildren } = require('../transforms/primitives/text.cjs');
+const { splitActionChildren } = require('../transforms/primitives/action.cjs');
+
+test('composite-fragments: preserves dynamic runtime expression and wraps literal text in editable span', () => {
+  const code = '<h1>Shop {category.name} Collection</h1>';
+  const ast = parseSource(code, 'heading.tsx');
+  const h1Node = ast.program.body[0].expression;
+
+  replaceTextChildren(h1Node, 'shop.heading', 'Shop', 'text');
+  const result = printSource(ast, code);
+
+  // Dynamic expression must be preserved
+  assert.match(result, /\{category\.name\}/);
+  // Literal text must be wrapped in editable span with field-path
+  assert.match(result, /data-preview-field-path="shop\.heading"/);
+});
+
+test('composite-fragments: replaces pure static text directly without extra spans', () => {
+  const code = '<h1>Featured Products</h1>';
+  const ast = parseSource(code, 'heading.tsx');
+  const h1Node = ast.program.body[0].expression;
+
+  replaceTextChildren(h1Node, 'home.featuredTitle', 'Featured Products', 'text');
+  const result = printSource(ast, code);
+
+  assert.match(result, /<h1>\{siteData\?\.content\?\.home\?\.featuredTitle \?\? "Featured Products"\}<\/h1>/);
+});
+
+test('composite-fragments: splitActionChildren wraps only text and leaves icon untouched', () => {
+  const code = '<button><Icon className="w-4 h-4" /> Add to Cart</button>';
+  const ast = parseSource(code, 'button.tsx');
+  const btnNode = ast.program.body[0].expression;
+
+  splitActionChildren(btnNode, 'product.addToCartLabel', 'Add to Cart');
+  const result = printSource(ast, code);
+
+  // Icon must remain untouched
+  assert.match(result, /<Icon className="w-4 h-4" \/>/);
+  // Outer button must NOT have data-preview-field-path
+  assert.doesNotMatch(result, /<button[^>]*data-preview-field-path/);
+  // Inner text must be in span
+  assert.match(result, /<span[\s\S]*?data-preview-field-path="product\.addToCartLabel"/);
+});

package/src/arc/__tests__/fifteen-gates.test.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { ACCEPTANCE_GATES, evaluateAcceptanceGates } = require('../acceptance-gates.cjs');
+
+test('fifteen-gates: evaluates all 15 gates and passes when all critical pass', () => {
+  const allGateKeys = Object.keys(ACCEPTANCE_GATES);
+  assert.equal(allGateKeys.length, 15, 'Must have exactly 15 acceptance gates');
+
+  const evalResult = evaluateAcceptanceGates({
+    sourceAnalysis: { passed: true },
+    astTransformation: { passed: true },
+    typescriptValidation: { passed: true },
+    buildSuccess: { passed: true },
+    fivoraAudit: { passed: true },
+    manifestValid: true,
+    runtimeEditabilityScore: 100,
+    collectionOpsPassed: true,
+    imageEditingPassed: true,
+    routeCoveragePassed: true,
+    designPreservationScore: 100,
+    controlOnlyValid: true,
+    assetIntegrityPassed: true,
+    rscIntegrityPassed: true,
+    consoleCleanlinessPassed: true,
+    editabilityCoverage: 100,
+  });
+
+  assert.equal(evalResult.passed, true);
+  assert.equal(evalResult.status, 'CONVERSION_PASSED');
+  assert.equal(Object.keys(evalResult.gates).length, 15);
+});
+
+test('fifteen-gates: fails conversion if asset integrity or RSC integrity fails', () => {
+  const failedAsset = evaluateAcceptanceGates({
+    assetIntegrityPassed: false,
+  });
+  assert.equal(failedAsset.passed, false);
+  assert.equal(failedAsset.status, 'CONVERSION_FAILED');
+
+  const failedRsc = evaluateAcceptanceGates({
+    rscIntegrityPassed: false,
+  });
+  assert.equal(failedRsc.passed, false);
+  assert.equal(failedRsc.status, 'CONVERSION_FAILED');
+});

package/src/arc/__tests__/fivora-schema-authority.test.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  PLATFORM_ALLOWED_TYPES,
+  normalizeFieldType,
+  CanonicalPathRegistry,
+  sanitizeEditorSections,
+} = require('../fivora-schema-authority.cjs');
+
+test('fivora-schema-authority: coerces unsupported types to platform whitelist', () => {
+  assert.equal(normalizeFieldType('currency'), 'text');
+  assert.equal(normalizeFieldType('price'), 'text');
+  assert.equal(normalizeFieldType('richText'), 'textarea');
+  assert.equal(normalizeFieldType('phone'), 'tel');
+  assert.equal(normalizeFieldType('link'), 'url');
+  assert.equal(normalizeFieldType('unknown_custom_type'), 'text');
+
+  // Allowed types remain untouched
+  for (const t of PLATFORM_ALLOWED_TYPES) {
+    assert.equal(normalizeFieldType(t), t);
+  }
+});
+
+test('fivora-schema-authority: CanonicalPathRegistry tracks unique paths and detects duplicates', () => {
+  const reg = new CanonicalPathRegistry();
+  const res1 = reg.register('site.announcement.linkUrl', 'site_announcement', 'url');
+  assert.equal(res1.registered, true);
+  assert.equal(res1.isDuplicate, false);
+
+  const res2 = reg.register('site.announcement.linkUrl', 'site', 'url');
+  assert.equal(res2.registered, false);
+  assert.equal(res2.isDuplicate, true);
+  assert.equal(res2.owner, 'site_announcement');
+});
+
+test('fivora-schema-authority: sanitizeEditorSections strips duplicate paths and fixes unsupported types', () => {
+  const sections = [
+    {
+      id: 'site_announcement',
+      path: 'site.announcement',
+      type: 'object',
+      fields: [
+        { key: 'linkUrl', type: 'url', label: 'Announcement Link' },
+        { key: 'priceTag', type: 'currency', label: 'Discount Tag' },
+      ],
+    },
+    {
+      id: 'site',
+      path: 'site',
+      type: 'object',
+      fields: [
+        { key: 'announcement.linkUrl', type: 'url', label: 'Duplicate Announcement Link' },
+        { key: 'brandTitle', type: 'text', label: 'Brand Title' },
+      ],
+    },
+  ];
+
+  const sanitized = sanitizeEditorSections(sections);
+  assert.equal(sanitized.length, 2);
+
+  // Section 1: priceTag coerced from currency to text
+  const priceField = sanitized[0].fields.find((f) => f.key === 'priceTag');
+  assert.equal(priceField.type, 'text');
+
+  // Section 2: duplicate announcement.linkUrl removed
+  const dupField = sanitized[1].fields.find((f) => f.key === 'announcement.linkUrl');
+  assert.equal(dupField, undefined, 'Duplicate field path must be eliminated');
+
+  // Non-duplicate brandTitle remains
+  const brandField = sanitized[1].fields.find((f) => f.key === 'brandTitle');
+  assert.ok(brandField);
+  assert.equal(brandField.type, 'text');
+});

package/src/arc/__tests__/recovery-and-inventory.test.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { recoverCandidateConfidence } = require('../confidence-recovery.cjs');
+const { buildEditabilityInventory } = require('../editability-inventory.cjs');
+
+test('confidence-recovery: elevates low-confidence heading candidate from 0.45 to >= 0.65', () => {
+  const candidate = {
+    tag: 'h2',
+    componentName: 'FeatureTitle',
+    className: 'text-3xl font-bold tracking-tight text-white',
+    value: 'Engineered for Performance and Comfort',
+    confidence: 0.45,
+  };
+
+  const rec = recoverCandidateConfidence(candidate);
+  assert.equal(rec.recovered, true);
+  assert.ok(rec.confidence >= 0.65, `Expected >= 0.65, got ${rec.confidence}`);
+  assert.ok(rec.reasons.includes('semantic-heading-tag'));
+  assert.ok(rec.reasons.includes('tailwind-typography-token'));
+});
+
+test('confidence-recovery: elevates hero promotional badge from 0.40 to >= 0.60', () => {
+  const candidate = {
+    tag: 'span',
+    componentName: 'PromoBadge',
+    parentName: 'HeroSection',
+    className: 'text-sm font-semibold uppercase',
+    value: 'Limited Time Offer',
+    confidence: 0.40,
+  };
+
+  const rec = recoverCandidateConfidence(candidate);
+  assert.equal(rec.recovered, true);
+  assert.ok(rec.confidence >= 0.60, `Expected >= 0.60, got ${rec.confidence}`);
+  assert.ok(rec.reasons.includes('semantic-component-name'));
+});
+
+test('editability-inventory: builds accurate inventory and accounts for 100% of discovered candidates', () => {
+  const candidates = [
+    { loc: '1:1', tag: 'h1', kind: 'text', dataClassification: 'CONTENT_STATIC' },
+    { loc: '2:1', tag: 'p', kind: 'text', dataClassification: 'CONTENT_STATIC' },
+    { loc: '3:1', tag: 'img', kind: 'image', dataClassification: 'CONTENT_STATIC' },
+    { loc: '4:1', tag: 'span', kind: 'text', dataClassification: 'PLATFORM_CONTROLLED' },
+    { loc: '5:1', tag: 'span', kind: 'text', dataClassification: 'RUNTIME_COMPUTED' },
+    { loc: '6:1', tag: 'div', kind: 'bg', dataClassification: 'STYLE_TOKEN' },
+  ];
+
+  const inventory = buildEditabilityInventory(candidates);
+  assert.equal(inventory.totalDiscovered, 6);
+  assert.equal(inventory.expectedEditableCount, 3);
+  assert.equal(inventory.platformControlledCount, 1);
+  assert.equal(inventory.runtimeDataCount, 1);
+  assert.equal(inventory.decorativeCount, 1);
+
+  // Invariant: sum of all tiers must exactly equal totalDiscovered
+  const sumTiers =
+    inventory.expectedEditableCount +
+    inventory.platformControlledCount +
+    inventory.runtimeDataCount +
+    inventory.decorativeCount +
+    inventory.interactionStateCount;
+  assert.equal(sumTiers, inventory.totalDiscovered, 'No candidate lost invariant must hold');
+});

package/src/arc/__tests__/routing-and-assets.test.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { instrumentPageKey } = require('../transforms/routing/page-key.cjs');
+const { auditProjectAssets } = require('../asset-auditor.cjs');
+
+test('routing-and-assets: instrumentPageKey stamps custom root components like PlatformProductDetail', () => {
+  const code = `
+    export default function ProductDetailPage() {
+      return <PlatformProductDetail initialProduct={product} />;
+    }
+  `;
+  const result = instrumentPageKey(code, 'src/app/products/detail/page.tsx', 'products_detail');
+  assert.equal(result.updated, true);
+  assert.match(result.code, /<PlatformProductDetail\s+data-preview-page-key="products_detail"/);
+});
+
+test('routing-and-assets: instrumentPageKey updates mismatched existing page key to canonical route id', () => {
+  const code = `
+    export default function VantaPage() {
+      return <main data-preview-page-key="products"><h1>Vanta Aero</h1></main>;
+    }
+  `;
+  const result = instrumentPageKey(code, 'src/app/products/vanta-aero-x/page.tsx', 'products_vanta-aero-x');
+  assert.equal(result.updated, true);
+  assert.match(result.code, /data-preview-page-key="products_vanta-aero-x"/);
+});
+
+test('routing-and-assets: auditProjectAssets reports missing assets against public directory', () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-assets-'));
+  const publicDir = path.join(tempDir, 'public');
+  fs.mkdirSync(publicDir, { recursive: true });
+  fs.writeFileSync(path.join(publicDir, 'logo.svg'), '<svg></svg>');
+
+  const siteData = {
+    content: {
+      common: {
+        logoUrl: '/logo.svg',
+        brokenLogo: '/fivora-logo.png',
+      },
+    },
+  };
+
+  const audit = auditProjectAssets(tempDir, siteData);
+  assert.equal(audit.passed, false);
+  assert.equal(audit.missingAssets.length, 1);
+  assert.equal(audit.missingAssets[0].path, '/fivora-logo.png');
+  assert.equal(audit.verifiedAssets.length, 1);
+  assert.equal(audit.verifiedAssets[0].path, '/logo.svg');
+});

package/src/arc/__tests__/site-data-scope.test.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { parseSource } = require('../ast.cjs');
+const {
+  SCOPE_STATUS,
+  classifySiteDataRequirement,
+} = require('../transforms/runtime/site-data-scope.cjs');
+const { injectSiteDataHook } = require('../transforms/runtime/provider.cjs');
+
+test('site-data-scope: classifies function with siteData parameter as PROP_BOUND', () => {
+  const code = 'export function getRequiredPages(siteData: any) { return siteData.pages; }';
+  const ast = parseSource(code, 'requiredPages.ts');
+  const fn = ast.program.body[0].declaration;
+  const status = classifySiteDataRequirement(fn, 'getRequiredPages', { filePath: 'src/lib/requiredPages.ts' });
+  assert.equal(status, SCOPE_STATUS.PROP_BOUND);
+
+  const injected = injectSiteDataHook(ast, 'src/lib/requiredPages.ts');
+  assert.equal(injected, false, 'Should not inject hook when siteData is already a prop/param');
+});
+
+test('site-data-scope: classifies RootLayout mounting SiteDataProvider as PROVIDER_OWNER', () => {
+  const code = `
+    export default function RootLayout({ children }: { children: any }) {
+      return (
+        <html>
+          <body>
+            <SiteDataProvider initialSiteData={initialSiteData}>
+              {children}
+            </SiteDataProvider>
+          </body>
+        </html>
+      );
+    }
+  `;
+  const ast = parseSource(code, 'layout.tsx');
+  const fn = ast.program.body[0].declaration;
+  const status = classifySiteDataRequirement(fn, 'RootLayout', {
+    filePath: 'src/app/layout.tsx',
+    mountsProvider: true,
+    isServerComponent: true,
+  });
+  assert.equal(status, SCOPE_STATUS.PROVIDER_OWNER);
+
+  const injected = injectSiteDataHook(ast, 'src/app/layout.tsx');
+  assert.equal(injected, false, 'Should not inject hook into RootLayout or Provider owner');
+});
+
+test('site-data-scope: classifies async function as SERVER_BOUNDARY', () => {
+  const code = `
+    export default async function Page() {
+      const data = await fetch('https://api.example.com');
+      return <div>{siteData.title}</div>;
+    }
+  `;
+  const ast = parseSource(code, 'page.tsx');
+  const fn = ast.program.body[0].declaration;
+  const status = classifySiteDataRequirement(fn, 'Page', { filePath: 'src/app/page.tsx', isServerComponent: true });
+  assert.equal(status, SCOPE_STATUS.SERVER_BOUNDARY);
+
+  const injected = injectSiteDataHook(ast, 'src/app/page.tsx', { isServerComponent: true });
+  assert.equal(injected, false, 'Should not inject hook into async server component');
+});
+
+test('site-data-scope: classifies plain utility function without JSX as UTILITY_FUNCTION', () => {
+  const code = `
+    export function calculateTotal(items: any[]) {
+      return items.reduce((acc, x) => acc + x.price, 0);
+    }
+  `;
+  const ast = parseSource(code, 'utils.ts');
+  const fn = ast.program.body[0].declaration;
+  const status = classifySiteDataRequirement(fn, 'calculateTotal', { filePath: 'src/lib/utils.ts' });
+  assert.equal(status, SCOPE_STATUS.UTILITY_FUNCTION);
+
+  const injected = injectSiteDataHook(ast, 'src/lib/utils.ts');
+  assert.equal(injected, false, 'Should not inject hook into utility functions');
+});
+
+test('site-data-scope: classifies React component referencing siteData as HOOK_SAFE', () => {
+  const code = `
+    export function HeroBanner() {
+      return <h1>{siteData.home.heroTitle}</h1>;
+    }
+  `;
+  const ast = parseSource(code, 'HeroBanner.tsx');
+  const fn = ast.program.body[0].declaration;
+  const status = classifySiteDataRequirement(fn, 'HeroBanner', { filePath: 'src/components/HeroBanner.tsx', isClientComponent: true });
+  assert.equal(status, SCOPE_STATUS.HOOK_SAFE);
+
+  const injected = injectSiteDataHook(ast, 'src/components/HeroBanner.tsx', { isClientComponent: true });
+  assert.equal(injected, true, 'Should safely inject hook into valid UI component');
+});

package/src/arc/__tests__/transform-proof.test.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { TransformProof, ProofRegistry } = require('../transform-proof.cjs');
+
+test('transform-proof: records valid proof object and verifies preconditions', () => {
+  const proof = new TransformProof({
+    type: 'TEXT_BIND',
+    source: { file: 'Hero.tsx', loc: '42:6', tag: 'h1', originalText: 'Vanta Aero' },
+    target: { path: 'home.hero.title', type: 'text', section: 'hero' },
+    preconditions: ['client-safe', 'leaf-node', 'content-owned'],
+    verification: { astParsed: true, contractValid: true, designPreserved: true },
+  });
+
+  assert.equal(proof.isVerified(), true);
+  assert.equal(proof.type, 'TEXT_BIND');
+  assert.equal(proof.target.path, 'home.hero.title');
+  assert.equal(proof.preconditions.length, 3);
+});
+
+test('transform-proof: ProofRegistry enforces phase invariants against planned count', () => {
+  const registry = new ProofRegistry();
+  registry.record({
+    type: 'TEXT_BIND',
+    source: { file: 'Hero.tsx', loc: '10:2' },
+    target: { path: 'home.hero.title', type: 'text' },
+  });
+  registry.record({
+    type: 'ACTION_SPLIT',
+    source: { file: 'Hero.tsx', loc: '15:2' },
+    target: { path: 'home.hero.ctaLabel', type: 'text' },
+  });
+
+  // Test passed invariants
+  const passCheck = registry.verifyPhaseInvariants({ plannedCount: 2, boundCount: 2, schemaPathCount: 2 });
+  assert.equal(passCheck.passed, true);
+
+  // Test violation when planned exceeds recorded proofs
+  const failCheck = registry.verifyPhaseInvariants({ plannedCount: 3, boundCount: 2, schemaPathCount: 2 });
+  assert.equal(failCheck.passed, false);
+  assert.ok(failCheck.violations[0].includes('Phase Invariant Violation'));
+});

package/src/arc/__tests__/vanta-regressions.test.cjs

@@ -0,0 +1,110 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { parseSource, printSource } = require('../ast.cjs');
+const { injectSiteDataHook } = require('../transforms/runtime/provider.cjs');
+const { instrumentPageKey } = require('../transforms/routing/page-key.cjs');
+const { normalizeFieldType, sanitizeEditorSections } = require('../fivora-schema-authority.cjs');
+const { auditProjectAssets } = require('../asset-auditor.cjs');
+const { recoverCandidateConfidence } = require('../confidence-recovery.cjs');
+
+test('vanta-regressions: RootLayout server component is never injected with useSiteData hook', () => {
+  const code = `
+    export default function RootLayout({ children }: { children: any }) {
+      return (
+        <html>
+          <body>
+            <SiteDataProvider initialSiteData={initialSiteData}>
+              {children}
+            </SiteDataProvider>
+          </body>
+        </html>
+      );
+    }
+  `;
+  const ast = parseSource(code, 'layout.tsx');
+  const injected = injectSiteDataHook(ast, 'src/app/layout.tsx', { isServerComponent: true, mountsProvider: true });
+  assert.equal(injected, false, 'RootLayout mounting SiteDataProvider must NEVER receive useSiteData');
+  const result = printSource(ast, code);
+  assert.doesNotMatch(result, /useSiteData\(\)/);
+});
+
+test('vanta-regressions: getRequiredPages(siteData) parameter is never shadowed or duplicated', () => {
+  const code = `
+    export function getRequiredPages(siteData: any) {
+      if (Array.isArray(siteData?.pages)) return siteData.pages;
+      return ['home', 'shop'];
+    }
+  `;
+  const ast = parseSource(code, 'requiredPages.ts');
+  const injected = injectSiteDataHook(ast, 'src/lib/requiredPages.ts');
+  assert.equal(injected, false, 'Functions with siteData parameter must NEVER have hook injected');
+  const result = printSource(ast, code);
+  assert.doesNotMatch(result, /const siteData = useSiteData\(\)/);
+});
+
+test('vanta-regressions: schema type "currency" is auto-normalized to "text"', () => {
+  assert.equal(normalizeFieldType('currency', 'priceLkrLabel'), 'text');
+});
+
+test('vanta-regressions: duplicate path site.announcement.linkUrl across sections is eliminated', () => {
+  const sections = [
+    {
+      id: 'site_announcement',
+      path: 'site.announcement',
+      type: 'object',
+      fields: [{ key: 'linkUrl', type: 'url', label: 'Link' }],
+    },
+    {
+      id: 'site',
+      path: 'site',
+      type: 'object',
+      fields: [{ key: 'announcement.linkUrl', type: 'url', label: 'Duplicate' }],
+    },
+  ];
+  const clean = sanitizeEditorSections(sections);
+  const dup = clean[1].fields.find((f) => f.key === 'announcement.linkUrl');
+  assert.equal(dup, undefined, 'Duplicate leaf path must be eliminated');
+});
+
+test('vanta-regressions: custom component on /products/detail receives data-preview-page-key', () => {
+  const code = 'export default function Detail() { return <PlatformProductDetail item={shoe} />; }';
+  const res = instrumentPageKey(code, 'src/app/products/detail/page.tsx', 'products_detail');
+  assert.equal(res.updated, true);
+  assert.match(res.code, /data-preview-page-key="products_detail"/);
+});
+
+test('vanta-regressions: missing /fivora-logo.png is flagged before runtime', () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-vanta-'));
+  const publicDir = path.join(tempDir, 'public');
+  fs.mkdirSync(publicDir, { recursive: true });
+  fs.writeFileSync(path.join(publicDir, 'logo.svg'), '<svg></svg>');
+
+  const siteData = {
+    content: {
+      common: {
+        logoUrl: '/fivora-logo.png',
+      },
+    },
+  };
+  const audit = auditProjectAssets(tempDir, siteData);
+  assert.equal(audit.passed, false);
+  assert.equal(audit.missingAssets[0].path, '/fivora-logo.png');
+});
+
+test('vanta-regressions: low-confidence candidate (< 0.60) is elevated by recovery pipeline', () => {
+  const candidate = {
+    tag: 'h2',
+    componentName: 'FeatureBanner',
+    className: 'text-2xl font-bold text-slate-900',
+    value: 'Designed in Colombo, Built for the Street',
+    confidence: 0.45,
+  };
+  const rec = recoverCandidateConfidence(candidate);
+  assert.equal(rec.recovered, true);
+  assert.ok(rec.confidence >= 0.65);
+});

package/src/arc/acceptance-gates.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 /**
- * Deneb ARC v3 — Production Acceptance Gates Engine
- * Implements the 12-Gate Acceptance Matrix recommended for enterprise Next.js -> Fivora compilation.
+ * Deneb ARC v3 — Production 15-Gate Acceptance Matrix (P12)
+ * Comprehensive compiler gates guaranteeing 100% verifiable Fivora conversion.
  */
 const ACCEPTANCE_GATES = {
   SOURCE_ANALYSIS: 'Source Analysis',
@@ -17,10 +17,13 @@ const ACCEPTANCE_GATES = {
   ROUTE_COVERAGE: 'Route Coverage',
   DESIGN_PRESERVATION: 'Design Preservation',
   CONTROL_ONLY_PROTECTION: 'Control-Only Protection',
+  ASSET_INTEGRITY: 'Asset Integrity',
+  RSC_CLIENT_INTEGRITY: 'RSC & Client Hook Integrity',
+  BROWSER_CONSOLE_CLEANLINESS: 'Browser Console Cleanliness',
 };
 
 /**
- * Evaluates compilation metrics against the 12-Gate Acceptance Matrix.
+ * Evaluates compilation metrics against the 15-Gate Acceptance Matrix.
  */
 function evaluateAcceptanceGates(metrics = {}) {
   const gates = {
@@ -88,6 +91,21 @@ function evaluateAcceptanceGates(metrics = {}) {
       passed: Boolean(metrics.controlOnlyValid !== false),
       critical: true,
     },
+    assetIntegrity: {
+      name: ACCEPTANCE_GATES.ASSET_INTEGRITY,
+      passed: Boolean(metrics.assetIntegrityPassed !== false),
+      critical: true,
+    },
+    rscClientIntegrity: {
+      name: ACCEPTANCE_GATES.RSC_CLIENT_INTEGRITY,
+      passed: Boolean(metrics.rscIntegrityPassed !== false),
+      critical: true,
+    },
+    browserConsoleCleanliness: {
+      name: ACCEPTANCE_GATES.BROWSER_CONSOLE_CLEANLINESS,
+      passed: Boolean(metrics.consoleCleanlinessPassed !== false),
+      critical: false,
+    },
   };
 
   const criticalGates = Object.values(gates).filter((g) => g.critical);