@deneb-ui/cli 2.0.112 → 2.0.114

package/src/arc/component-registry.cjs

@@ -17,6 +17,8 @@ const KNOWN_EDITABLE_COMPONENTS = new Set([
   'EditableQuote',
   'EditableButton',
   'EditableImage',
+  'EditableIcon',
+  'DynamicIcon',
   'EditableMap',
   'EditableList',
   'EditableBox',
@@ -26,6 +28,10 @@ const KNOWN_EDITABLE_COMPONENTS = new Set([
 
   // ─── Product & Commerce ────────────────────────────────────────
   'EditableProductCard',
+  'EditableUniversalCard',
+  'EditableVehicleCard',
+  'EditableListingCard',
+  'EditableEntityCard',
   'EditableProductGrid',
   'EditableProductDetail',
   'EditableCartDrawer',
@@ -78,12 +84,18 @@ const ALIAS_MAP = {
   'Badge': 'EditableBadge',
   'Quote': 'EditableQuote',
   'Image': 'EditableImage',
+  'Icon': 'EditableIcon',
+  'DynamicIcon': 'EditableIcon',
   'Map': 'EditableMap',
   'Grid': 'EditableGrid',
   'Section': 'EditableSection',
   'Box': 'EditableBox',
   'List': 'EditableList',
   'ProductCard': 'EditableProductCard',
+  'UniversalCard': 'EditableUniversalCard',
+  'ListingCard': 'EditableUniversalCard',
+  'EntityCard': 'EditableUniversalCard',
+  'VehicleCard': 'EditableVehicleCard',
   'ProductGrid': 'EditableProductGrid',
   'ProductDetail': 'EditableProductDetail',
   'CustomerReviews': 'EditableCustomerReviews',

package/src/arc/field-paths.cjs

@@ -91,7 +91,10 @@ function inferFieldName(kind, tag, text, extra = {}) {
     if (kind === 'image') return 'logoUrl';
     return 'logoText';
   }
-  if (kind === 'image') return extra.alt ? toCamel([extra.alt, 'image']) || 'image' : 'image';
+  if (kind === 'image') {
+    if (extra.fieldHint) return extra.fieldHint;
+    return extra.alt ? toCamel([extra.alt, 'image']) || 'image' : 'image';
+  }
   if (kind === 'alt') return extra.imageField ? extra.imageField.replace(/Image$/, 'ImageAlt').replace(/image$/, 'imageAlt') : 'imageAlt';
   if (kind === 'placeholder') return toCamel([text || '', 'placeholder']) || 'placeholder';
 

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

@@ -36,7 +36,7 @@ const TYPE_COERCION_MAP = {
   float: 'number',
   bool: 'boolean',
   img: 'image',
-  icon: 'image',
+  icon: 'text',
 };
 
 /**
@@ -49,6 +49,11 @@ function normalizeFieldType(rawType, fieldKey = '') {
   if (!rawType || typeof rawType !== 'string') return 'text';
   const lower = rawType.toLowerCase().trim();
 
+  // Explicit icon or emoji fields always coerce to text
+  if (lower === 'icon' || lower === 'emoji') {
+    return 'text';
+  }
+
   if (PLATFORM_ALLOWED_TYPES.has(lower)) {
     return lower;
   }
@@ -59,6 +64,9 @@ function normalizeFieldType(rawType, fieldKey = '') {
 
   // Heuristic from fieldKey
   const keyLower = fieldKey.toLowerCase();
+  if (keyLower.endsWith('icon') || keyLower.startsWith('icon') || keyLower.includes('emoji')) {
+    return 'text';
+  }
   if (keyLower.endsWith('url') || keyLower.endsWith('link') || keyLower.endsWith('href')) {
     return 'url';
   }

package/src/arc/index.cjs

@@ -69,6 +69,7 @@ const {
   testMutationResilience,
   runFuzzHarness,
 } = require('./fuzz-engine.cjs');
+const { runAutoEditabilityFix } = require('./auto-editability-fixer.cjs');
 const {
   analyzeBlockedProject,
   formatBlockedExplanationTerminal,
@@ -1306,6 +1307,27 @@ function runTransactionalPipeline(targetDirInput = '.', options = {}) {
   }
 }
 
+/**
+ * Standalone entry point for `deneb fix-editability`.
+ * Scans the project for missing field paths and auto-patches everything.
+ *
+ * @param {string} projectDir
+ * @param {{ dryRun?: boolean, verbose?: boolean }} options
+ */
+function runFixEditability(projectDir, options) {
+  const verbose = !!(options && options.verbose);
+  const dryRun = !!(options && options.dryRun);
+  if (verbose) console.log('[deneb] Running auto-editability fix on ' + projectDir);
+  const report = runAutoEditabilityFix(projectDir, { dryRun, verbose: true });
+  if (report.fixed.length === 0) {
+    console.log('[deneb] ✅ All fields already present — nothing to fix.');
+  } else {
+    console.log('[deneb] ✅ Fixed ' + report.fixed.length + ' file(s):');
+    for (const f of report.fixed) console.log('   • ' + f);
+  }
+  return report;
+}
+
 module.exports = {
   runDenebArc,
   runTransactionalPipeline,
@@ -1332,4 +1354,6 @@ module.exports = {
   printBlockedExplanation,
   ENGINE_ID,
   ARC_VERSION,
+  runAutoEditabilityFix,
+  runFixEditability,
 };

package/src/arc/planner.cjs

@@ -163,6 +163,7 @@ function planTransformations({ profile, analyses, recipe, ir }) {
           used: usedPaths,
         });
         transform.fieldType = 'image';
+        transform.dynamicSrc = Boolean(extra.dynamicSrc);
       } else if (candidate.operation === 'extract-alt') {
         transform.field = buildFieldPath({
           scope,
@@ -233,6 +234,18 @@ function planTransformations({ profile, analyses, recipe, ir }) {
         transform.targetComponent = extra.componentName;
         transform.targetFile = extra.componentFile;
         transform.previewPath = prefix;
+      } else if (candidate.operation === 'feature-icon') {
+        const iconBase = extra.iconName || 'icon';
+        const fieldName = inferFieldName(iconBase + 'Icon', candidate.tag, candidate.value, extra);
+        transform.field = buildFieldPath({
+          scope,
+          section,
+          field: fieldName,
+          used: usedPaths,
+        });
+        transform.fieldType = 'text';
+        transform.control = 'icon-picker';
+        transform.fallback = candidate.value || iconBase;
       } else if (candidate.operation === 'extract-tailwind-bg') {
         transform.field = buildFieldPath({
           scope,

package/src/arc/residual.cjs

@@ -31,6 +31,8 @@ const {
   IMAGE_TAGS,
   DECORATIVE_TAGS,
   isIconComponent,
+  isUtilityIcon,
+  isFeatureIcon,
 } = require('./adapters.cjs');
 const { BROAD_CONTENT_CONTAINERS } = require('./fivora-contract.cjs');
 const { inferSection, inferFieldName, buildFieldPath, classifyFieldType } = require('./field-paths.cjs');
@@ -118,7 +120,7 @@ function isDecorativeCopy(text, tag, className) {
 function classifyResidual(node, text, tag) {
   const className = attrLiteral(node, 'className') || attrLiteral(node, 'class');
   const ariaHidden = attrLiteral(node, 'aria-hidden') === 'true' || hasJsxAttribute(node, 'hidden') || /(^|\s)hidden(\s|$)/.test(className);
-  if (ariaHidden || DECORATIVE_TAGS.has(tag) || isIconComponent(tag, '')) {
+  if (ariaHidden || DECORATIVE_TAGS.has(tag) || isUtilityIcon(tag)) {
     return { bind: false, reason: 'decorative-icon' };
   }
   if (isDecorativeCopy(text, tag, className)) {
@@ -224,7 +226,7 @@ function applyResidualPass({ code, file, ownerScope, usedPaths, componentName, r
         return;
       }
 
-      if (DECORATIVE_TAGS.has(tag) || isIconComponent(tag, '')) {
+      if (DECORATIVE_TAGS.has(tag) || isUtilityIcon(tag)) {
         if (ensureStaticOnLeaf(node, 'decorative-icon')) applied++;
         this.traverse(pathNode);
         return;

package/src/arc/semantic.cjs

@@ -10,12 +10,16 @@ const {
   collectJsxText,
   findJsxAttribute,
   unwrapExpr,
+  extractItemMemberName,
 } = require('./ast.cjs');
 const {
   activeAdapters,
   recognizeWithAdapters,
   resolveActionWithAdapters,
   isIconComponent,
+  isUtilityIcon,
+  isFeatureIcon,
+  extractIconBaseName,
   classifyHref,
   classifyActionIntent,
   isLikelyCtaClass,
@@ -498,6 +502,141 @@ function classNameOf(node) {
   return getJsxAttributeLiteral(node, 'className') || getJsxAttributeLiteral(node, 'class') || '';
 }
 
+function collectPatternNames(param, out) {
+  if (!param) return;
+  if (param.type === 'Identifier') out.push(param.name);
+  else if (param.type === 'AssignmentPattern') collectPatternNames(param.left, out);
+  else if (param.type === 'RestElement') collectPatternNames(param.argument, out);
+  else if (param.type === 'ObjectPattern') {
+    for (const prop of param.properties || []) {
+      if (prop.type === 'RestElement') collectPatternNames(prop.argument, out);
+      else collectPatternNames(prop.value || prop.argument, out);
+    }
+  } else if (param.type === 'ArrayPattern') {
+    for (const el of param.elements || []) collectPatternNames(el, out);
+  }
+}
+
+function enclosingComponentParams(pathNode) {
+  let current = pathNode.parent;
+  while (current) {
+    const node = current.node || current.value;
+    if (
+      node &&
+      (node.type === 'FunctionDeclaration' ||
+        node.type === 'FunctionExpression' ||
+        node.type === 'ArrowFunctionExpression')
+    ) {
+      const parent = current.parent?.node || current.parent?.value;
+      const isMapCallback =
+        parent?.type === 'CallExpression' &&
+        parent.callee?.type === 'MemberExpression' &&
+        parent.callee.property?.name === 'map';
+      if (!isMapCallback) {
+        const names = [];
+        for (const param of node.params || []) collectPatternNames(param, names);
+        return { fn: node, names };
+      }
+    }
+    current = current.parentPath || current.parent;
+  }
+  return { fn: null, names: [] };
+}
+
+function identifiersIn(expr, out) {
+  const node = unwrapExpr(expr);
+  if (!node) return;
+  if (node.type === 'Identifier') {
+    out.add(node.name);
+    return;
+  }
+  if (node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression') {
+    identifiersIn(node.object, out);
+    if (node.computed) identifiersIn(node.property, out);
+    return;
+  }
+  if (node.type === 'ChainExpression') {
+    identifiersIn(node.expression, out);
+    return;
+  }
+  if (node.type === 'LogicalExpression' || node.type === 'BinaryExpression') {
+    identifiersIn(node.left, out);
+    identifiersIn(node.right, out);
+    return;
+  }
+  if (node.type === 'ConditionalExpression') {
+    identifiersIn(node.test, out);
+    identifiersIn(node.consequent, out);
+    identifiersIn(node.alternate, out);
+  }
+}
+
+function namesTiedToParams(fn, paramNames) {
+  const blocked = new Set(paramNames);
+  if (!fn?.body) return blocked;
+  let grew = true;
+  while (grew) {
+    grew = false;
+    recast.types.visit(fn.body, {
+      visitVariableDeclarator(pathNode) {
+        const node = pathNode.node;
+        if (node.id?.type === 'Identifier' && node.init && !blocked.has(node.id.name)) {
+          const used = new Set();
+          identifiersIn(node.init, used);
+          for (const name of used) {
+            if (blocked.has(name)) {
+              blocked.add(node.id.name);
+              grew = true;
+            }
+          }
+        }
+        this.traverse(pathNode);
+      },
+    });
+  }
+  return blocked;
+}
+
+function imageExpression(node) {
+  if (!node) return null;
+  const attr = findJsxAttribute(node, 'src');
+  if (!attr?.value || attr.value.type !== 'JSXExpressionContainer') return null;
+  const expr = unwrapExpr(attr.value.expression);
+  if (!expr || expr.type === 'JSXEmptyExpression') return null;
+  if (expr.type === 'StringLiteral' || expr.type === 'Literal' || expr.type === 'TemplateLiteral') return null;
+  if (expr.type === 'Identifier' && expr.name === 'siteData') return null;
+  if (
+    expr.type === 'Identifier' ||
+    expr.type === 'MemberExpression' ||
+    expr.type === 'OptionalMemberExpression' ||
+    expr.type === 'ChainExpression' ||
+    expr.type === 'LogicalExpression' ||
+    expr.type === 'ConditionalExpression'
+  ) {
+    return expr;
+  }
+  return null;
+}
+
+function imageFieldHint(expr) {
+  const node = unwrapExpr(expr);
+  if (!node) return 'photoImage';
+  if (node.type === 'Identifier') {
+    return /image|photo|picture|banner|logo/i.test(node.name) ? node.name : `${node.name}Image`;
+  }
+  if ((node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression') && !node.computed) {
+    const prop = node.property?.name || '';
+    const objectName = node.object?.type === 'Identifier' ? node.object.name : '';
+    const base = /^(src|url|href)$/i.test(prop) ? objectName || prop : prop || objectName;
+    if (!base) return 'photoImage';
+    return /image|photo|picture|banner|logo/i.test(base) ? base : `${base}Image`;
+  }
+  if (node.type === 'ChainExpression') return imageFieldHint(node.expression);
+  if (node.type === 'LogicalExpression') return imageFieldHint(node.left) || imageFieldHint(node.right);
+  if (node.type === 'ConditionalExpression') return imageFieldHint(node.consequent) || imageFieldHint(node.alternate);
+  return 'photoImage';
+}
+
 function confidenceFor(kind, extras = {}) {
   if (extras.already) return 1;
   if (extras.dynamic) return 0.15;
@@ -641,7 +780,7 @@ function analyzeFile(optionsOrFile, codeArg, profileArg) {
         if (!binding || binding.kind !== 'array') apiOwned = true;
       }
 
-      if (DECORATIVE_TAGS.has(name) || isIconComponent(name, importSource)) {
+      if (DECORATIVE_TAGS.has(name) || isUtilityIcon(name)) {
         candidates.push({
           loc,
           tag: name,
@@ -657,6 +796,29 @@ function analyzeFile(optionsOrFile, codeArg, profileArg) {
         return;
       }
 
+      if (isFeatureIcon(name, importSource)) {
+        const iconBase = extractIconBaseName(name);
+        candidates.push({
+          loc,
+          tag: name,
+          kind: 'feature-icon',
+          operation: 'feature-icon',
+          confidence: 0.95,
+          skip: false,
+          value: iconBase,
+          file: relativeFile,
+          ownerScope,
+          fingerprint: fingerprintCandidate({ tag: name, kind: 'icon', importSource }),
+          extra: {
+            iconName: iconBase,
+            originalComponent: name,
+            importSource,
+          },
+        });
+        this.traverse(pathNode);
+        return;
+      }
+
       const parents = parentNames(pathNode);
 
       if (name === 'source' && (parents[0] === 'picture' || recognition?.kind === 'responsive-image-source')) {
@@ -818,6 +980,43 @@ function analyzeFile(optionsOrFile, codeArg, profileArg) {
         return;
       }
 
+      const dynamicImageNode = name === 'picture'
+        ? (node.children || []).find((c) => c && c.type === 'JSXElement' && (getJsxName(c) === 'img' || getJsxName(c) === 'Image'))
+        : node;
+      const dynamicExpr = !src ? imageExpression(dynamicImageNode) : null;
+      if ((IMAGE_TAGS.has(name) || recognition?.kind === 'image') && dynamicExpr && !hasJsxAttribute(dynamicImageNode, 'data-preview-field-path')) {
+        const itemBound = mapInfo?.itemParam && extractItemMemberName(dynamicExpr, mapInfo.itemParam);
+        const componentParams = enclosingComponentParams(pathNode);
+        const blocked = namesTiedToParams(componentParams.fn, componentParams.names);
+        const usedNames = new Set();
+        identifiersIn(dynamicExpr, usedNames);
+        const fromProps = [...usedNames].some((usedName) => blocked.has(usedName));
+        // A photo that lives on one page (the home hero, for example) gets its
+        // own image field even when the src is a prop. A shared image widget
+        // must not, or every call site would show the same photo.
+        const pageOwned = Boolean(ownerScope) && ownerScope !== 'common';
+        if (!itemBound && (!fromProps || pageOwned)) {
+          usedLocs.add(loc);
+          candidates.push({
+            ...baseMeta,
+            kind: 'image',
+            operation: 'extract-image',
+            value: '',
+            extra: {
+              alt,
+              dynamicSrc: true,
+              fieldHint: isLogoContext ? undefined : imageFieldHint(dynamicExpr),
+              isBrandLogo: Boolean(isLogoContext),
+            },
+            confidence: 0.9,
+            reason: 'dynamic-image-source',
+            fingerprint: fingerprintCandidate({ tag: name, kind: 'image', dynamic: true, hint: imageFieldHint(dynamicExpr) }),
+          });
+          this.traverse(pathNode);
+          return;
+        }
+      }
+
       if (placeholder && !isStaticSkipText(placeholder)) {
         usedLocs.add(loc);
         candidates.push({

package/src/arc/transforms/element-transform.cjs

@@ -5,6 +5,7 @@ const {
   findJsxAttribute,
   hasJsxAttribute,
   siteDataBinding,
+  optionalMember,
   ensureStyleAttrs,
   b,
 } = require('../ast.cjs');
@@ -20,6 +21,22 @@ const { splitActionChildren } = require('./primitives/action.cjs');
 const { bindButtonWithIcon, bindHighlightedHeading } = require('./components/compound-content.cjs');
 const { extractTailwindBg } = require('./assets/tailwind-bg.cjs');
 
+function bindDynamicImageSource(node, field) {
+  const tagName = getJsxName(node);
+  const target = tagName === 'picture'
+    ? (node.children || []).find((child) => child && child.type === 'JSXElement' && (getJsxName(child) === 'img' || getJsxName(child) === 'Image'))
+    : node;
+  if (!target) return;
+  const srcAttr = findJsxAttribute(target, 'src');
+  if (srcAttr?.value?.type === 'JSXExpressionContainer' && srcAttr.value.expression) {
+    const original = srcAttr.value.expression;
+    const edited = optionalMember(['siteData', 'content', ...String(field).split('.')]);
+    srcAttr.value = b.jsxExpressionContainer(b.logicalExpression('||', edited, original));
+  }
+  ensurePreviewPath(target, field);
+  if (target !== node) ensurePreviewPath(node, field);
+}
+
 function applyTransformToElement(pathNode, transform) {
   const node = pathNode.node;
   if (transform.operation === 'form-submit-action') {
@@ -96,6 +113,10 @@ function applyTransformToElement(pathNode, transform) {
     return;
   }
   if (transform.operation === 'extract-image' || transform.operation === 'extract-picture') {
+    if (transform.dynamicSrc) {
+      bindDynamicImageSource(node, transform.field);
+      return;
+    }
     const tagName = getJsxName(node);
     if (tagName === 'picture') {
       const children = node.children || [];
@@ -185,6 +206,20 @@ function applyTransformToElement(pathNode, transform) {
     extractTailwindBg(node, transform);
     return;
   }
+  if (transform.operation === 'feature-icon') {
+    if (hasJsxAttribute(node, 'data-preview-static')) {
+      node.openingElement.attributes = node.openingElement.attributes.filter(
+        (attr) => !(attr.type === 'JSXAttribute' && attr.name && attr.name.name === 'data-preview-static')
+      );
+    }
+    replaceAttrValue(node, 'data-preview-field-path', b.stringLiteral(transform.field));
+    if (!hasJsxAttribute(node, 'data-preview-control')) {
+      node.openingElement.attributes.push(
+        b.jsxAttribute(b.jsxIdentifier('data-preview-control'), b.stringLiteral('icon-picker'))
+      );
+    }
+    return;
+  }
 }
 
 module.exports = {

package/src/arc/transforms/index.cjs

@@ -77,6 +77,7 @@ function applyFilePlan(filePlan, profile) {
     'bind-highlighted-heading',
     'prop-flow-callsite',
     'instrument-reusable-component',
+    'feature-icon',
   ]);
 
   const isTypeScript = Boolean(filePlan.file && /\.(tsx|ts)$/.test(filePlan.file));

package/src/arc/universal-icon-patcher.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Helper to ensure nested object path exists
+function setDeep(obj, pathArr, value) {
+  let cur = obj;
+  for (let i = 0; i < pathArr.length - 1; i++) {
+    const k = pathArr[i];
+    if (!cur[k] || typeof cur[k] !== 'object') cur[k] = {};
+    cur = cur[k];
+  }
+  if (cur[pathArr[pathArr.length - 1]] === undefined) {
+    cur[pathArr[pathArr.length - 1]] = value;
+  }
+}
+
+function patchUniversalIcons(projectDir, dryRun = false, log = () => {}) {
+  if (!projectDir || typeof projectDir !== 'string' || !fs.existsSync(projectDir)) {
+    return;
+  }
+
+  const siteDataPath = path.join(projectDir, 'data', 'site-data.json');
+  if (!fs.existsSync(siteDataPath)) {
+    return;
+  }
+
+  let siteData;
+  try {
+    siteData = JSON.parse(fs.readFileSync(siteDataPath, 'utf8'));
+  } catch {
+    return;
+  }
+
+  if (!siteData.content) siteData.content = {};
+  if (!siteData.content.common) siteData.content.common = {};
+
+  setDeep(siteData.content, ['common', 'whatsapp', 'copyIcon'], 'copy');
+  setDeep(siteData.content, ['common', 'whatsapp', 'icon'], 'message-circle');
+  setDeep(siteData.content, ['common', 'search', 'searchIcon'], 'search');
+
+  if (!dryRun) {
+    try {
+      fs.writeFileSync(siteDataPath, JSON.stringify(siteData, null, 2), 'utf8');
+      log('[universal-icons] Registered common icon keys in site-data.json');
+    } catch (err) {
+      log('[universal-icons] Warning: failed to save site-data.json: ' + err.message);
+    }
+  }
+}
+
+module.exports = {
+  patchUniversalIcons,
+};

package/src/sites/universal-page-selection.ts

@@ -519,10 +519,32 @@ export function findLinksToUnselectedPages(input: {
   return findings;
 }
 
+/** Detect links that contain the configured base path but omit its leading
+ * slash. Browsers resolve these relative to the current page and duplicate the
+ * generated-site prefix after navigation. */
+export function findMalformedBasePathLinks(input: {
+  html: string;
+  basePath: string;
+}) {
+  const prefix = input.basePath.replace(/^\/+|\/+$/g, '');
+  if (!prefix) return [];
+  const findings = new Set<string>();
+  for (const match of input.html.matchAll(
+    /<[a-z][^>]*\b(?:href|formaction|data-href|data-route|data-url)\s*=\s*(?:"([^"]*)"|'([^']*)')[^>]*>/gi,
+  )) {
+    const value = (match[1] ?? match[2] ?? '').trim();
+    const path = value.split(/[?#]/, 1)[0].replace(/^\.\//, '');
+    if (path === prefix || path.startsWith(`${prefix}/`)) {
+      findings.add(value);
+    }
+  }
+  return [...findings];
+}
+
 /**
  * Next's client router applies next.config `basePath` automatically. Wrapping
- * a router destination in a helper that also prepends the base path duplicates
- * the generated-site prefix at runtime.
+ * a router destination in a package helper that also prepends the base path
+ * duplicates the generated-site prefix at runtime.
  */
 export function findDoubleBasePathNextRouterCalls(source: string) {
   const findings: Array<{