@deneb-ui/cli 2.0.50 → 2.0.52

package/src/arc/scanner.cjs

@@ -277,8 +277,50 @@ function scanPagesRouterRoutes(pagesDir, projectDir) {
  * ever declares routes it actually found.
  */
 function keepExportableRoutes(routes) {
-  const exportable = routes.filter((route) => !route.dynamic);
-  return exportable.length ? exportable : routes;
+  const exportable = routes.filter((route) => !route.dynamic && (route.file || route.inferred));
+  return exportable.length ? exportable : routes.filter((route) => route.inferred);
+}
+
+function resolvePageFileOnDisk(projectDir, page) {
+  if (!page) return null;
+  if (page.file && fs.existsSync(path.join(projectDir, page.file))) return page.file.replace(/\\/g, '/');
+  const route = String(page.route || '').replace(/^\//, '').replace(/\/+$/, '');
+  const id = page.id === 'home' ? '' : page.id;
+  const segments = route || id || '';
+  const candidates = [];
+  if (!segments || page.id === 'home' || page.route === '/') {
+    candidates.push(
+      'src/app/page.tsx',
+      'src/app/page.jsx',
+      'src/app/page.js',
+      'app/page.tsx',
+      'app/page.jsx',
+      'app/page.js',
+      'pages/index.tsx',
+      'pages/index.jsx',
+      'pages/index.js',
+      'src/pages/index.tsx',
+      'src/pages/index.jsx',
+      'src/pages/index.js',
+    );
+  }
+  if (segments) {
+    for (const base of ['src/app', 'app']) {
+      for (const name of ['page.tsx', 'page.jsx', 'page.js']) {
+        candidates.push(`${base}/${segments}/${name}`);
+      }
+    }
+    for (const base of ['pages', 'src/pages']) {
+      for (const ext of ['tsx', 'jsx', 'js']) {
+        candidates.push(`${base}/${segments}.${ext}`);
+        candidates.push(`${base}/${segments}/index.${ext}`);
+      }
+    }
+  }
+  for (const relative of candidates) {
+    if (fs.existsSync(path.join(projectDir, relative))) return relative.replace(/\\/g, '/');
+  }
+  return null;
 }
 
 function detectLanguage(sourceFiles) {
@@ -610,4 +652,6 @@ module.exports = {
   resolveImportSpecifier,
   extractImportSpecifiers,
   parseTsconfig,
+  keepExportableRoutes,
+  resolvePageFileOnDisk,
 };

package/src/arc/semantic.cjs

@@ -23,6 +23,8 @@ const {
   TEXT_TAGS,
   ACTION_TAGS,
   IMAGE_TAGS,
+  FORM_INPUT_TAGS,
+  FORM_CONTAINER_TAGS,
   DECORATIVE_TAGS,
 } = require('./adapters.cjs');
 const { shortHash } = require('./fs-utils.cjs');
@@ -126,8 +128,9 @@ function objectLiteralToPlain(node) {
       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;
+        // Component references (e.g. icon: Truck) are not merchant content.
+        // Skip this key only so primitive siblings (title, body) stay convertible.
+        continue;
       }
       out[key] = val.name;
     } else if (val.type === 'UnaryExpression' && val.argument) {
@@ -347,12 +350,15 @@ function collectItemFieldUsage(callback, itemParam) {
   }
 
   let usesItemAsComponent = false;
+  const componentProps = new Set();
   recast.types.visit(callback, {
     visitJSXOpeningElement(pathNode) {
       const name = pathNode.node.name;
       if (name?.type === 'JSXMemberExpression') {
-        if (name.object?.type === 'Identifier' && name.object.name === itemParam) {
+        const objectName = name.object && name.object.name;
+        if ((name.object?.type === 'Identifier' || name.object?.type === 'JSXIdentifier') && objectName === itemParam) {
           usesItemAsComponent = true;
+          if (name.property?.name) componentProps.add(name.property.name);
         }
       }
       this.traverse(pathNode);
@@ -360,6 +366,7 @@ function collectItemFieldUsage(callback, itemParam) {
     visitJSXExpressionContainer(pathNode) {
       const properties = findItemMemberProperties(pathNode.node.expression);
       for (const property of properties) {
+        if (componentProps.has(property)) continue;
         const parent = pathNode.parent?.node || pathNode.parent?.value;
         if (parent?.type === 'JSXAttribute') {
           const attribute = parent.name?.name;
@@ -392,7 +399,7 @@ function confidenceFor(kind, extras = {}) {
   if (extras.icon) return 0.1;
   if (kind === 'url' && extras.action === 'whatsapp') return 0.96;
   if (kind === 'url' && extras.social) return 0.93;
-  if (kind === 'split-action-contract') return 0.94;
+  if (kind === 'split-action-contract' || kind === 'form-submit-action') return 0.94;
   if (kind === 'text' && HEADING_TAGS.has(extras.tag)) return 0.95;
   if (kind === 'text' && extras.tag === 'p') return 0.9;
   if (kind === 'image') return 0.88;
@@ -562,14 +569,47 @@ function analyzeFile({ code, relativeFile, profile, graph, ownerScope, component
         });
       }
 
+      const insideForm = parents.some((p) => FORM_CONTAINER_TAGS.has(p));
+
       const actionableHref = href || (name === 'Button' ? getJsxAttributeLiteral(node, 'href') : null);
       const innerText = textInfo.dynamic ? '' : textInfo.text;
       const typeAttr = getJsxAttributeLiteral(node, 'type');
       const isSubmit = typeAttr === 'submit';
 
-      // Check for action intent via classifyActionIntent (covers WhatsApp, Call/Phone, Directions, Location, Shop, Email)
-      const actionIntent = !isSubmit && !apiOwned ? classifyActionIntent(innerText, actionableHref) : null;
-      const isAction = (Boolean(actionableHref) || Boolean(actionIntent)) && (ACTION_TAGS.has(name) || isLikelyCtaClass(className));
+      // Check for action intent via classifyActionIntent (covers Form Submit, WhatsApp, Call/Phone, Directions, Location, Shop, Email)
+      const actionIntent = !apiOwned ? classifyActionIntent(innerText, actionableHref) : null;
+
+      const isFormSubmit =
+        !apiOwned &&
+        (ACTION_TAGS.has(name) || isLikelyCtaClass(className)) &&
+        (isSubmit ||
+          (insideForm && (actionIntent?.action === 'form-submit' || (innerText && !actionableHref))) ||
+          actionIntent?.action === 'form-submit');
+
+      if (isFormSubmit && innerText && !textInfo.dynamic) {
+        usedLocs.add(loc);
+        const resolvedHref = actionableHref || (actionIntent ? actionIntent.defaultUrl : 'https://wa.me/1234567890');
+        candidates.push({
+          ...baseMeta,
+          kind: 'form-submit-action',
+          operation: 'form-submit-action',
+          value: resolvedHref,
+          label: innerText,
+          extra: {
+            action: 'form-submit',
+            external: true,
+            insideForm,
+            isSubmit,
+          },
+          confidence: confidenceFor('form-submit-action'),
+          reason: 'form-submit-whatsapp-dispatch',
+          fingerprint: fingerprintCandidate({ tag: name, kind: 'form-submit-action', action: 'form-submit' }),
+        });
+        this.traverse(pathNode);
+        return;
+      }
+
+      const isAction = !isSubmit && (Boolean(actionableHref) || Boolean(actionIntent)) && (ACTION_TAGS.has(name) || isLikelyCtaClass(className));
 
       if (isAction && (actionableHref || actionIntent)) {
         const action = actionIntent ? actionIntent.action : classifyHref(actionableHref);
@@ -684,7 +724,6 @@ function analyzeFile({ code, relativeFile, profile, graph, ownerScope, component
         const objectItems = arr.items.every((item) => item.type === 'object');
         const boundProperties = [...itemUsage.keys()];
         const convertible =
-          !usesItemAsComponent &&
           objectItems &&
           boundProperties.length > 0 &&
           arr.items.some((item) => boundProperties.some((key) => key in item.value));

package/src/arc/style-candidates.cjs

@@ -5,6 +5,7 @@ const BUTTON_TAGS = new Set(['button', 'Button', 'CTAButton']);
 
 function inferStyleKind(transform) {
   if (transform.operation === 'collection-conversion') return 'grid';
+  if (transform.operation === 'form-submit-action') return 'button';
   if (transform.operation === 'split-action-contract') return 'text';
   if (BUTTON_TAGS.has(transform.tag) && transform.operation === 'extract-text') return 'button';
   if (TEXT_OPS.has(transform.operation)) return 'text';
@@ -14,7 +15,7 @@ function inferStyleKind(transform) {
 function stylePathFor(transform, kind) {
   if (kind === 'grid' && transform.listField) return `${transform.listField}.grid`;
   if (kind === 'card' && transform.listField) return `${transform.listField}[*].card`;
-  if (transform.operation === 'split-action-contract') return transform.labelField;
+  if (transform.operation === 'split-action-contract' || transform.operation === 'form-submit-action') return transform.labelField;
   return transform.field || transform.labelField || null;
 }
 

package/src/arc/transformer.cjs

@@ -152,6 +152,32 @@ function wrapHiddenUrlSibling(pathNode, urlField, fallback) {
 
 function applyTransformToElement(pathNode, transform) {
   const node = pathNode.node;
+  if (transform.operation === 'form-submit-action') {
+    const tagName = getJsxName(node);
+    if (!hasJsxAttribute(node, 'type') && tagName === 'button') {
+      node.openingElement.attributes.push(
+        b.jsxAttribute(b.jsxIdentifier('type'), b.stringLiteral('submit'))
+      );
+    }
+    if (transform.labelField) {
+      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')
+        );
+      }
+      if (hasJsxAttribute(node, 'data-preview-field-path')) {
+        node.openingElement.attributes = node.openingElement.attributes.filter(
+          (attr) => !(attr.type === 'JSXAttribute' && attr.name && attr.name.name === 'data-preview-field-path')
+        );
+      }
+      splitActionChildren(node, transform.labelField, transform.labelFallback || '');
+    } else if (!hasJsxAttribute(node, 'data-preview-static')) {
+      node.openingElement.attributes.push(
+        b.jsxAttribute(b.jsxIdentifier('data-preview-static'), b.stringLiteral('action-button'))
+      );
+    }
+    return;
+  }
   if (transform.operation === 'split-action-contract') {
     const tagName = getJsxName(node);
     if (tagName === 'button') {
@@ -185,18 +211,17 @@ function applyTransformToElement(pathNode, transform) {
       }
     }
 
-    if (!hasJsxAttribute(node, 'data-preview-static')) {
-      node.openingElement.attributes.push(
-        b.jsxAttribute(b.jsxIdentifier('data-preview-static'), b.stringLiteral('action-link'))
-      );
-    }
-    if (hasJsxAttribute(node, 'data-preview-field-path')) {
+    // Fivora Strict Action/Label Contract:
+    // Bind the URL action marker directly to the outer <a> element (never hidden)
+    replaceAttrValue(node, 'data-preview-field-path', b.stringLiteral(transform.urlField));
+    // Remove data-preview-static if present to prevent static/field collisions
+    if (hasJsxAttribute(node, 'data-preview-static')) {
       node.openingElement.attributes = node.openingElement.attributes.filter(
-        (attr) => !(attr.type === 'JSXAttribute' && attr.name && attr.name.name === 'data-preview-field-path')
+        (attr) => !(attr.type === 'JSXAttribute' && attr.name && attr.name.name === 'data-preview-static')
       );
     }
+    // Bind the label to the inner text child
     splitActionChildren(node, transform.labelField, transform.labelFallback || '');
-    wrapHiddenUrlSibling(pathNode, transform.urlField, transform.fallback);
     return;
   }
   if (transform.operation === 'extract-url') {
@@ -234,11 +259,29 @@ function applyTransformToElement(pathNode, transform) {
     return;
   }
   if (transform.operation === 'style-bind') {
-    if (transform.styleKind === 'grid' || transform.styleKind === 'card') return;
+    if (transform.styleKind === 'grid') {
+      const container = findAncestorJsxElement(pathNode) || node;
+      ensureStyleAttrs(container, transform.stylePath, 'grid');
+      return;
+    }
+    if (transform.styleKind === 'card') {
+      ensureStyleAttrs(node, transform.stylePath, 'card');
+      return;
+    }
     ensureStyleAttrs(node, transform.stylePath, transform.styleKind || 'text');
   }
 }
 
+function findAncestorJsxElement(pathNode) {
+  let current = pathNode.parent;
+  while (current) {
+    const candidate = current.node || current.value;
+    if (candidate?.type === 'JSXElement') return candidate;
+    current = current.parentPath || current.parent;
+  }
+  return null;
+}
+
 function inferButtonKind(tag) {
   if (tag === 'button' || tag === 'Button') return 'button';
   return 'text';
@@ -314,6 +357,7 @@ function applyCollectionTransform(ast, transform, isClient = false) {
   }
 
   markItemFields(callback, { listPath, binding, indexName });
+  markComponentRefItemsStatic(callback, binding);
 
   const container = findListContainer(mapCall);
   if (container && !hasJsxAttribute(container, 'data-preview-list-path')) {
@@ -330,7 +374,7 @@ function applyCollectionTransform(ast, transform, isClient = false) {
     );
   }
 
-  return bindArrayDeclaration(ast, mapCall, listPath, isClient);
+  return bindArrayDeclaration(ast, mapCall, listPath, isClient, Boolean(transform.hasComponentRef));
 }
 
 function findMapCall(ast, loc) {
@@ -389,9 +433,14 @@ function markItemFields(callback, { listPath, binding, indexName }) {
       );
       if (textChild && !hasJsxAttribute(node, 'data-preview-field-path')) {
         const property = itemMemberName(textChild.expression, binding);
-        node.openingElement.attributes.push(
-          jsxTemplatePathAttr('data-preview-field-path', listPath, indexName, `.${property}`)
-        );
+        const tagName = getJsxName(node);
+        if (BROAD_CONTENT_CONTAINERS.has(tagName) || BROAD_CONTENT_CONTAINERS.has(String(tagName).toLowerCase())) {
+          wrapItemFieldInSpan(node, textChild, listPath, indexName, property);
+        } else {
+          node.openingElement.attributes.push(
+            jsxTemplatePathAttr('data-preview-field-path', listPath, indexName, `.${property}`)
+          );
+        }
       }
 
       this.traverse(pathNode);
@@ -399,6 +448,51 @@ function markItemFields(callback, { listPath, binding, indexName }) {
   });
 }
 
+function wrapItemFieldInSpan(node, textChild, listPath, indexName, property) {
+  const nextChildren = [];
+  for (const child of node.children || []) {
+    if (child === textChild) {
+      nextChildren.push(
+        b.jsxElement(
+          b.jsxOpeningElement(
+            b.jsxIdentifier('span'),
+            [jsxTemplatePathAttr('data-preview-field-path', listPath, indexName, `.${property}`)],
+            false
+          ),
+          b.jsxClosingElement(b.jsxIdentifier('span')),
+          [child],
+          false
+        )
+      );
+    } else {
+      nextChildren.push(child);
+    }
+  }
+  node.children = nextChildren;
+}
+
+function markComponentRefItemsStatic(callback, binding) {
+  recast.types.visit(callback, {
+    visitJSXElement(pathNode) {
+      const name = pathNode.node.openingElement && pathNode.node.openingElement.name;
+      if (
+        name &&
+        name.type === 'JSXMemberExpression' &&
+        name.object &&
+        (name.object.type === 'Identifier' || name.object.type === 'JSXIdentifier') &&
+        name.object.name === binding
+      ) {
+        if (!hasJsxAttribute(pathNode.node, 'data-preview-static') && !hasJsxAttribute(pathNode.node, 'data-preview-field-path')) {
+          pathNode.node.openingElement.attributes.push(
+            b.jsxAttribute(b.jsxIdentifier('data-preview-static'), b.stringLiteral('component-ref'))
+          );
+        }
+      }
+      this.traverse(pathNode);
+    },
+  });
+}
+
 function itemMemberName(expr, binding) {
   if (!expr || expr.type !== 'MemberExpression' || expr.computed) return null;
   if (expr.object?.type !== 'Identifier' || expr.object.name !== binding) return null;
@@ -449,7 +543,7 @@ function findEnclosingFunction(pathNode) {
   return null;
 }
 
-function bindArrayDeclaration(ast, mapCallPath, listPath, isClient = false) {
+function bindArrayDeclaration(ast, mapCallPath, listPath, isClient = false, mergeDefaultRefs = false) {
   const arrayName = mapCallPath.node.callee.object?.name;
   if (!arrayName) return false;
   let bound = false;
@@ -477,7 +571,9 @@ function bindArrayDeclaration(ast, mapCallPath, listPath, isClient = false) {
             const localDecl = b.variableDeclaration('const', [
               b.variableDeclarator(
                 b.identifier(arrayName),
-                siteDataListBinding(listPath.split('.'), b.identifier(defaultName))
+                mergeDefaultRefs
+                  ? mergeDefaultItemRefsBinding(listPath.split('.'), defaultName)
+                  : siteDataListBinding(listPath.split('.'), b.identifier(defaultName))
               ),
             ]);
             const hookIdx = body.findIndex((stmt) => recast.print(stmt).code.includes('useSiteData'));
@@ -501,6 +597,28 @@ function bindArrayDeclaration(ast, mapCallPath, listPath, isClient = false) {
   return bound;
 }
 
+function mergeDefaultItemRefsBinding(pathParts, defaultName) {
+  const listExpr = siteDataListBinding(pathParts, b.identifier(defaultName));
+  return b.callExpression(
+    b.memberExpression(listExpr, b.identifier('map'), false),
+    [
+      b.arrowFunctionExpression(
+        [b.identifier('item'), b.identifier('index')],
+        b.objectExpression([
+          b.spreadElement(
+            b.logicalExpression(
+              '??',
+              b.memberExpression(b.identifier(defaultName), b.identifier('index'), true),
+              b.objectExpression([])
+            )
+          ),
+          b.spreadElement(b.identifier('item')),
+        ])
+      ),
+    ]
+  );
+}
+
 function fileAlreadyUsesSiteDataHook(ast) {
   let found = false;
   recast.types.visit(ast, {
@@ -625,6 +743,7 @@ function applyFilePlan(filePlan, profile) {
 
   const supported = new Set([
     'split-action-contract',
+    'form-submit-action',
     'extract-url',
     'extract-image',
     'extract-alt',
@@ -688,6 +807,9 @@ function applyFilePlan(filePlan, profile) {
 
   // Sanitize any conflicting data-preview-static on elements with editable markers
   sanitizeContradictoryMarkers(ast);
+  healBroadContainerMarkers(ast);
+  healEmptyStateConditionals(ast);
+  healHiddenPreviewMarkers(ast);
 
   // Page keys are stamped in a separate route-driven pass so App Router and
   // Pages Router projects are handled by the same logic.
@@ -972,8 +1094,7 @@ function sanitizeContradictoryMarkers(ast) {
 }
 
 function sanitizeContradictoryMarkersInSource(code, relativeFile) {
-  if (!code.includes('data-preview-static')) return { code, updated: false };
-  if (!code.includes('data-preview-field-path') && !code.includes('data-preview-list-path') && !code.includes('data-preview-item-path')) {
+  if (!code.includes('data-preview-static') && !code.includes('data-preview-field-path')) {
     return { code, updated: false };
   }
   let ast;
@@ -982,9 +1103,200 @@ function sanitizeContradictoryMarkersInSource(code, relativeFile) {
   } catch {
     return { code, updated: false };
   }
-  const count = sanitizeContradictoryMarkers(ast);
-  if (count === 0) return { code, updated: false };
-  return { code: printSource(ast, code), updated: true, count };
+  const cleaned = sanitizeContradictoryMarkers(ast);
+  const healedBroad = healBroadContainerMarkers(ast);
+  const healedEmpty = healEmptyStateConditionals(ast);
+  const healedHidden = healHiddenPreviewMarkers(ast);
+  if (cleaned === 0 && healedBroad === 0 && healedEmpty === 0 && healedHidden === 0) return { code, updated: false };
+  return { code: printSource(ast, code), updated: true, count: cleaned + healedBroad + healedEmpty + healedHidden };
+}
+
+function healBroadContainerMarkers(ast) {
+  let healed = 0;
+  recast.types.visit(ast, {
+    visitJSXElement(pathNode) {
+      const node = pathNode.node;
+      const tag = getJsxName(node);
+      const lower = String(tag || '').toLowerCase();
+      if (!BROAD_CONTENT_CONTAINERS.has(tag) && !BROAD_CONTENT_CONTAINERS.has(lower)) {
+        this.traverse(pathNode);
+        return;
+      }
+      const fieldAttr = findJsxAttribute(node, 'data-preview-field-path');
+      if (!fieldAttr) {
+        this.traverse(pathNode);
+        return;
+      }
+
+      const fieldValue = fieldAttr.value;
+      node.openingElement.attributes = (node.openingElement.attributes || []).filter(
+        (attr) =>
+          !(
+            attr.type === 'JSXAttribute' &&
+            attr.name &&
+            (attr.name.name === 'data-preview-field-path' ||
+              attr.name.name === 'data-preview-style-target' ||
+              attr.name.name === 'data-preview-style-type')
+          )
+      );
+
+      const leaf = findFirstLeafChild(node);
+      if (leaf && !hasJsxAttribute(leaf, 'data-preview-field-path')) {
+        leaf.openingElement.attributes.push(
+          b.jsxAttribute(b.jsxIdentifier('data-preview-field-path'), fieldValue)
+        );
+        healed++;
+      } else {
+        const span = b.jsxElement(
+          b.jsxOpeningElement(
+            b.jsxIdentifier('span'),
+            [b.jsxAttribute(b.jsxIdentifier('data-preview-field-path'), fieldValue)],
+            false
+          ),
+          b.jsxClosingElement(b.jsxIdentifier('span')),
+          node.children || [],
+          false
+        );
+        node.children = [span];
+        healed++;
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return healed;
+}
+
+function findFirstLeafChild(node) {
+  const leafTags = new Set(['span', 'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'label', 'img', 'button', 'a', 'strong', 'em', 'small']);
+  for (const child of node.children || []) {
+    if (child && child.type === 'JSXElement') {
+      const name = getJsxName(child);
+      if (leafTags.has(name) || leafTags.has(String(name).toLowerCase())) return child;
+      const nested = findFirstLeafChild(child);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+function healEmptyStateConditionals(ast) {
+  let healed = 0;
+
+  function jsxHasPreviewMarker(node) {
+    if (!node) return false;
+    if (node.type === 'JSXElement') {
+      if (
+        hasJsxAttribute(node, 'data-preview-field-path') ||
+        hasJsxAttribute(node, 'data-preview-list-path') ||
+        hasJsxAttribute(node, 'data-preview-item-path')
+      ) {
+        return true;
+      }
+      return (node.children || []).some((child) => jsxHasPreviewMarker(child));
+    }
+    if (node.type === 'JSXFragment') {
+      return (node.children || []).some((child) => jsxHasPreviewMarker(child));
+    }
+    if (node.type === 'ParenthesizedExpression') return jsxHasPreviewMarker(node.expression);
+    return false;
+  }
+
+  recast.types.visit(ast, {
+    visitLogicalExpression(pathNode) {
+      const expr = pathNode.node;
+      if (expr.operator === '&&' && jsxHasPreviewMarker(expr.right)) {
+        pathNode.replace(expr.right);
+        healed++;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+    visitJSXExpressionContainer(pathNode) {
+      const expr = pathNode.node.expression;
+      if (!expr) {
+        this.traverse(pathNode);
+        return;
+      }
+      if (expr.type === 'LogicalExpression' && expr.operator === '&&' && jsxHasPreviewMarker(expr.right)) {
+        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;
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return healed;
+}
+
+function isNullish(node) {
+  if (!node) return true;
+  if (node.type === 'NullLiteral') return true;
+  if (node.type === 'Literal' && (node.value === null || node.value === false || node.value === undefined)) return true;
+  if (node.type === 'BooleanLiteral' && node.value === false) return true;
+  if (node.type === 'Identifier' && (node.name === 'undefined' || node.name === 'null')) return true;
+  return false;
+}
+
+function healHiddenPreviewMarkers(ast) {
+  let healed = 0;
+  recast.types.visit(ast, {
+    visitJSXOpeningElement(pathNode) {
+      const attrs = pathNode.node.attributes || [];
+      const hasEditable = attrs.some(
+        (attr) =>
+          attr.type === 'JSXAttribute' &&
+          attr.name &&
+          (attr.name.name === 'data-preview-field-path' ||
+            attr.name.name === 'data-preview-list-path' ||
+            attr.name.name === 'data-preview-item-path')
+      );
+      if (!hasEditable) {
+        this.traverse(pathNode);
+        return;
+      }
+      const classAttr = attrs.find((attr) => attr.type === 'JSXAttribute' && attr.name && (attr.name.name === 'className' || attr.name.name === 'class'));
+      let classText = '';
+      if (classAttr && classAttr.value) {
+        if (classAttr.value.type === 'StringLiteral' || classAttr.value.type === 'Literal') classText = String(classAttr.value.value || '');
+        else if (classAttr.value.type === 'JSXExpressionContainer' && classAttr.value.expression) {
+          const expr = classAttr.value.expression;
+          if (expr.type === 'StringLiteral' || expr.type === 'Literal') classText = String(expr.value || '');
+          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)) {
+        pathNode.node.attributes = attrs.filter(
+          (attr) =>
+            !(
+              attr.type === 'JSXAttribute' &&
+              attr.name &&
+              (attr.name.name === 'data-preview-field-path' ||
+                attr.name.name === 'data-preview-list-path' ||
+                attr.name.name === 'data-preview-item-path' ||
+                attr.name.name === 'data-preview-style-target' ||
+                attr.name.name === 'data-preview-style-type')
+            )
+        );
+        healed++;
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return healed;
 }
 
 module.exports = {
@@ -998,4 +1310,7 @@ module.exports = {
   inferPageKey,
   sanitizeContradictoryMarkers,
   sanitizeContradictoryMarkersInSource,
+  healBroadContainerMarkers,
+  healEmptyStateConditionals,
+  healHiddenPreviewMarkers,
 };