@deneb-ui/cli 2.0.50 → 2.0.52

package/src/arc/manifest.cjs

@@ -11,6 +11,43 @@ const {
   wildcardPath,
 } = require('./fivora-contract.cjs');
 
+function pruneUnboundLeaves(content, isBound) {
+  function walk(node, path) {
+    if (Array.isArray(node)) {
+      node.forEach((item, index) => {
+        if (item && typeof item === 'object') walk(item, `${path}[${index}]`);
+      });
+      return;
+    }
+    if (!isPlainObject(node)) return;
+    for (const key of Object.keys(node)) {
+      const next = path ? `${path}.${key}` : key;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        const listBound =
+          isBound(next) || isBound(`${next}[0]`) || isBound(`${next}[*]`);
+        if (!listBound && !isAllowedControlOnly(next)) {
+          delete node[key];
+          continue;
+        }
+        walk(value, next);
+        continue;
+      }
+      if (isPlainObject(value)) {
+        walk(value, next);
+        if (Object.keys(value).length === 0 && !isBound(next) && !isAllowedControlOnly(next)) {
+          delete node[key];
+        }
+        continue;
+      }
+      if (!isBound(next) && !isAllowedControlOnly(next)) {
+        delete node[key];
+      }
+    }
+  }
+  walk(content, '');
+}
+
 function setDeep(target, pathStr, value) {
   const parts = String(pathStr).split('.').filter(Boolean);
   let curr = target;
@@ -254,11 +291,32 @@ function baseContent(projectName, routes) {
 
 /**
  * Fivora strict mode requires every concrete site-data field to either render a
- * data-preview-field-path marker or be declared control-only. ARC always emits
- * a merchant-facing baseline (business phone, logo, nav labels) that an
- * arbitrary project may not render, so every unbound path is declared here
- * instead of being silently shipped as an ingest failure.
+ * data-preview-field-path marker or be declared control-only. Control-only is
+ * reserved for ids, internal flags, and the unrendered merchant baseline — not
+ * as a dump for fields ARC planned but failed to bind.
  */
+const BASELINE_CONTROL_ONLY = /^(common\.(websiteTitle|shortDescription|logoUrl|headerCtaLabel|copyright|navLabels(\.[^.]+)?|business(\.[^.]+)*))$/;
+const SYSTEM_FIELD = /(^|\.)(id|key|slug|internalId|sku|_id)$/i;
+
+function slimListItems(items, itemFields) {
+  const keys = (itemFields || []).map((field) => field.key).filter(Boolean);
+  if (!keys.length || !Array.isArray(items)) return items || [];
+  return items.map((item) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) return item;
+    const out = {};
+    for (const key of keys) {
+      if (!(key in item)) continue;
+      if (Array.isArray(item[key])) continue;
+      out[key] = item[key];
+    }
+    return Object.keys(out).length ? out : item;
+  });
+}
+
+function isAllowedControlOnly(path) {
+  return BASELINE_CONTROL_ONLY.test(path) || SYSTEM_FIELD.test(path);
+}
+
 function computeControlOnlyPaths(content, boundPaths, declared = []) {
   const inventory = enumerateContentPaths(content);
   const bound = new Set([...(boundPaths || [])].map(wildcardPath));
@@ -266,9 +324,7 @@ function computeControlOnlyPaths(content, boundPaths, declared = []) {
 
   for (const declaredPath of declared) {
     const canonical = canonicalizeMarkerPath(declaredPath);
-    if (!canonical) continue;
-    // Drop stale declarations that no longer exist in content; the platform
-    // rejects controlOnlyPaths entries it cannot resolve.
+    if (!canonical || !isAllowedControlOnly(canonical)) continue;
     const known = [...inventory.fieldPatterns, ...inventory.concreteFields].some(
       (path) => wildcardPath(path) === wildcardPath(canonical)
     );
@@ -276,7 +332,8 @@ function computeControlOnlyPaths(content, boundPaths, declared = []) {
   }
 
   for (const path of inventory.concreteFields) {
-    if (!bound.has(wildcardPath(path))) controlOnly.add(path);
+    if (bound.has(wildcardPath(path))) continue;
+    if (isAllowedControlOnly(path)) controlOnly.add(path);
   }
 
   return [...controlOnly].sort();
@@ -314,6 +371,8 @@ function buildSiteDataAndManifest({
   existingSiteData,
   existingManifest,
   boundFieldPaths = [],
+  boundListPaths = [],
+  extraFields = [],
   markerRoutes = {},
 }) {
   const routes = (profile.routes && profile.routes.length ? profile.routes : [{ id: 'home', label: 'Home', route: '/', required: true }])
@@ -329,7 +388,15 @@ function buildSiteDataAndManifest({
   // Recipes may hint schema shape, but must not dump another storefront's content
   // into an unrelated project. Extracted values always win.
 
-  const plannedFields = collectFieldsFromPlan(plan);
+  const plannedFields = [...collectFieldsFromPlan(plan), ...(extraFields || [])];
+  const boundSet = new Set(
+    [...(boundFieldPaths || []), ...(boundListPaths || [])].map((path) => wildcardPath(path))
+  );
+  function isBound(path) {
+    if (!path) return false;
+    const wild = wildcardPath(path);
+    return boundSet.has(wild) || [...boundSet].some((marker) => wildcardPath(marker) === wild);
+  }
 
   // A second `init` run re-reads already-transformed sources, where the former
   // literals are now site-data expressions and therefore no longer detectable.
@@ -373,8 +440,15 @@ function buildSiteDataAndManifest({
 
   for (const field of plannedFields) {
     if (field.type === 'list') {
-      setDeep(content, field.path, field.value ?? []);
-      upsertSchemaList(editorSections, field.path, field.itemFields, field.value);
+      if (!isBound(field.path) && !isBound(`${field.path}[0]`) && !isBound(`${field.path}[*]`)) continue;
+      const value = slimListItems(field.value ?? [], field.itemFields);
+      setDeep(content, field.path, value);
+      upsertSchemaList(editorSections, field.path, field.itemFields, value);
+      continue;
+    }
+    if (!isBound(field.path) && !isAllowedControlOnly(field.path)) continue;
+    if (!isBound(field.path) && isAllowedControlOnly(field.path)) {
+      setDeep(content, field.path, field.value ?? '');
       continue;
     }
     setDeep(content, field.path, field.value ?? '');
@@ -387,12 +461,15 @@ function buildSiteDataAndManifest({
     // Planned extracted values should win over empty recipe defaults when existing is absent,
     // but never erase merchant-configured existing values.
     for (const field of plannedFields) {
+      if (!isBound(field.path) && field.type !== 'list' && !isAllowedControlOnly(field.path)) continue;
       const existingVal = getDeep(existingSiteData.content, field.path);
       if (existingVal !== undefined) setDeep(content, field.path, existingVal);
       else if (field.value !== undefined) setDeep(content, field.path, field.value);
     }
   }
 
+  pruneUnboundLeaves(content, isBound);
+
   const siteData = {
     denebVersion: existingSiteData?.denebVersion || undefined,
     arcVersion: ARC_VERSION,
@@ -503,4 +580,5 @@ module.exports = {
   upsertSchemaList,
   enrichSchemasFromContent,
   isListActionCtaKey,
+  isAllowedControlOnly,
 };

package/src/arc/planner.cjs

@@ -9,7 +9,7 @@ const { appendStyleBindTransforms } = require('./style-candidates.cjs');
 function recipeBoost(candidate, recipe) {
   if (!recipe) return 0;
   let boost = 0;
-  if (recipe.actionRules?.splitActionAndLabel && candidate.operation === 'split-action-contract') boost += 0.03;
+  if (recipe.actionRules?.splitActionAndLabel && (candidate.operation === 'split-action-contract' || candidate.operation === 'form-submit-action')) boost += 0.03;
   const keywords = recipe.signatures?.keywords || [];
   const hay = `${candidate.tag} ${candidate.value || ''} ${candidate.label || ''} ${candidate.file || ''}`.toLowerCase();
   if (keywords.some((kw) => hay.includes(String(kw).toLowerCase()))) boost += 0.02;
@@ -66,8 +66,8 @@ function planTransformations({ profile, analyses, recipe }) {
       }
 
       const extra = { ...(candidate.extra || {}) };
-      if (candidate.operation === 'split-action-contract') {
-        extra.action = extra.action || classifyHref(candidate.value);
+      if (candidate.operation === 'split-action-contract' || candidate.operation === 'form-submit-action') {
+        extra.action = extra.action || (candidate.operation === 'form-submit-action' ? 'form-submit' : classifyHref(candidate.value));
         extra.paired = true;
       }
 
@@ -107,7 +107,7 @@ function planTransformations({ profile, analyses, recipe }) {
         continue;
       }
 
-      if (candidate.operation === 'split-action-contract') {
+      if (candidate.operation === 'split-action-contract' || candidate.operation === 'form-submit-action') {
         const urlName = inferFieldName('url', candidate.tag, candidate.label, extra);
         const labelName = inferFieldName('label', candidate.tag, candidate.label, { ...extra, paired: true });
         const actionSection = sectionForAction(scope, section, extra);
@@ -117,6 +117,9 @@ function planTransformations({ profile, analyses, recipe }) {
         transform.labelField = uniquePath(usedPaths, sibling.join('.'));
         transform.fieldType = 'url';
         transform.labelFieldType = 'text';
+        if (candidate.operation === 'form-submit-action') {
+          transform.formContext = true;
+        }
       } else if (candidate.operation === 'extract-url') {
         transform.field = buildFieldPath({
           scope,
@@ -186,7 +189,8 @@ function planTransformations({ profile, analyses, recipe }) {
               type: typeof sample[k] === 'number' ? 'number' : /image|photo|avatar/i.test(k) ? 'image' : /url|link/i.test(k) ? 'url' : 'text',
             }));
         }
-        if (!transform.itemFields.length || !extra.objectItems || extra.hasComponentRef) transform.decision = 'skip';
+        transform.hasComponentRef = Boolean(extra.hasComponentRef);
+        if (!transform.itemFields.length || !extra.objectItems) transform.decision = 'skip';
       } else {
         transform.field = buildFieldPath({
           scope,
@@ -238,7 +242,7 @@ function sectionForAction(scope, section, extra) {
   if (scope === 'common' && (extra.social || ['instagram', 'facebook', 'twitter', 'tiktok', 'youtube', 'linkedin'].includes(extra.action))) {
     return 'footer';
   }
-  if (['whatsapp', 'phone', 'email', 'directions', 'location'].includes(extra.action)) {
+  if (['whatsapp', 'phone', 'email', 'directions', 'location', 'form-submit'].includes(extra.action)) {
     return section || 'contact';
   }
   if (extra.action === 'shop') {

package/src/arc/printer.cjs

@@ -84,9 +84,12 @@ function printValidation(validation, coverage, design) {
   else warn('AST validation reported parse issues');
   if (validation.contractPassed) ok('editable contracts');
   else warn('editable contract issues detected');
+  if (validation.fivoraContractPassed) ok('Fivora strict contract');
+  else warn('Fivora strict contract failed — package is not upload-ready');
   ok('manifest');
   if (validation.idempotencyPassed !== false) ok('idempotency');
   console.log('');
+  console.log(`  Visual coverage: ${coverage.visualCoverage != null ? coverage.visualCoverage : coverage.editableCoverage}%`);
   console.log(`  Editable coverage: ${coverage.editableCoverage}%`);
   console.log(`  Design preservation: ${design.score}%`);
 }
@@ -135,6 +138,11 @@ function printSuccess() {
   console.log(`\n${C.green}${C.bold}Deneb ARC completed successfully.${C.reset}\n`);
 }
 
+function printContractFailed() {
+  console.log(`\n${C.yellow}${C.bold}Deneb ARC finished with Fivora contract findings.${C.reset}`);
+  console.log(`${C.dim}Files were kept for debugging. This package is not upload-ready. Re-run with --strict to roll back.${C.reset}\n`);
+}
+
 function printUncoveredText(findings = []) {
   if (!findings.length) return;
   warn(`${findings.length} visible text node(s) still uncovered — run deneb validate . before packaging`);
@@ -229,6 +237,7 @@ module.exports = {
   printDryRun,
   printError,
   printSuccess,
+  printContractFailed,
   printUncoveredText,
   printDeveloperNextSteps,
   printRollback,

package/src/arc/residual.cjs

@@ -0,0 +1,400 @@
+'use strict';
+
+/**
+ * Pass B of the ARC planner: residual bind-or-static closure.
+ *
+ * Confidence cannot rescue dynamic leftovers (c_sem = 0.15). After Pass A,
+ * every remaining visible literal is either bound to a field or marked
+ * data-preview-static with a reason. This pass ignores the 0.60 skip floor.
+ */
+
+const recast = require('recast');
+const {
+  parseSource,
+  printSource,
+  getJsxName,
+  hasJsxAttribute,
+  findJsxAttribute,
+  collectJsxText,
+  wrapTextInEditableSpan,
+  jsxPreviewAttr,
+  jsxStaticAttr,
+  ensureStyleAttrs,
+  siteDataBinding,
+  b,
+} = require('./ast.cjs');
+const {
+  SKIP_TAGS,
+  HEADING_TAGS,
+  TEXT_TAGS,
+  ACTION_TAGS,
+  IMAGE_TAGS,
+  DECORATIVE_TAGS,
+  isIconComponent,
+} = require('./adapters.cjs');
+const { BROAD_CONTENT_CONTAINERS } = require('./fivora-contract.cjs');
+const { inferSection, inferFieldName, buildFieldPath, classifyFieldType } = require('./field-paths.cjs');
+const { isStaticSkipText } = require('./semantic.cjs');
+
+const LEAF_TEXT_TAGS = new Set([
+  ...HEADING_TAGS,
+  ...TEXT_TAGS,
+  'em', 'strong', 'small', 'b', 'i', 'u', 'code', 'time', 'cite', 'mark',
+  'dt', 'dd', 'th', 'td', 'legend', 'caption',
+]);
+
+const CHROME_TEXT_RE = /^(×|x|✕|✖|\+|−|-|•|·|…|\.|…|\||\/|©|®|™|\d+)$/i;
+const CART_CHROME_RE = /^(qty|quantity|subtotal|total|cart|checkout|remove|close|menu)$/i;
+
+function attrLiteral(node, name) {
+  const attr = findJsxAttribute(node, name);
+  if (!attr || !attr.value) return '';
+  if (attr.value.type === 'StringLiteral' || attr.value.type === 'Literal') return String(attr.value.value || '');
+  if (attr.value.type === 'JSXExpressionContainer') {
+    const expr = attr.value.expression;
+    if (expr && (expr.type === 'StringLiteral' || expr.type === 'Literal')) return String(expr.value || '');
+  }
+  return '';
+}
+
+function hasEditableMarker(node) {
+  return (
+    hasJsxAttribute(node, 'data-preview-field-path') ||
+    hasJsxAttribute(node, 'data-preview-list-path') ||
+    hasJsxAttribute(node, 'data-preview-item-path') ||
+    hasJsxAttribute(node, 'data-preview-static')
+  );
+}
+
+function ancestorHasStatic(pathNode) {
+  let current = pathNode.parent;
+  while (current) {
+    const node = current.node || current.value;
+    if (node && node.type === 'JSXElement' && hasJsxAttribute(node, 'data-preview-static')) return true;
+    current = current.parentPath || current.parent;
+  }
+  return false;
+}
+
+function inMapCallback(pathNode) {
+  let current = pathNode.parent;
+  while (current) {
+    const node = current.node || current.value;
+    if (
+      node &&
+      node.type === 'CallExpression' &&
+      node.callee &&
+      node.callee.type === 'MemberExpression' &&
+      node.callee.property &&
+      node.callee.property.name === 'map'
+    ) {
+      return true;
+    }
+    current = current.parentPath || current.parent;
+  }
+  return false;
+}
+
+function isMeaningfulVisibleText(text) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!value || value.length <= 2) return false;
+  if (!/\p{L}/u.test(value)) return false;
+  if (isStaticSkipText(value)) return false;
+  if (CHROME_TEXT_RE.test(value)) return false;
+  return true;
+}
+
+function isDecorativeCopy(text, tag, className) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!value) return true;
+  if (CHROME_TEXT_RE.test(value)) return true;
+  if (CART_CHROME_RE.test(value) && /cart|drawer|qty|quantity/i.test(className || '')) return true;
+  if (DECORATIVE_TAGS.has(tag) || tag === 'svg') return true;
+  if (/\bsr-only\b|\bhidden\b/.test(className || '')) return true;
+  return false;
+}
+
+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, '')) {
+    return { bind: false, reason: 'decorative-icon' };
+  }
+  if (isDecorativeCopy(text, tag, className)) {
+    return { bind: false, reason: 'chrome' };
+  }
+  if (IMAGE_TAGS.has(tag) && attrLiteral(node, 'src')) {
+    return { bind: true, kind: 'image', value: attrLiteral(node, 'src') };
+  }
+  if (isMeaningfulVisibleText(text)) {
+    return { bind: true, kind: 'text', value: text };
+  }
+  if (text && text.trim()) {
+    return { bind: false, reason: 'decorative-copy' };
+  }
+  return null;
+}
+
+function ensureStaticOnLeaf(node, reason) {
+  const tag = getJsxName(node);
+  if (BROAD_CONTENT_CONTAINERS.has(tag.toLowerCase()) || BROAD_CONTENT_CONTAINERS.has(tag)) {
+    return false;
+  }
+  if (hasJsxAttribute(node, 'data-preview-static') || hasEditableMarker(node)) return false;
+  node.openingElement.attributes.push(jsxStaticAttr(reason || 'decorative'));
+  return true;
+}
+
+function wrapFirstLiteralAsStatic(node, reason) {
+  const nextChildren = [];
+  let wrapped = false;
+  for (const child of node.children || []) {
+    if (!wrapped && child.type === 'JSXText' && child.value.replace(/\s+/g, '').length) {
+      const leading = child.value.match(/^\s*/)?.[0] || '';
+      const trailing = child.value.match(/\s*$/)?.[0] || '';
+      const text = child.value.trim();
+      if (leading) nextChildren.push(b.jsxText(leading));
+      nextChildren.push(
+        b.jsxElement(
+          b.jsxOpeningElement(b.jsxIdentifier('span'), [jsxStaticAttr(reason || 'decorative')], false),
+          b.jsxClosingElement(b.jsxIdentifier('span')),
+          [b.jsxText(text)],
+          false
+        )
+      );
+      if (trailing) nextChildren.push(b.jsxText(trailing));
+      wrapped = true;
+      continue;
+    }
+    nextChildren.push(child);
+  }
+  if (wrapped) node.children = nextChildren;
+  return wrapped;
+}
+
+function applyResidualPass({ code, file, ownerScope, usedPaths, componentName, role }) {
+  if (!code || !code.includes('<')) {
+    return { code, changed: false, fields: [], applied: 0 };
+  }
+
+  let ast;
+  try {
+    ast = parseSource(code, file);
+  } catch {
+    return { code, changed: false, fields: [], applied: 0 };
+  }
+
+  const fields = [];
+  let applied = 0;
+  const used = usedPaths instanceof Set ? usedPaths : new Set(usedPaths || []);
+
+  recast.types.visit(ast, {
+    visitJSXElement(pathNode) {
+      const node = pathNode.node;
+      const tag = getJsxName(node);
+      const lower = tag.toLowerCase();
+
+      if (!tag || SKIP_TAGS.has(tag) || tag === 'React.Fragment' || tag === 'Fragment') {
+        this.traverse(pathNode);
+        return;
+      }
+
+      if (hasEditableMarker(node) || ancestorHasStatic(pathNode)) {
+        this.traverse(pathNode);
+        return;
+      }
+
+      if (DECORATIVE_TAGS.has(tag) || isIconComponent(tag, '')) {
+        if (ensureStaticOnLeaf(node, 'decorative-icon')) applied++;
+        this.traverse(pathNode);
+        return;
+      }
+
+      const text = collectJsxText(node);
+      const src = attrLiteral(node, 'src');
+      const placeholder = attrLiteral(node, 'placeholder');
+      const alt = attrLiteral(node, 'alt');
+
+      const decision = classifyResidual(node, text, tag);
+      const insideMap = inMapCallback(pathNode);
+
+      if (insideMap && decision && decision.bind && ACTION_TAGS.has(tag)) {
+        // Repeated chrome inside a list stays static so we never couple parallel arrays.
+        if (BROAD_CONTENT_CONTAINERS.has(lower)) {
+          if (wrapFirstLiteralAsStatic(node, 'collection-chrome')) applied++;
+        } else if (ensureStaticOnLeaf(node, 'collection-chrome')) {
+          applied++;
+        }
+        this.traverse(pathNode);
+        return;
+      }
+
+      if (IMAGE_TAGS.has(tag) && src && !src.startsWith('{') && !hasJsxAttribute(node, 'data-preview-field-path')) {
+        const section = inferSection({
+          componentName,
+          fileName: file,
+          className: attrLiteral(node, 'className'),
+          tag,
+          role,
+        });
+        const field = buildFieldPath({
+          scope: ownerScope || 'home',
+          section,
+          field: inferFieldName('image', tag, src, {}),
+          used,
+        });
+        node.openingElement.attributes.push(jsxPreviewAttr(field));
+        const srcAttr = findJsxAttribute(node, 'src');
+        if (srcAttr) {
+          srcAttr.value = b.jsxExpressionContainer(siteDataBinding(field.split('.'), src, 'image'));
+        }
+        fields.push({ path: field, type: 'image', value: src });
+        applied++;
+        this.traverse(pathNode);
+        return;
+      }
+
+      if (placeholder && !hasJsxAttribute(node, 'data-preview-field-path')) {
+        const section = inferSection({ componentName, fileName: file, tag, role });
+        const field = buildFieldPath({
+          scope: ownerScope || 'home',
+          section,
+          field: inferFieldName('placeholder', tag, placeholder, {}),
+          used,
+        });
+        node.openingElement.attributes.push(jsxPreviewAttr(field));
+        const ph = findJsxAttribute(node, 'placeholder');
+        if (ph) {
+          ph.value = b.jsxExpressionContainer(siteDataBinding(field.split('.'), placeholder, 'text'));
+        }
+        fields.push({ path: field, type: 'text', value: placeholder });
+        applied++;
+      }
+
+      if (alt && isMeaningfulVisibleText(alt) && !hasJsxAttribute(node, 'data-preview-field-path')) {
+        const section = inferSection({ componentName, fileName: file, tag, role });
+        const field = buildFieldPath({
+          scope: ownerScope || 'home',
+          section,
+          field: inferFieldName('alt', tag, alt, {}),
+          used,
+        });
+        const altAttr = findJsxAttribute(node, 'alt');
+        if (altAttr) {
+          altAttr.value = b.jsxExpressionContainer(siteDataBinding(field.split('.'), alt, 'text'));
+        }
+        fields.push({ path: field, type: 'text', value: alt });
+        applied++;
+      }
+
+      if (decision && decision.bind && decision.kind === 'text' && isMeaningfulVisibleText(text)) {
+        const section = inferSection({
+          componentName,
+          fileName: file,
+          className: attrLiteral(node, 'className'),
+          tag,
+          role,
+        });
+        const field = buildFieldPath({
+          scope: ownerScope || 'home',
+          section,
+          field: inferFieldName('text', tag, text, { tag }),
+          used,
+        });
+        const fieldType = classifyFieldType('text', text);
+
+        if (BROAD_CONTENT_CONTAINERS.has(lower) || BROAD_CONTENT_CONTAINERS.has(tag)) {
+          const nextChildren = [];
+          let wrapped = false;
+          for (const child of node.children || []) {
+            if (!wrapped && child.type === 'JSXText' && child.value.replace(/\s+/g, '').length) {
+              const leading = child.value.match(/^\s*/)?.[0] || '';
+              const trailing = child.value.match(/\s*$/)?.[0] || '';
+              if (leading) nextChildren.push(b.jsxText(leading));
+              nextChildren.push(wrapTextInEditableSpan(field, text, fieldType));
+              if (trailing) nextChildren.push(b.jsxText(trailing));
+              wrapped = true;
+              continue;
+            }
+            nextChildren.push(child);
+          }
+          if (wrapped) {
+            node.children = nextChildren;
+            fields.push({ path: field, type: fieldType, value: text });
+            applied++;
+          }
+        } else if (LEAF_TEXT_TAGS.has(tag) || HEADING_TAGS.has(tag) || tag === 'button' || tag === 'Button') {
+          if (ACTION_TAGS.has(tag) && (hasJsxAttribute(node, 'href') || tag === 'a' || tag === 'Link')) {
+            const nextChildren = [];
+            let wrapped = false;
+            for (const child of node.children || []) {
+              if (!wrapped && child.type === 'JSXText' && child.value.replace(/\s+/g, '').length) {
+                const leading = child.value.match(/^\s*/)?.[0] || '';
+                const trailing = child.value.match(/\s*$/)?.[0] || '';
+                if (leading) nextChildren.push(b.jsxText(leading));
+                nextChildren.push(wrapTextInEditableSpan(field, text, fieldType));
+                if (trailing) nextChildren.push(b.jsxText(trailing));
+                wrapped = true;
+                continue;
+              }
+              nextChildren.push(child);
+            }
+            if (wrapped) {
+              node.children = nextChildren;
+              fields.push({ path: field, type: fieldType, value: text });
+              applied++;
+            }
+          } else {
+            node.openingElement.attributes.push(jsxPreviewAttr(field));
+            ensureStyleAttrs(node, field, tag === 'button' || tag === 'Button' ? 'button' : 'text');
+            const nextChildren = [];
+            let replaced = false;
+            for (const child of node.children || []) {
+              if (!replaced && child.type === 'JSXText' && child.value.replace(/\s+/g, '').length) {
+                nextChildren.push(b.jsxExpressionContainer(siteDataBinding(field.split('.'), text, fieldType)));
+                replaced = true;
+              } else {
+                nextChildren.push(child);
+              }
+            }
+            if (replaced) node.children = nextChildren;
+            fields.push({ path: field, type: fieldType, value: text });
+            applied++;
+          }
+        } else if (!BROAD_CONTENT_CONTAINERS.has(lower)) {
+          if (ensureStaticOnLeaf(node, 'non-leaf-copy')) applied++;
+        } else if (wrapFirstLiteralAsStatic(node, 'container-copy')) {
+          applied++;
+        }
+        this.traverse(pathNode);
+        return;
+      }
+
+      if (decision && !decision.bind && text) {
+        if (BROAD_CONTENT_CONTAINERS.has(lower)) {
+          if (wrapFirstLiteralAsStatic(node, decision.reason || 'decorative')) applied++;
+        } else if (ensureStaticOnLeaf(node, decision.reason || 'decorative')) {
+          applied++;
+        }
+      }
+
+      this.traverse(pathNode);
+    },
+  });
+
+  if (applied === 0) {
+    return { code, changed: false, fields: [], applied: 0 };
+  }
+
+  return {
+    code: printSource(ast, code),
+    changed: true,
+    fields,
+    applied,
+  };
+}
+
+module.exports = {
+  applyResidualPass,
+  isMeaningfulVisibleText,
+};