@deneb-ui/cli 2.0.88 → 2.0.90

package/src/arc/transforms/healing/conditionals.cjs

@@ -0,0 +1,295 @@
+'use strict';
+
+const recast = require('recast');
+const {
+  parseSource,
+  printSource,
+  getJsxName,
+  findJsxAttribute,
+  hasJsxAttribute,
+  b,
+} = require('../../ast.cjs');
+const {
+  sanitizeContradictoryMarkers,
+  healBroadContainerMarkers,
+  healHiddenPreviewMarkers,
+  healSectionOverflowHidden,
+  healDecorativeOverlays,
+} = require('./sanitizer.cjs');
+
+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 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 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)) {
+        if (!isUnsafeToStripCondition(expr.left, expr.right, pathNode)) {
+          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)) {
+        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))
+      ) {
+        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);
+    },
+  });
+  return healed;
+}
+
+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 };
+}
+
+function sanitizeContradictoryMarkersInSource(code, relativeFile) {
+  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;
+  try {
+    ast = parseSource(code, relativeFile);
+  } catch {
+    return { code, updated: false };
+  }
+  const cleaned = sanitizeContradictoryMarkers(ast);
+  const healedBroad = healBroadContainerMarkers(ast);
+  const healedEmpty = healEmptyStateConditionals(ast);
+  const healedHidden = healHiddenPreviewMarkers(ast);
+  const healedOverflow = healSectionOverflowHidden(ast);
+  const healedOverlay = healDecorativeOverlays(ast);
+  if (cleaned === 0 && healedBroad === 0 && healedEmpty === 0 && healedHidden === 0 && healedOverflow === 0 && healedOverlay === 0) return { code, updated: false };
+  return { code: printSource(ast, code), updated: true, count: cleaned + healedBroad + healedEmpty + healedHidden + healedOverflow + healedOverlay };
+}
+
+module.exports = {
+  isUnsafeToStripCondition,
+  isNullish,
+  healEmptyStateConditionals,
+  healUnguardedModalConditionals,
+  healUnguardedModalConditionalsInSource,
+  sanitizeContradictoryMarkersInSource,
+};

package/src/arc/transforms/healing/sanitizer.cjs

