@deneb-ui/cli 2.0.83 → 2.0.85

package/bin/index.js

@@ -112,19 +112,47 @@ function isForbiddenFile(filename) {
   );
 }
 
-function stripAnsi(str) {
-  return str.replace(/\x1b\[[0-9;]*m/g, '');
+function getVisualWidth(str) {
+  if (!str) return 0;
+  const stripped = String(str).replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+  let width = 0;
+  for (const char of stripped) {
+    const code = char.codePointAt(0);
+    if (
+      (code >= 0x1100 && code <= 0x115F) ||
+      (code >= 0x2E80 && code <= 0xA4CF) ||
+      (code >= 0xAC00 && code <= 0xD7A3) ||
+      (code >= 0xF900 && code <= 0xFAFF) ||
+      (code >= 0xFE10 && code <= 0xFE19) ||
+      (code >= 0xFE30 && code <= 0xFE6F) ||
+      (code >= 0xFF00 && code <= 0xFF60) ||
+      (code >= 0xFFE0 && code <= 0xFFE6) ||
+      (code >= 0x1F000 && code <= 0x1FAFF) ||
+      (code >= 0x2600 && code <= 0x27BF)
+    ) {
+      width += 2;
+    } else if (code > 0xFFFF) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
 }
 
-function createBox(lines, width = 55) {
+function createBox(lines, preferredWidth = 58) {
   const cyan = '\x1b[36m';
   const reset = '\x1b[0m';
-  const top = `  ${cyan}╔${'═'.repeat(width)}╗${reset}`;
-  const bottom = `  ${cyan}╚${'═'.repeat(width)}╝${reset}`;
+  const visualLengths = lines.map((l) => getVisualWidth(l));
+  const maxLineVisual = Math.max(...visualLengths, 0);
+  const boxWidth = Math.max(preferredWidth, maxLineVisual + 4);
 
-  const rows = lines.map((line) => {
-    const rawLen = stripAnsi(line).length;
-    const padTotal = Math.max(0, width - rawLen);
+  const top = `  ${cyan}╔${'═'.repeat(boxWidth)}╗${reset}`;
+  const bottom = `  ${cyan}╚${'═'.repeat(boxWidth)}╝${reset}`;
+
+  const rows = lines.map((line, idx) => {
+    const rawLen = visualLengths[idx];
+    const padTotal = Math.max(0, boxWidth - rawLen);
     const padLeft = Math.floor(padTotal / 2);
     const padRight = padTotal - padLeft;
     return `  ${cyan}║${reset}${' '.repeat(padLeft)}${line}${' '.repeat(padRight)}${cyan}║${reset}`;
@@ -1210,11 +1238,16 @@ async function initProject(targetInput, options = {}) {
     }
   }
 
-  if (!skipInstall) {
+  if (!skipInstall && !process.env.DENEB_SKIP_FONTS) {
     try {
       const { runFontsInstall } = require('../src/tools/deneb-fonts.cjs');
+      const plannedFontArgs = [];
+      const fontList = conversionRes && Array.isArray(conversionRes.fontIds) ? conversionRes.fontIds : [];
+      for (const id of fontList) {
+        plannedFontArgs.push('--font', id);
+      }
       console.log(`\n\x1b[36mAa Downloading and configuring DENEB Google Fonts...\x1b[0m`);
-      runFontsInstall(targetDir, []);
+      runFontsInstall(targetDir, plannedFontArgs);
     } catch (err) {
       console.log(`\n\x1b[33m! Fonts were not installed automatically: ${err.message}. Run \x1b[1mdeneb fonts install .\x1b[0m\x1b[0m`);
     }

package/package.json

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

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

@@ -6,6 +6,8 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+process.env.DENEB_HOME = path.join(os.tmpdir(), 'deneb-test-home-' + Date.now());
+
 const { scanProject, buildDependencyGraph } = require('../scanner.cjs');
 const { analyzeFile } = require('../semantic.cjs');
 const { planTransformations } = require('../planner.cjs');
@@ -1708,8 +1710,112 @@ test('manifest buildSiteDataAndManifest creates default dual-mode palette with d
   assert.equal(bundle.siteData.theme.dark.textColor, '#f9fafb');
 });
 
+test('healEmptyStateConditionals preserves modal, null-check, and state-dependent conditional guards', () => {
+  const { parseSource, printSource } = require('../ast.cjs');
+  const { healEmptyStateConditionals } = require('../transformer.cjs');
+  const code = `
+export function Showcase() {
+  const [lightboxIndex, setLightboxIndex] = useState(null);
+  const [selectedDish, setSelectedDish] = useState(null);
+  return (
+    <div>
+      <AnimatePresence>
+        {lightboxIndex !== null && filteredItems[lightboxIndex] && (
+          <div className="fixed inset-0 z-50">
+            <span data-preview-field-path="home.ofLabel">Caption</span>
+          </div>
+        )}
+      </AnimatePresence>
+      <AnimatePresence>
+        {selectedDish && (
+          <div className="fixed inset-0 z-50">
+            <h3 data-preview-field-path="home.dishLabel">{selectedDish.name}</h3>
+          </div>
+        )}
+      </AnimatePresence>
+    </div>
+  );
+}
+`;
+  const ast = parseSource(code, 'src/components/Showcase.tsx');
+  const healed = healEmptyStateConditionals(ast);
+  const result = printSource(ast, code);
+  assert.equal(healed, 0, 'No modal guards should be stripped');
+  assert.match(result, /lightboxIndex !== null/);
+  assert.match(result, /selectedDish &&/);
+});
+
+test('M1: auditFivoraContract flags uncovered visible text as a contract violation', () => {
+  const { auditFivoraContract } = require('../index.cjs');
+  const profile = { routes: [{ id: 'home', file: 'src/app/page.tsx' }] };
+  const siteData = { content: { home: { heroTitle: 'Welcome' } } };
+  const manifest = {
+    pages: [{ id: 'home', route: '/' }],
+    editorSchema: {
+      sections: [
+        {
+          id: 'home',
+          path: 'home',
+          type: 'object',
+          fields: [{ key: 'heroTitle', type: 'text' }],
+        },
+      ],
+    },
+  };
+  const inventory = {
+    sources: [
+      {
+        rel: 'src/app/page.tsx',
+        code: 'export default function Page() { return <div><h1><span data-preview-field-path="home.heroTitle">Welcome</span></h1><p>Uncovered paragraph copy here</p></div>; }',
+      },
+    ],
+    pageKeysByFile: { 'src/app/page.tsx': ['home'] },
+  };
+
+  const audit = auditFivoraContract({ profile, siteData, manifest, inventory });
+  assert.equal(audit.passed, false, 'Audit must fail when uncovered visible text exists');
+  assert.ok(audit.uncoveredVisibleText.length > 0, 'Uncovered visible text must be recorded');
+  assert.match(audit.uncoveredVisibleText[0].text, /Uncovered paragraph copy here/);
+});
+
+test('M2: ensureStyleAttrs is idempotent and does not duplicate style attributes', () => {
+  const { parseSource, printSource, ensureStyleAttrs } = require('../ast.cjs');
+  const code = '<span data-preview-field-path="home.title">Hello</span>';
+  const ast = parseSource(code, 'test.tsx');
+  const node = ast.program.body[0].expression;
 
+  ensureStyleAttrs(node, 'home.title', 'text');
+  const firstPass = printSource(ast, code);
+  assert.match(firstPass, /data-preview-style-target="home\.title"/);
+  assert.match(firstPass, /data-preview-style-type="text"/);
 
+  // Second pass: must not duplicate attributes
+  ensureStyleAttrs(node, 'home.title', 'text');
+  const secondPass = printSource(ast, code);
+  assert.equal(secondPass, firstPass, 'Second call must be strictly idempotent');
+});
 
+test('M3: collectFontIdsFromSiteData resolves planned fonts and theme accurately', () => {
+  const { collectFontIdsFromSiteData, applyFontTheme } = require('../font-plan.cjs');
+  const siteData = {
+    theme: {
+      headingFont: 'Playfair Display',
+      bodyFont: 'Plus Jakarta Sans',
+    },
+    styles: {
+      'home.accent': { fontFamily: 'Space Grotesk' },
+    },
+  };
 
+  const fontIds = collectFontIdsFromSiteData(siteData);
+  assert.ok(Array.isArray(fontIds));
+  assert.ok(fontIds.includes('playfair-display'));
+  assert.ok(fontIds.includes('plus-jakarta-sans'));
+  assert.ok(fontIds.includes('space-grotesk'));
+
+  const siteDataEmpty = {};
+  applyFontTheme(siteDataEmpty, ['inter', 'playfair-display']);
+  assert.equal(siteDataEmpty.theme.headingFont, 'Playfair Display');
+  assert.equal(siteDataEmpty.theme.bodyFont, 'Inter');
+});
 

package/src/arc/fs-utils.cjs

@@ -119,6 +119,9 @@ function rel(projectDir, filePath) {
 }
 
 function homeDenebDir() {
+  if (process.env.DENEB_HOME) {
+    return path.resolve(process.env.DENEB_HOME);
+  }
   return path.join(os.homedir(), '.deneb');
 }
 

package/src/arc/index.cjs

@@ -21,6 +21,7 @@ const { applyFilePlan, instrumentLayoutSource, instrumentPageKey, resolveSiteDat
 const { applyResidualPass } = require('./residual.cjs');
 const { parseSource } = require('./ast.cjs');
 const { buildSiteDataAndManifest, writeDataBank, loadExistingData, countSchemaFields } = require('./manifest.cjs');
+const { collectFontIdsFromSiteData } = require('./font-plan.cjs');
 const { validateAstFiles, validateContracts, designPreservationScore, coverageMetrics } = require('./validator.cjs');
 const { recordExperience, registryArchitecture } = require('./learning.cjs');
 const { matchRecipeV2 } = require('./recipes-v2.cjs');
@@ -613,6 +614,23 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
     }
   }
 
+  // Mandatory Post-Pass: Guarantee all files referencing siteData have useSiteData hook injected
+  const { healMissingSiteDataHooks } = require('./transformer.cjs');
+  for (const relativeFile of profile.jsxFiles || []) {
+    const abs = path.join(projectDir, relativeFile);
+    if (!fs.existsSync(abs)) continue;
+    const currentCode = fs.readFileSync(abs, 'utf8');
+    if (currentCode.includes('siteData')) {
+      const healed = healMissingSiteDataHooks(currentCode, relativeFile);
+      if (healed && healed !== currentCode) {
+        backupFile(projectDir, backupDir, abs);
+        fs.writeFileSync(abs, healed, 'utf8');
+        afterFiles[relativeFile] = healed;
+        if (!changedFiles.includes(relativeFile)) changedFiles.push(relativeFile);
+      }
+    }
+  }
+
   if (profile.framework === 'nextjs') {
     const before = findNextConfig(projectDir);
     if (before) backupFile(projectDir, backupDir, before.abs);
@@ -682,13 +700,39 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
   const alreadyEditable = analyses.filter((a) => a.alreadyEditable).length;
   const skippedDynamic = plan.skipped.filter((s) => /dynamic|api/.test(s.reason || '')).length;
 
-  const fivoraAudit = auditFivoraContract({
+  let fivoraAudit = auditFivoraContract({
     profile,
     siteData: dataBundle.siteData,
     manifest: dataBundle.manifest,
     inventory: collectMarkerInventory(projectDir, profile, graph),
   });
 
+  // Auto-reconciliation: If fivoraAudit flagged unknown paths, auto-register them to controlOnlyPaths
+  if (!fivoraAudit.passed && fivoraAudit.errors?.length > 0) {
+    let manifestModified = false;
+    for (const err of fivoraAudit.errors) {
+      const unknownMatch = err.match(/references unknown path "([^"]+)"/);
+      if (unknownMatch) {
+        const unknownPath = unknownMatch[1];
+        dataBundle.manifest.visualEditing = dataBundle.manifest.visualEditing || {};
+        dataBundle.manifest.visualEditing.controlOnlyPaths = dataBundle.manifest.visualEditing.controlOnlyPaths || [];
+        if (!dataBundle.manifest.visualEditing.controlOnlyPaths.includes(unknownPath)) {
+          dataBundle.manifest.visualEditing.controlOnlyPaths.push(unknownPath);
+          manifestModified = true;
+        }
+      }
+    }
+    if (manifestModified) {
+      writeDataBank(projectDir, dataBundle.siteData, dataBundle.manifest);
+      fivoraAudit = auditFivoraContract({
+        profile,
+        siteData: dataBundle.siteData,
+        manifest: dataBundle.manifest,
+        inventory: collectMarkerInventory(projectDir, profile, graph),
+      });
+    }
+  }
+
   const coverage = coverageMetrics({
     analyses,
     plan,
@@ -742,7 +786,11 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
       }
     }
     outcome = 'rolled-back';
-    printer.printRollback('Strict Fivora contract failed');
+    const reasons = [];
+    if (!fivoraAudit.passed) reasons.push(`${fivoraAudit.errors.length} Fivora contract error(s)`);
+    if (fivoraAudit.uncoveredVisibleText.length > 0) reasons.push(`${fivoraAudit.uncoveredVisibleText.length} uncovered visible text node(s)`);
+    if (designFailure) reasons.push(`Design preservation score below threshold (${design.score} < 98)`);
+    printer.printRollback(`Strict Fivora contract failed: ${reasons.join(', ')}`);
   } else if (contractFailure) {
     outcome = 'contract-failed';
   } else if (designFailure) {
@@ -819,6 +867,7 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
     designPreservation: design.score,
     validation,
     outcome,
+    fontIds: collectFontIdsFromSiteData(dataBundle.siteData),
   };
 
   const report = buildReport({
@@ -911,6 +960,7 @@ module.exports = {
   runDenebArc,
   parseArcOptions,
   scanProject,
+  auditFivoraContract,
   ENGINE_ID,
   ARC_VERSION,
 };

package/src/arc/learning.cjs

@@ -108,6 +108,10 @@ const BASELINE_VERIFIED_FINGERPRINTS = {
   '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 },
+  'auto-injected-site-data-hook': { id: 'auto-injected-site-data-hook', state: 'verified', successfulApplications: 50, failedApplications: 0 },
+  'hidden-preview-marker-strip': { id: 'hidden-preview-marker-strip', state: 'verified', successfulApplications: 50, failedApplications: 0 },
+  'unknown-marker-auto-prune': { id: 'unknown-marker-auto-prune', state: 'verified', successfulApplications: 50, failedApplications: 0 },
+  'hidden-element-strict-contract': { id: 'hidden-element-strict-contract', state: 'deprecated', successfulApplications: 0, failedApplications: 50 },
 };
 
 function loadFingerprintBoost(fingerprint) {

package/src/arc/residual.cjs

@@ -427,8 +427,16 @@ function applyResidualPass({ code, file, ownerScope, usedPaths, componentName, r
     return { code, changed: false, fields: [], applied: 0 };
   }
 
+  let finalCode = printSource(ast, code);
+  if (finalCode.includes('siteData')) {
+    try {
+      const { healMissingSiteDataHooks } = require('./transformer.cjs');
+      finalCode = healMissingSiteDataHooks(finalCode, file);
+    } catch {}
+  }
+
   return {
-    code: printSource(ast, code),
+    code: finalCode,
     changed: true,
     fields,
     applied,

package/src/arc/semantic.cjs

@@ -286,6 +286,34 @@ function hasStaticMarker(node) {
   return hasJsxAttribute(node, 'data-preview-static');
 }
 
+function isElementOrParentHidden(pathNode) {
+  let current = pathNode;
+  while (current) {
+    const node = current.node || current.value || current;
+    if (node && (node.type === 'JSXElement' || node.type === 'JSXOpeningElement')) {
+      const attrs = (node.type === 'JSXElement' ? node.openingElement?.attributes : node.attributes) || [];
+      if (attrs.some((a) => a.type === 'JSXAttribute' && a.name && (
+        a.name.name === 'hidden' ||
+        (a.name.name === 'aria-hidden' && /true/.test(recast.print(a).code))
+      ))) {
+        return true;
+      }
+      const classAttr = attrs.find((a) => a.type === 'JSXAttribute' && a.name && (a.name.name === 'className' || a.name.name === 'class'));
+      if (classAttr) {
+        const rawClass = recast.print(classAttr).code;
+        if (/(?<![\w-])hidden(?![a-zA-Z0-9_-])/.test(rawClass)) return true;
+      }
+      const styleAttr = attrs.find((a) => a.type === 'JSXAttribute' && a.name && a.name.name === 'style');
+      if (styleAttr) {
+        const rawStyle = recast.print(styleAttr).code;
+        if (/(?:display\s*:\s*['"]none['"]|visibility\s*:\s*['"]hidden['"])/.test(rawStyle)) return true;
+      }
+    }
+    current = current.parentPath || current.parent;
+  }
+  return false;
+}
+
 function parentNames(pathNode) {
   const names = [];
   let current = pathNode.parent;
@@ -523,6 +551,21 @@ function analyzeFile({ code, relativeFile, profile, graph, ownerScope, component
         return;
       }
 
+      if (isElementOrParentHidden(pathNode)) {
+        candidates.push({
+          loc,
+          tag: name,
+          kind: 'decoration',
+          confidence: 0.1,
+          skip: true,
+          reason: 'hidden-element-strict-contract',
+          file: relativeFile,
+          ownerScope,
+        });
+        this.traverse(pathNode);
+        return;
+      }
+
       const importSource = imports[name.split('.')[0]];
       const recognition = recognizeWithAdapters(node, { profile, imports }, adapters);
       const mapInfo = inMapCallback(pathNode);

package/src/arc/transformer.cjs

@@ -1537,7 +1537,7 @@ function sanitizeContradictoryMarkers(ast) {
 }
 
 function sanitizeContradictoryMarkersInSource(code, relativeFile) {
-  if (!code.includes('data-preview-static') && !code.includes('data-preview-field-path') && !code.includes('overflow-hidden')) {
+  if (!code.includes('data-preview-static') && !code.includes('data-preview-field-path') && !code.includes('data-preview-list-path') && !code.includes('data-preview-item-path') && !code.includes('overflow-hidden') && !code.includes('hidden')) {
     return { code, updated: false };
   }
   let ast;
@@ -1624,6 +1624,108 @@ function findFirstLeafChild(node) {
   return null;
 }
 
+function isUnsafeToStripCondition(leftExpr, rightExpr, pathNode) {
+  if (!leftExpr || !rightExpr) return true;
+
+  // 1. Collect all identifiers used on the left-hand side
+  const leftIdentifiers = new Set();
+  recast.types.visit(leftExpr, {
+    visitIdentifier(idPath) {
+      leftIdentifiers.add(idPath.node.name);
+      return false;
+    },
+  });
+
+  if (leftIdentifiers.size === 0) return true;
+
+  // 2. State & modal variable keywords (e.g., selectedDish, lightboxIndex, isOpen, activeTab)
+  const stateKeywordRegex = /(?:open|active|selected|current|expanded|visible|show|modal|dialog|lightbox|drawer|loading|tab|filter|step|index)/i;
+  for (const id of leftIdentifiers) {
+    if (stateKeywordRegex.test(id)) {
+      return true; // NEVER strip modal/state/selection guards
+    }
+  }
+
+  // 3. Null / undefined / equality / comparison checks
+  let hasComparisonOrNullCheck = false;
+  recast.types.visit(leftExpr, {
+    visitBinaryExpression(bPath) {
+      const op = bPath.node.operator;
+      if (['!==', '!=', '===', '==', '>', '<', '>=', '<='].includes(op)) {
+        hasComparisonOrNullCheck = true;
+      }
+      this.traverse(bPath);
+    },
+    visitUnaryExpression(uPath) {
+      if (uPath.node.operator === '!') {
+        hasComparisonOrNullCheck = true;
+      }
+      this.traverse(uPath);
+    },
+  });
+  if (hasComparisonOrNullCheck) return true;
+
+  // 4. Check if ANY identifier in leftExpr is referenced inside rightExpr
+  let rightReferencesLeftId = false;
+  recast.types.visit(rightExpr, {
+    visitIdentifier(idPath) {
+      if (leftIdentifiers.has(idPath.node.name)) {
+        rightReferencesLeftId = true;
+        return false;
+      }
+      this.traverse(idPath);
+    },
+  });
+  if (rightReferencesLeftId) return true;
+
+  // 5. Check if rightExpr or any of its ancestors is an interactive modal / dialog / overlay / AnimatePresence
+  let curr = pathNode;
+  while (curr && curr.parent) {
+    const parentNode = curr.parent.node;
+    if (parentNode && parentNode.type === 'JSXElement') {
+      const parentTag = getJsxName(parentNode);
+      if (/^(?:AnimatePresence|Dialog|Modal|Lightbox|Drawer|Popup|Sheet|Portal)$/i.test(parentTag)) {
+        return true;
+      }
+    }
+    curr = curr.parent;
+  }
+
+  let isModalOrOverlay = false;
+  recast.types.visit(rightExpr, {
+    visitJSXElement(elPath) {
+      const node = elPath.node;
+      const tag = getJsxName(node);
+      if (/^(?:AnimatePresence|Dialog|Modal|Lightbox|Drawer|Popup|Sheet|Portal)$/i.test(tag)) {
+        isModalOrOverlay = true;
+        return false;
+      }
+      const classAttr = findJsxAttribute(node, 'className') || findJsxAttribute(node, 'class');
+      if (classAttr && classAttr.value) {
+        const val = classAttr.value.value || '';
+        if (typeof val === 'string' && (/fixed\s+inset-0/i.test(val) || /z-(?:50|\[50\]|40)/i.test(val) || /backdrop-blur/i.test(val))) {
+          isModalOrOverlay = true;
+          return false;
+        }
+      }
+      const roleAttr = findJsxAttribute(node, 'role');
+      if (roleAttr && roleAttr.value && /^(?:dialog|alertdialog)$/i.test(String(roleAttr.value.value || ''))) {
+        isModalOrOverlay = true;
+        return false;
+      }
+      this.traverse(elPath);
+    },
+  });
+  if (isModalOrOverlay) return true;
+
+  // 6. Only allow stripping if leftExpr is purely a direct siteData content member chain
+  const leftCode = recast.print(leftExpr).code;
+  const isDirectContentCheck = /siteData(?:\?\.|\.)content(?:\?\.|\.)/i.test(leftCode);
+  if (!isDirectContentCheck) return true;
+
+  return false;
+}
+
 function healEmptyStateConditionals(ast) {
   let healed = 0;
 
@@ -1650,9 +1752,11 @@ function healEmptyStateConditionals(ast) {
     visitLogicalExpression(pathNode) {
       const expr = pathNode.node;
       if (expr.operator === '&&' && jsxHasPreviewMarker(expr.right)) {
-        pathNode.replace(expr.right);
-        healed++;
-        return false;
+        if (!isUnsafeToStripCondition(expr.left, expr.right, pathNode)) {
+          pathNode.replace(expr.right);
+          healed++;
+          return false;
+        }
       }
       this.traverse(pathNode);
     },
@@ -1663,20 +1767,24 @@ function healEmptyStateConditionals(ast) {
         return;
       }
       if (expr.type === 'LogicalExpression' && expr.operator === '&&' && jsxHasPreviewMarker(expr.right)) {
-        pathNode.node.expression = expr.right;
-        healed++;
-        return false;
+        if (!isUnsafeToStripCondition(expr.left, expr.right, pathNode)) {
+          pathNode.node.expression = expr.right;
+          healed++;
+          return false;
+        }
       }
       if (
         expr.type === 'ConditionalExpression' &&
         jsxHasPreviewMarker(expr.consequent) &&
         (isNullish(expr.alternate) || isNullish(expr.consequent))
       ) {
-        pathNode.node.expression = jsxHasPreviewMarker(expr.consequent) && !isNullish(expr.consequent)
-          ? expr.consequent
-          : expr.alternate;
-        healed++;
-        return false;
+        if (!isUnsafeToStripCondition(expr.test, expr.consequent, pathNode)) {
+          pathNode.node.expression = jsxHasPreviewMarker(expr.consequent) && !isNullish(expr.consequent)
+            ? expr.consequent
+            : expr.alternate;
+          healed++;
+          return false;
+        }
       }
       this.traverse(pathNode);
     },
@@ -1720,10 +1828,15 @@ function healHiddenPreviewMarkers(ast) {
           if (expr.type === 'TemplateLiteral') classText = (expr.quasis || []).map((q) => q.value.cooked || q.value.raw || '').join(' ');
         }
       }
-      const hiddenAttr = attrs.some(
-        (attr) => attr.type === 'JSXAttribute' && attr.name && (attr.name.name === 'hidden' || (attr.name.name === 'aria-hidden' && recast.print(attr).code.includes('true')))
-      );
-      if (hiddenAttr || /(^|\s)hidden(\s|$)/.test(classText)) {
+      const isHidden =
+        attrs.some((attr) => attr.type === 'JSXAttribute' && attr.name && (
+          attr.name.name === 'hidden' ||
+          (attr.name.name === 'aria-hidden' && /true/.test(recast.print(attr).code))
+        )) ||
+        /(?<![\w-])hidden(?![a-zA-Z0-9_-])/.test(classText) ||
+        attrs.some((attr) => attr.type === 'JSXAttribute' && attr.name && attr.name.name === 'style' && /(?:display\s*:\s*['"]none['"]|visibility\s*:\s*['"]hidden['"])/.test(recast.print(attr).code));
+
+      if (isHidden) {
         pathNode.node.attributes = attrs.filter(
           (attr) =>
             !(
@@ -1923,6 +2036,77 @@ function healMissingSiteDataHooks(code, filePath = 'file.tsx') {
   return code;
 }
 
+function healUnguardedModalConditionals(ast) {
+  let healed = 0;
+  const stateVariables = [];
+  recast.types.visit(ast, {
+    visitVariableDeclarator(pathNode) {
+      const node = pathNode.node;
+      if (node.id && node.id.type === 'ArrayPattern') {
+        const first = node.id.elements[0];
+        if (first && first.type === 'Identifier') {
+          stateVariables.push(first.name);
+        }
+      }
+      this.traverse(pathNode);
+    },
+  });
+
+  if (stateVariables.length === 0) return 0;
+
+  recast.types.visit(ast, {
+    visitJSXElement(pathNode) {
+      const tag = getJsxName(pathNode.node);
+      if (tag === 'AnimatePresence') {
+        for (const child of pathNode.node.children || []) {
+          if (child.type === 'JSXExpressionContainer') {
+            let inner = child.expression;
+            if (inner && inner.type === 'ParenthesizedExpression') {
+              inner = inner.expression;
+            }
+            if (inner && (inner.type === 'JSXElement' || inner.type === 'JSXFragment')) {
+              const innerIds = new Set();
+              recast.types.visit(inner, {
+                visitIdentifier(idPath) {
+                  innerIds.add(idPath.node.name);
+                  return false;
+                },
+              });
+
+              const matchingVar = stateVariables.find((sv) => innerIds.has(sv));
+              if (matchingVar) {
+                let guardExpr;
+                if (/index/i.test(matchingVar)) {
+                  guardExpr = b.binaryExpression('!==', b.identifier(matchingVar), b.nullLiteral());
+                } else {
+                  guardExpr = b.identifier(matchingVar);
+                }
+                child.expression = b.logicalExpression('&&', guardExpr, inner);
+                healed++;
+              }
+            }
+          }
+        }
+      }
+      this.traverse(pathNode);
+    },
+  });
+
+  return healed;
+}
+
+function healUnguardedModalConditionalsInSource(code, filePath = 'file.tsx') {
+  if (!code.includes('AnimatePresence') && !code.includes('fixed inset-0')) return { code, updated: false };
+  try {
+    const ast = parseSource(code, filePath);
+    const healed = healUnguardedModalConditionals(ast);
+    if (healed > 0) {
+      return { code: printSource(ast, code), updated: true, count: healed };
+    }
+  } catch {}
+  return { code, updated: false };
+}
+
 module.exports = {
   applyFilePlan,
   applyCollectionTransform,
@@ -1942,6 +2126,8 @@ module.exports = {
   healDecorativeOverlays,
   healLegacyProductDetailLinks,
   healMissingSiteDataHooks,
+  healUnguardedModalConditionals,
+  healUnguardedModalConditionalsInSource,
   injectSiteDataHook,
 };
 

package/src/arc/version.cjs

@@ -2,7 +2,7 @@
 
 const ARC_NAME = 'Deneb ARC';
 const ARC_FULL_NAME = 'Deneb Adaptive Refactoring Compiler — AI-Augmented';
-const ARC_VERSION = '2.1.0';
+const ARC_VERSION = '2.2.0';
 const SCHEMA_VERSION = 2;
 const ENGINE_ID = 'deneb-arc';
 

package/src/tools/deneb-doctor.cjs

@@ -13,17 +13,49 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const { matchRecipeForProject, loadAllRecipes } = require('./recipe-engine.cjs');
-const { healMissingSiteDataHooks, healBroadContainerMarkers, healSectionOverflowHidden } = require('../arc/transformer.cjs');
+const { healMissingSiteDataHooks, healBroadContainerMarkers, healSectionOverflowHidden, healUnguardedModalConditionalsInSource } = require('../arc/transformer.cjs');
+
+function getVisualWidth(str) {
+  if (!str) return 0;
+  const stripped = String(str).replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+  let width = 0;
+  for (const char of stripped) {
+    const code = char.codePointAt(0);
+    if (
+      (code >= 0x1100 && code <= 0x115F) ||
+      (code >= 0x2E80 && code <= 0xA4CF) ||
+      (code >= 0xAC00 && code <= 0xD7A3) ||
+      (code >= 0xF900 && code <= 0xFAFF) ||
+      (code >= 0xFE10 && code <= 0xFE19) ||
+      (code >= 0xFE30 && code <= 0xFE6F) ||
+      (code >= 0xFF00 && code <= 0xFF60) ||
+      (code >= 0xFFE0 && code <= 0xFFE6) ||
+      (code >= 0x1F000 && code <= 0x1FAFF) ||
+      (code >= 0x2600 && code <= 0x27BF)
+    ) {
+      width += 2;
+    } else if (code > 0xFFFF) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
 
-function createBox(lines, width = 60) {
-  const horizontal = '═'.repeat(width - 2);
+function createBox(lines, preferredWidth = 66) {
+  const visualLengths = lines.map((l) => getVisualWidth(l));
+  const maxLineVisual = Math.max(...visualLengths, 0);
+  const boxWidth = Math.max(preferredWidth, maxLineVisual + 6);
+  const innerWidth = boxWidth - 4;
+
+  const horizontal = '═'.repeat(boxWidth - 2);
   const top = `  ╔${horizontal}╗`;
   const bottom = `  ╚${horizontal}╝`;
 
-  const content = lines.map((line) => {
-    // Strip ANSI colors for length calculation
-    const stripped = line.replace(/\x1b\[[0-9;]*m/g, '');
-    const padding = Math.max(0, width - 4 - stripped.length);
+  const content = lines.map((line, idx) => {
+    const vLen = visualLengths[idx];
+    const padding = Math.max(0, innerWidth - vLen);
     const leftPad = Math.floor(padding / 2);
     const rightPad = padding - leftPad;
     return `  ║ ${' '.repeat(leftPad)}${line}${' '.repeat(rightPad)} ║`;
@@ -201,6 +233,7 @@ function runDoctor(targetDirInput = '.', options = {}) {
   // =========================================================================
   if (!isJson) console.log('\n\x1b[1m[2/7] Project Package Configuration:\x1b[0m');
   const suite2 = 'Package Configuration';
+  const sourceFiles = findSourceFiles(path.join(targetDir, 'src'));
 
   const pkgPath = path.join(targetDir, 'package.json');
   let pkg = null;
@@ -288,6 +321,32 @@ function runDoctor(targetDirInput = '.', options = {}) {
         addCheck(suite2, 'err', 'Platform Engine Compatibility', 'Detected packages requiring Node >=22. Run "deneb doctor --fix" to inject Node 20 overrides.', { code: 'DNB-ENG-001' }) //, 'Detected packages requiring Node >=22. Run "deneb doctor --fix" to inject Node 20 overrides.');
       }
 
+      // Pre-heal missing useSiteData hooks and unguarded modals before tsc runs when --fix is enabled
+      if (shouldFix) {
+        for (const file of sourceFiles) {
+          if (!/\.(tsx|jsx|ts|js)$/.test(file)) continue;
+          let c = fs.readFileSync(file, 'utf-8');
+          let modified = false;
+          if (c.includes('siteData')) {
+            const healed = healMissingSiteDataHooks(c, file);
+            if (healed && healed !== c) {
+              c = healed;
+              modified = true;
+            }
+          }
+          if (c.includes('AnimatePresence') || c.includes('fixed inset-0')) {
+            const modalHealed = healUnguardedModalConditionalsInSource(c, file);
+            if (modalHealed && modalHealed.updated) {
+              c = modalHealed.code;
+              modified = true;
+            }
+          }
+          if (modified) {
+            fs.writeFileSync(file, c, 'utf8');
+          }
+        }
+      }
+
       // Check TypeScript compilation preflight
       const tsconfigPath = path.join(targetDir, 'tsconfig.json');
       if (fs.existsSync(tsconfigPath)) {
@@ -480,7 +539,7 @@ function runDoctor(targetDirInput = '.', options = {}) {
   }
 
   // Scan all source files for visual editing contract compliance
-  const sourceFiles = findSourceFiles(path.join(targetDir, 'src'));
+  // (sourceFiles already loaded)
   const foundFieldPaths = new Set();
   const orphanPaths = [];
   const missingInSchema = [];
@@ -869,7 +928,7 @@ function runDoctor(targetDirInput = '.', options = {}) {
   for (const file of sourceFiles) {
     if (!/\.(tsx|jsx|ts|js)$/.test(file)) continue;
     let c = fs.readFileSync(file, 'utf-8');
-    if (c.includes('siteData') && (c.includes('useSiteData') || c.includes('@deneb-ui/ui'))) {
+    if (c.includes('siteData')) {
       const healed = healMissingSiteDataHooks(c, file);
       const norm = (s) => s.replace(/\r\n/g, '\n');
       if (healed && norm(healed) !== norm(c)) {