@a11y-oracle/axe-bridge 1.0.0

package/dist/lib/resolvers/link-in-text-block.js

@@ -0,0 +1,141 @@
+/**
+ * @module link-in-text-block
+ *
+ * Resolver for axe-core's `link-in-text-block` incomplete rule
+ * (WCAG 1.4.1 Use of Color). Checks the DEFAULT/resting state of
+ * inline links for non-color visual differentiation.
+ *
+ * IMPORTANT: Hover/focus states are NOT checked. If a link only
+ * shows differentiation on hover or focus, that is a **Violation**.
+ * The link must be visually distinct in its resting state.
+ */
+import { parseColor, contrastRatio } from '@a11y-oracle/focus-analyzer';
+import { getSelector, cloneResults, findIncompleteRule, applyPromotions, } from '../resolver-pipeline.js';
+const RULE_ID = 'link-in-text-block';
+/** Default minimum contrast ratio between link color and surrounding text. */
+const DEFAULT_LINK_TEXT_CONTRAST = 3.0;
+/**
+ * Resolve incomplete `link-in-text-block` results.
+ *
+ * Checks the **default/resting state** of inline links for:
+ * 1. Non-color visual indicators (underline, border-bottom, font-weight diff)
+ * 2. Sufficient color contrast (≥ 3:1) between link and surrounding text
+ *
+ * If neither is present → Violation (indistinguishable from surrounding text).
+ *
+ * @param cdp - CDP session for querying computed styles.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional threshold override.
+ * @returns Modified results with resolved findings.
+ */
+export async function resolveLinkInTextBlock(cdp, axeResults, options) {
+    const clone = cloneResults(axeResults);
+    const found = findIncompleteRule(clone, RULE_ID);
+    if (!found)
+        return clone;
+    const { index, rule } = found;
+    const threshold = options?.linkTextContrastThreshold ?? DEFAULT_LINK_TEXT_CONTRAST;
+    const passNodes = [];
+    const violationNodes = [];
+    const incompleteNodes = [];
+    for (const node of rule.nodes) {
+        const selector = getSelector(node);
+        if (!selector) {
+            incompleteNodes.push(node);
+            continue;
+        }
+        // Query computed styles for link and its parent in DEFAULT state
+        const result = await cdp.send('Runtime.evaluate', {
+            expression: `(() => {
+        const link = document.querySelector(${JSON.stringify(selector)});
+        if (!link) return null;
+        const parent = link.parentElement;
+        if (!parent) return null;
+        const linkCS = window.getComputedStyle(link);
+        const parentCS = window.getComputedStyle(parent);
+        return {
+          link: {
+            textDecorationLine: linkCS.textDecorationLine,
+            borderBottomWidth: linkCS.borderBottomWidth,
+            borderBottomStyle: linkCS.borderBottomStyle,
+            fontWeight: linkCS.fontWeight,
+            color: linkCS.color,
+          },
+          parent: {
+            fontWeight: parentCS.fontWeight,
+            color: parentCS.color,
+          },
+        };
+      })()`,
+            returnByValue: true,
+        });
+        const data = result.result.value;
+        if (!data) {
+            incompleteNodes.push(node);
+            continue;
+        }
+        // Check 1: Non-color visual indicator in default state
+        if (hasNonColorIndicator(data)) {
+            passNodes.push(node);
+            continue;
+        }
+        // Check 2: Sufficient contrast between link color and surrounding text
+        const linkColor = parseColor(data.link.color);
+        const parentColor = parseColor(data.parent.color);
+        if (linkColor && parentColor) {
+            const cr = contrastRatio(linkColor, parentColor);
+            if (cr >= threshold) {
+                passNodes.push(node);
+                continue;
+            }
+        }
+        // No non-color indicator and insufficient contrast → Violation
+        violationNodes.push(node);
+    }
+    applyPromotions(clone, index, rule, {
+        passNodes,
+        violationNodes,
+        incompleteNodes,
+    });
+    return clone;
+}
+/**
+ * Check if the link has a non-color visual indicator in its default state.
+ */
+function hasNonColorIndicator(data) {
+    // Underline present
+    if (data.link.textDecorationLine.includes('underline')) {
+        return true;
+    }
+    // Border-bottom present (visible border)
+    const borderWidth = parseFloat(data.link.borderBottomWidth);
+    if (!isNaN(borderWidth) &&
+        borderWidth > 0 &&
+        data.link.borderBottomStyle !== 'none') {
+        return true;
+    }
+    // Font-weight difference between link and parent
+    const linkWeight = parseFontWeight(data.link.fontWeight);
+    const parentWeight = parseFontWeight(data.parent.fontWeight);
+    if (linkWeight !== parentWeight) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Parse CSS font-weight to a numeric value.
+ */
+function parseFontWeight(weight) {
+    switch (weight) {
+        case 'normal':
+            return 400;
+        case 'bold':
+            return 700;
+        case 'lighter':
+            return 100;
+        case 'bolder':
+            return 900;
+        default:
+            return parseInt(weight, 10) || 400;
+    }
+}

package/dist/lib/resolvers/scrollable-region-focusable.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @module scrollable-region-focusable
+ *
+ * Resolver for axe-core's `scrollable-region-focusable` incomplete rule
+ * (WCAG 2.1.1 Keyboard). Verifies that scrollable containers are
+ * keyboard-accessible, either via tabindex or focusable children.
+ */
+import type { CDPSessionLike } from '@a11y-oracle/cdp-types';
+import type { AxeResults, ScrollableRegionOptions } from '../types.js';
+/**
+ * Resolve incomplete `scrollable-region-focusable` results.
+ *
+ * For each flagged scrollable container:
+ * 1. Check if actually scrollable (scrollHeight > clientHeight).
+ *    If not → **Pass** (false positive).
+ * 2. Check for `tabindex >= 0` on container → **Pass**.
+ * 3. Check for visible focusable children. If none → **Violation**.
+ * 4. Focus last focusable child, check if scroll position changed → **Pass**.
+ *
+ * @param cdp - CDP session for querying DOM properties.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional configuration.
+ * @returns Modified results with resolved findings.
+ */
+export declare function resolveScrollableRegionFocusable(cdp: CDPSessionLike, axeResults: AxeResults, options?: ScrollableRegionOptions): Promise<AxeResults>;
+//# sourceMappingURL=scrollable-region-focusable.d.ts.map

package/dist/lib/resolvers/scrollable-region-focusable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrollable-region-focusable.d.ts","sourceRoot":"","sources":["../../../src/lib/resolvers/scrollable-region-focusable.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAW,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAoBhF;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,gCAAgC,CACpD,GAAG,EAAE,cAAc,EACnB,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,UAAU,CAAC,CAgHrB"}

package/dist/lib/resolvers/scrollable-region-focusable.js

@@ -0,0 +1,139 @@
+/**
+ * @module scrollable-region-focusable
+ *
+ * Resolver for axe-core's `scrollable-region-focusable` incomplete rule
+ * (WCAG 2.1.1 Keyboard). Verifies that scrollable containers are
+ * keyboard-accessible, either via tabindex or focusable children.
+ */
+import { getSelector, cloneResults, findIncompleteRule, applyPromotions, } from '../resolver-pipeline.js';
+const RULE_ID = 'scrollable-region-focusable';
+/** CSS selector for focusable elements within a container. */
+const FOCUSABLE_SELECTOR = [
+    'a[href]',
+    'button:not([disabled])',
+    'input:not([disabled]):not([type="hidden"])',
+    'select:not([disabled])',
+    'textarea:not([disabled])',
+    '[tabindex]:not([tabindex="-1"])',
+].join(', ');
+/**
+ * Resolve incomplete `scrollable-region-focusable` results.
+ *
+ * For each flagged scrollable container:
+ * 1. Check if actually scrollable (scrollHeight > clientHeight).
+ *    If not → **Pass** (false positive).
+ * 2. Check for `tabindex >= 0` on container → **Pass**.
+ * 3. Check for visible focusable children. If none → **Violation**.
+ * 4. Focus last focusable child, check if scroll position changed → **Pass**.
+ *
+ * @param cdp - CDP session for querying DOM properties.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional configuration.
+ * @returns Modified results with resolved findings.
+ */
+export async function resolveScrollableRegionFocusable(cdp, axeResults, options) {
+    const clone = cloneResults(axeResults);
+    const found = findIncompleteRule(clone, RULE_ID);
+    if (!found)
+        return clone;
+    const { index, rule } = found;
+    const maxChildren = options?.maxChildren ?? 50;
+    const passNodes = [];
+    const violationNodes = [];
+    const incompleteNodes = [];
+    for (const node of rule.nodes) {
+        const selector = getSelector(node);
+        if (!selector) {
+            incompleteNodes.push(node);
+            continue;
+        }
+        const result = await cdp.send('Runtime.evaluate', {
+            expression: `(() => {
+        const container = document.querySelector(${JSON.stringify(selector)});
+        if (!container) return null;
+
+        // Check 1: Is it actually scrollable?
+        const isScrollableV = container.scrollHeight > container.clientHeight;
+        const isScrollableH = container.scrollWidth > container.clientWidth;
+        if (!isScrollableV && !isScrollableH) {
+          return { category: 'pass', reason: 'not-scrollable' };
+        }
+
+        // Check 2: Does the container itself have tabindex?
+        if (container.tabIndex >= 0) {
+          return { category: 'pass', reason: 'has-tabindex' };
+        }
+
+        // Check 3: Find visible focusable children
+        const focusable = container.querySelectorAll(${JSON.stringify(FOCUSABLE_SELECTOR)});
+        const visible = [];
+        for (let i = 0; i < Math.min(focusable.length, ${maxChildren}); i++) {
+          const el = focusable[i];
+          const cs = window.getComputedStyle(el);
+          if (cs.display !== 'none' && cs.visibility !== 'hidden' && el.offsetParent !== null) {
+            visible.push(el);
+          }
+        }
+
+        if (visible.length === 0) {
+          return { category: 'violation', reason: 'no-focusable-children' };
+        }
+
+        // Check 4: Focus last child and see if container scrolls
+        const origScrollTop = container.scrollTop;
+        const origScrollLeft = container.scrollLeft;
+        const lastChild = visible[visible.length - 1];
+        lastChild.focus();
+        const scrolled =
+          container.scrollTop !== origScrollTop ||
+          container.scrollLeft !== origScrollLeft;
+
+        // Restore state
+        container.scrollTop = origScrollTop;
+        container.scrollLeft = origScrollLeft;
+        lastChild.blur();
+
+        if (scrolled) {
+          return { category: 'pass', reason: 'scroll-reached' };
+        }
+
+        // Last child was already visible without scrolling — check
+        // if there's content beyond what's reachable by focusable children
+        const lastRect = lastChild.getBoundingClientRect();
+        const containerRect = container.getBoundingClientRect();
+        const contentBottom = container.scrollHeight;
+        const lastChildBottom = lastRect.bottom - containerRect.top + container.scrollTop;
+
+        if (lastChildBottom >= contentBottom - 5) {
+          // Focusable children reach the bottom of content
+          return { category: 'pass', reason: 'children-cover-content' };
+        }
+
+        // There's content below the last focusable child that is unreachable
+        return { category: 'violation', reason: 'unreachable-content' };
+      })()`,
+            returnByValue: true,
+        });
+        const data = result.result.value;
+        if (!data) {
+            incompleteNodes.push(node);
+            continue;
+        }
+        switch (data.category) {
+            case 'pass':
+                passNodes.push(node);
+                break;
+            case 'violation':
+                violationNodes.push(node);
+                break;
+            default:
+                incompleteNodes.push(node);
+        }
+    }
+    applyPromotions(clone, index, rule, {
+        passNodes,
+        violationNodes,
+        incompleteNodes,
+    });
+    return clone;
+}

package/dist/lib/resolvers/skip-link.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @module skip-link
+ *
+ * Resolver for axe-core's `skip-link` incomplete rule
+ * (WCAG 2.4.1 Bypass Blocks). Verifies that skip links become
+ * visible when they receive keyboard focus.
+ */
+import type { CDPSessionLike } from '@a11y-oracle/cdp-types';
+import type { AxeResults, SkipLinkOptions } from '../types.js';
+/**
+ * Resolve incomplete `skip-link` results.
+ *
+ * Skip links are typically visually hidden until focused. This resolver:
+ * 1. Resets focus to the document body
+ * 2. Dispatches a native Tab keystroke to focus the skip link
+ * 3. Checks if the element becomes visible (bounding box, opacity, clip, position)
+ *
+ * Visible on focus → **Pass**. Hidden on focus → **Violation**.
+ *
+ * @param cdp - CDP session for keyboard dispatch and style queries.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional delay configuration.
+ * @returns Modified results with resolved findings.
+ */
+export declare function resolveSkipLink(cdp: CDPSessionLike, axeResults: AxeResults, options?: SkipLinkOptions): Promise<AxeResults>;
+//# sourceMappingURL=skip-link.d.ts.map

package/dist/lib/resolvers/skip-link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skip-link.d.ts","sourceRoot":"","sources":["../../../src/lib/resolvers/skip-link.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAW,eAAe,EAAE,MAAM,aAAa,CAAC;AAaxE;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,cAAc,EACnB,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,UAAU,CAAC,CAuFrB"}

package/dist/lib/resolvers/skip-link.js

@@ -0,0 +1,140 @@
+/**
+ * @module skip-link
+ *
+ * Resolver for axe-core's `skip-link` incomplete rule
+ * (WCAG 2.4.1 Bypass Blocks). Verifies that skip links become
+ * visible when they receive keyboard focus.
+ */
+import { getSelector, cloneResults, findIncompleteRule, applyPromotions, } from '../resolver-pipeline.js';
+const RULE_ID = 'skip-link';
+/** Default delay after focus for CSS transitions to settle. */
+const DEFAULT_FOCUS_SETTLE_DELAY = 100;
+/**
+ * Resolve incomplete `skip-link` results.
+ *
+ * Skip links are typically visually hidden until focused. This resolver:
+ * 1. Resets focus to the document body
+ * 2. Dispatches a native Tab keystroke to focus the skip link
+ * 3. Checks if the element becomes visible (bounding box, opacity, clip, position)
+ *
+ * Visible on focus → **Pass**. Hidden on focus → **Violation**.
+ *
+ * @param cdp - CDP session for keyboard dispatch and style queries.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional delay configuration.
+ * @returns Modified results with resolved findings.
+ */
+export async function resolveSkipLink(cdp, axeResults, options) {
+    const clone = cloneResults(axeResults);
+    const found = findIncompleteRule(clone, RULE_ID);
+    if (!found)
+        return clone;
+    const { index, rule } = found;
+    const settleDelay = options?.focusSettleDelay ?? DEFAULT_FOCUS_SETTLE_DELAY;
+    const passNodes = [];
+    const violationNodes = [];
+    const incompleteNodes = [];
+    for (const node of rule.nodes) {
+        const selector = getSelector(node);
+        if (!selector) {
+            incompleteNodes.push(node);
+            continue;
+        }
+        // Reset focus to body
+        await cdp.send('Runtime.evaluate', {
+            expression: 'document.activeElement?.blur(); void 0;',
+            returnByValue: true,
+        });
+        // Focus the skip link via element.focus() for reliability
+        await cdp.send('Runtime.evaluate', {
+            expression: `(() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (el) el.focus();
+      })()`,
+            returnByValue: true,
+        });
+        // Wait for CSS transitions to settle
+        await delay(settleDelay);
+        // Check visibility
+        const result = await cdp.send('Runtime.evaluate', {
+            expression: `(() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return null;
+        const isFocused = document.activeElement === el;
+        const rect = el.getBoundingClientRect();
+        const cs = window.getComputedStyle(el);
+        return {
+          isFocused,
+          width: rect.width,
+          height: rect.height,
+          top: rect.top,
+          left: rect.left,
+          right: rect.right,
+          bottom: rect.bottom,
+          opacity: cs.opacity,
+          visibility: cs.visibility,
+          display: cs.display,
+          clip: cs.clip,
+          clipPath: cs.clipPath,
+          position: cs.position,
+          overflow: cs.overflow,
+          viewportWidth: window.innerWidth,
+          viewportHeight: window.innerHeight,
+        };
+      })()`,
+            returnByValue: true,
+        });
+        const data = result.result.value;
+        if (!data) {
+            incompleteNodes.push(node);
+            continue;
+        }
+        if (isVisible(data)) {
+            passNodes.push(node);
+        }
+        else {
+            violationNodes.push(node);
+        }
+    }
+    applyPromotions(clone, index, rule, {
+        passNodes,
+        violationNodes,
+        incompleteNodes,
+    });
+    return clone;
+}
+/**
+ * Determine if a skip link is visible on screen after receiving focus.
+ */
+function isVisible(data) {
+    // Must have non-zero dimensions
+    if (data.width <= 0 || data.height <= 0)
+        return false;
+    // Must not be display: none or visibility: hidden
+    if (data.display === 'none')
+        return false;
+    if (data.visibility === 'hidden')
+        return false;
+    // Must not be fully transparent
+    if (data.opacity === '0')
+        return false;
+    // Must not be clipped to zero size
+    const clipZero = /rect\(\s*0(px)?\s*,?\s*0(px)?\s*,?\s*0(px)?\s*,?\s*0(px)?\s*\)/;
+    if (clipZero.test(data.clip))
+        return false;
+    if (data.clipPath === 'inset(100%)')
+        return false;
+    // Must be within viewport (not positioned off-screen)
+    if (data.right <= 0)
+        return false;
+    if (data.bottom <= 0)
+        return false;
+    if (data.left >= data.viewportWidth)
+        return false;
+    if (data.top >= data.viewportHeight)
+        return false;
+    return true;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/lib/resolvers/target-size.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @module target-size
+ *
+ * Resolver for axe-core's `target-size` incomplete rule
+ * (WCAG 2.5.8 Target Size Minimum). Verifies that interactive
+ * elements have at least 24×24 CSS pixels or sufficient spacing.
+ */
+import type { CDPSessionLike } from '@a11y-oracle/cdp-types';
+import type { AxeResults, TargetSizeOptions } from '../types.js';
+/**
+ * Resolve incomplete `target-size` results.
+ *
+ * Checks each flagged element's rendered bounding box:
+ * 1. If width ≥ 24 AND height ≥ 24 → **Pass**
+ * 2. If undersized, calculates center-to-center distance to
+ *    nearest interactive neighbor. If distance ≥ 24px → **Pass**
+ * 3. Otherwise → **Violation**
+ *
+ * @param cdp - CDP session for querying bounding boxes.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional size threshold override.
+ * @returns Modified results with resolved findings.
+ */
+export declare function resolveTargetSize(cdp: CDPSessionLike, axeResults: AxeResults, options?: TargetSizeOptions): Promise<AxeResults>;
+//# sourceMappingURL=target-size.d.ts.map

package/dist/lib/resolvers/target-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target-size.d.ts","sourceRoot":"","sources":["../../../src/lib/resolvers/target-size.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAW,iBAAiB,EAAE,MAAM,aAAa,CAAC;AA8B1E;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,cAAc,EACnB,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,UAAU,CAAC,CAuFrB"}

package/dist/lib/resolvers/target-size.js

@@ -0,0 +1,125 @@
+/**
+ * @module target-size
+ *
+ * Resolver for axe-core's `target-size` incomplete rule
+ * (WCAG 2.5.8 Target Size Minimum). Verifies that interactive
+ * elements have at least 24×24 CSS pixels or sufficient spacing.
+ */
+import { getSelector, cloneResults, findIncompleteRule, applyPromotions, } from '../resolver-pipeline.js';
+const RULE_ID = 'target-size';
+/** Default minimum target dimension in CSS pixels. */
+const DEFAULT_MIN_SIZE = 24;
+/** CSS selector for interactive elements. */
+const INTERACTIVE_SELECTOR = [
+    'a[href]',
+    'button:not([disabled])',
+    'input:not([disabled]):not([type="hidden"])',
+    'select:not([disabled])',
+    'textarea:not([disabled])',
+    '[role="button"]',
+    '[role="link"]',
+    '[role="checkbox"]',
+    '[role="radio"]',
+    '[role="tab"]',
+    '[role="menuitem"]',
+    '[role="option"]',
+    '[tabindex]:not([tabindex="-1"])',
+].join(', ');
+/**
+ * Resolve incomplete `target-size` results.
+ *
+ * Checks each flagged element's rendered bounding box:
+ * 1. If width ≥ 24 AND height ≥ 24 → **Pass**
+ * 2. If undersized, calculates center-to-center distance to
+ *    nearest interactive neighbor. If distance ≥ 24px → **Pass**
+ * 3. Otherwise → **Violation**
+ *
+ * @param cdp - CDP session for querying bounding boxes.
+ * @param axeResults - Raw axe-core results.
+ * @param options - Optional size threshold override.
+ * @returns Modified results with resolved findings.
+ */
+export async function resolveTargetSize(cdp, axeResults, options) {
+    const clone = cloneResults(axeResults);
+    const found = findIncompleteRule(clone, RULE_ID);
+    if (!found)
+        return clone;
+    const { index, rule } = found;
+    const minSize = options?.minSize ?? DEFAULT_MIN_SIZE;
+    const passNodes = [];
+    const violationNodes = [];
+    const incompleteNodes = [];
+    for (const node of rule.nodes) {
+        const selector = getSelector(node);
+        if (!selector) {
+            incompleteNodes.push(node);
+            continue;
+        }
+        // Get bounding box of target element and all interactive neighbors
+        const result = await cdp.send('Runtime.evaluate', {
+            expression: `(() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return null;
+        const rect = el.getBoundingClientRect();
+        const target = {
+          x: rect.x + rect.width / 2,
+          y: rect.y + rect.height / 2,
+          width: rect.width,
+          height: rect.height,
+        };
+        // If already large enough, no need to check neighbors
+        if (rect.width >= ${minSize} && rect.height >= ${minSize}) {
+          return { target, meetsMinSize: true, minDistance: null };
+        }
+        // Find nearest interactive neighbor
+        const all = document.querySelectorAll(${JSON.stringify(INTERACTIVE_SELECTOR)});
+        let minDist = Infinity;
+        for (const other of all) {
+          if (other === el) continue;
+          const oRect = other.getBoundingClientRect();
+          if (oRect.width === 0 || oRect.height === 0) continue;
+          const cx = oRect.x + oRect.width / 2;
+          const cy = oRect.y + oRect.height / 2;
+          const dist = Math.sqrt(
+            Math.pow(target.x - cx, 2) + Math.pow(target.y - cy, 2)
+          );
+          minDist = Math.min(minDist, dist);
+        }
+        return {
+          target,
+          meetsMinSize: false,
+          minDistance: minDist === Infinity ? null : minDist,
+        };
+      })()`,
+            returnByValue: true,
+        });
+        const data = result.result.value;
+        if (!data) {
+            incompleteNodes.push(node);
+            continue;
+        }
+        if (data.meetsMinSize) {
+            passNodes.push(node);
+        }
+        else if (data.minDistance !== null && data.minDistance >= minSize) {
+            // Undersized but has sufficient spacing
+            passNodes.push(node);
+        }
+        else if (data.minDistance === null) {
+            // Undersized but no neighbors found (only interactive element)
+            // This is technically a pass for the spacing exemption,
+            // but the element itself is still undersized → Violation
+            violationNodes.push(node);
+        }
+        else {
+            // Undersized and too close to a neighbor
+            violationNodes.push(node);
+        }
+    }
+    applyPromotions(clone, index, rule, {
+        passNodes,
+        violationNodes,
+        incompleteNodes,
+    });
+    return clone;
+}