@@ -0,0 +1,401 @@
+'use strict';
+
+const recast = require('recast');
+const {
+  parseSource,
+  printSource,
+  getJsxName,
+  findJsxAttribute,
+  hasJsxAttribute,
+  ensureImport,
+  b,
+} = require('../../ast.cjs');
+const { BROAD_CONTENT_CONTAINERS } = require('../../fivora-contract.cjs');
+const { injectSiteDataHook } = require('../runtime/provider.cjs');
+
+function sanitizeContradictoryMarkers(ast) {
+  let cleaned = 0;
+  recast.types.visit(ast, {
+    visitJSXElement(pathNode) {
+      const opening = pathNode.node.openingElement;
+      if (!opening || !Array.isArray(opening.attributes)) {
+        this.traverse(pathNode);
+        return;
+      }
+      const attrs = opening.attributes;
+      const hasStatic = attrs.some(
+        (a) => a.type === 'JSXAttribute' && a.name && a.name.name === 'data-preview-static'
+      );
+      if (!hasStatic) {
+        this.traverse(pathNode);
+        return;
+      }
+
+      const tag = getJsxName(pathNode.node);
+      const lower = String(tag || '').toLowerCase();
+      if (BROAD_CONTENT_CONTAINERS.has(tag) || BROAD_CONTENT_CONTAINERS.has(lower)) {
+        opening.attributes = attrs.filter(
+          (a) => !(a.type === 'JSXAttribute' && a.name && a.name.name === 'data-preview-static')
+        );
+        cleaned++;
+        this.traverse(pathNode);
+        return;
+      }
+
+      const hasDirectEditable = attrs.some(
+        (a) => a.type === 'JSXAttribute' && a.name && (
+          a.name.name === 'data-preview-field-path' ||
+          a.name.name === 'data-preview-list-path' ||
+          a.name.name === 'data-preview-item-path'
+        )
+      );
+
+      let hasNestedEditable = false;
+      if (!hasDirectEditable) {
+        recast.types.visit(pathNode.node, {
+          visitJSXElement(inner) {
+            if (inner.node === pathNode.node) {
+              this.traverse(inner);
+              return;
+            }
+            const innerAttrs = inner.node.openingElement?.attributes || [];
+            if (innerAttrs.some(
+              (a) => a.type === 'JSXAttribute' && a.name && (
+                a.name.name === 'data-preview-field-path' ||
+                a.name.name === 'data-preview-list-path' ||
+                a.name.name === 'data-preview-item-path'
+              )
+            )) {
+              hasNestedEditable = true;
+              return false;
+            }
+            this.traverse(inner);
+          },
+        });
+      }
+
+      if (hasDirectEditable || hasNestedEditable) {
+        opening.attributes = attrs.filter(
+          (a) => !(a.type === 'JSXAttribute' && a.name && a.name.name === 'data-preview-static')
+        );
+        cleaned++;
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return cleaned;
+}
+
+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 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 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) =>
+            !(
+              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;
+}
+
+function healLegacyProductDetailLinks(ast) {
+  let healed = 0;
+  let needsImport = false;
+
+  recast.types.visit(ast, {
+    visitJSXAttribute(pathNode) {
+      const attr = pathNode.node;
+      if (attr.name && attr.name.name === 'href' && attr.value) {
+        if (attr.value.type === 'JSXExpressionContainer' && attr.value.expression) {
+          const expr = attr.value.expression;
+          if (expr.type === 'TemplateLiteral') {
+            const quasis = expr.quasis || [];
+            if (quasis.length >= 1 && typeof quasis[0].value.raw === 'string' && quasis[0].value.raw.startsWith('/products/')) {
+              const arg = expr.expressions && expr.expressions[0];
+              if (arg) {
+                attr.value.expression = b.callExpression(
+                  b.identifier('platformProductDetailHref'),
+                  [arg]
+                );
+                healed++;
+                needsImport = true;
+              }
+            }
+          } else if (
+            expr.type === 'BinaryExpression' &&
+            expr.operator === '+' &&
+            expr.left &&
+            (expr.left.value === '/products/' || expr.left.value === '/products')
+          ) {
+            attr.value.expression = b.callExpression(
+              b.identifier('platformProductDetailHref'),
+              [expr.right]
+            );
+            healed++;
+            needsImport = true;
+          }
+        }
+      }
+      this.traverse(pathNode);
+    },
+  });
+
+  if (needsImport) {
+    ensureImport(ast, '@deneb-ui/ui', ['platformProductDetailHref']);
+  }
+  return healed;
+}
+
+function healSectionOverflowHidden(ast) {
+  let healed = 0;
+  recast.types.visit(ast, {
+    visitJSXOpeningElement(pathNode) {
+      const node = pathNode.node;
+      const tag = getJsxName(node);
+      const lower = String(tag || '').toLowerCase();
+      const isContainer = lower === 'section' || lower === 'div' || lower === 'main' || lower === 'article';
+      if (!isContainer) {
+        this.traverse(pathNode);
+        return;
+      }
+      const classAttr = (node.attributes || []).find(
+        (a) => a.type === 'JSXAttribute' && a.name && (a.name.name === 'className' || a.name.name === 'class')
+      );
+      if (!classAttr || !classAttr.value) {
+        this.traverse(pathNode);
+        return;
+      }
+      let modified = false;
+      if (classAttr.value.type === 'StringLiteral' || classAttr.value.type === 'Literal') {
+        const val = String(classAttr.value.value || '');
+        if (/\boverflow-hidden\b/.test(val)) {
+          classAttr.value.value = val.replace(/\boverflow-hidden\b/g, 'overflow-clip');
+          modified = true;
+        }
+      } else if (classAttr.value.type === 'JSXExpressionContainer') {
+        const expr = classAttr.value.expression;
+        if (expr && (expr.type === 'StringLiteral' || expr.type === 'Literal')) {
+          const val = String(expr.value || '');
+          if (/\boverflow-hidden\b/.test(val)) {
+            expr.value = val.replace(/\boverflow-hidden\b/g, 'overflow-clip');
+            modified = true;
+          }
+        } else if (expr && expr.type === 'TemplateLiteral') {
+          for (const quasi of expr.quasis || []) {
+            if (quasi.value && /\boverflow-hidden\b/.test(quasi.value.raw || '')) {
+              quasi.value.raw = (quasi.value.raw || '').replace(/\boverflow-hidden\b/g, 'overflow-clip');
+              if (quasi.value.cooked) {
+                quasi.value.cooked = (quasi.value.cooked || '').replace(/\boverflow-hidden\b/g, 'overflow-clip');
+              }
+              modified = true;
+            }
+          }
+        }
+      }
+      if (modified) healed++;
+      this.traverse(pathNode);
+    },
+  });
+  return healed;
+}
+
+function healDecorativeOverlays(ast) {
+  let healed = 0;
+  recast.types.visit(ast, {
+    visitJSXElement(pathNode) {
+      const node = pathNode.node;
+      const tag = getJsxName(node);
+      const lower = String(tag || '').toLowerCase();
+      if (lower !== 'div' && lower !== 'span') {
+        this.traverse(pathNode);
+        return;
+      }
+      const hasRealChildren = (node.children || []).some(
+        (c) => c.type === 'JSXElement' || (c.type === 'JSXText' && c.value.trim().length > 0)
+      );
+      if (hasRealChildren) {
+        this.traverse(pathNode);
+        return;
+      }
+      const classAttr = (node.openingElement.attributes || []).find(
+        (a) => a.type === 'JSXAttribute' && a.name && (a.name.name === 'className' || a.name.name === 'class')
+      );
+      if (!classAttr || !classAttr.value) {
+        this.traverse(pathNode);
+        return;
+      }
+      let modified = false;
+      const overlayPattern = /\b(?:bg-gradient-|bg-black\/|bg-white\/|bg-slate-\d+\/|backdrop-blur)/;
+      const isAbsolute = /\babsolute\b/;
+      const hasPointerEvents = /\bpointer-events-(?:none|auto)\b/;
+
+      if (classAttr.value.type === 'StringLiteral' || classAttr.value.type === 'Literal') {
+        const val = String(classAttr.value.value || '');
+        if (isAbsolute.test(val) && overlayPattern.test(val) && !hasPointerEvents.test(val)) {
+          classAttr.value.value = `${val} pointer-events-none`;
+          modified = true;
+        }
+      } else if (classAttr.value.type === 'JSXExpressionContainer') {
+        const expr = classAttr.value.expression;
+        if (expr && (expr.type === 'StringLiteral' || expr.type === 'Literal')) {
+          const val = String(expr.value || '');
+          if (isAbsolute.test(val) && overlayPattern.test(val) && !hasPointerEvents.test(val)) {
+            expr.value = `${val} pointer-events-none`;
+            modified = true;
+          }
+        } else if (expr && expr.type === 'TemplateLiteral') {
+          const fullText = (expr.quasis || []).map((q) => q.value?.raw || '').join(' ');
+          if (isAbsolute.test(fullText) && overlayPattern.test(fullText) && !hasPointerEvents.test(fullText)) {
+            const lastQuasi = expr.quasis[expr.quasis.length - 1];
+            if (lastQuasi && lastQuasi.value) {
+              lastQuasi.value.raw = `${lastQuasi.value.raw} pointer-events-none`;
+              if (lastQuasi.value.cooked) {
+                lastQuasi.value.cooked = `${lastQuasi.value.cooked} pointer-events-none`;
+              }
+              modified = true;
+            }
+          }
+        }
+      }
+      if (modified) healed++;
+      this.traverse(pathNode);
+    },
+  });
+  return healed;
+}
+
+function healMissingSiteDataHooks(code, filePath = 'file.tsx') {
+  if (!code.includes('siteData')) return code;
+  try {
+    const ast = parseSource(code, filePath);
+    const injected = injectSiteDataHook(ast);
+    if (injected) {
+      ensureImport(ast, '@deneb-ui/ui', ['useSiteData']);
+      return printSource(ast, code);
+    }
+  } catch {}
+  return code;
+}
+
+module.exports = {
+  sanitizeContradictoryMarkers,
+  healBroadContainerMarkers,
+  findFirstLeafChild,
+  healHiddenPreviewMarkers,
+  healLegacyProductDetailLinks,
+  healSectionOverflowHidden,
+  healDecorativeOverlays,
+  healMissingSiteDataHooks,
+};