feat: port Shadow DOM piercing from TS to Python CDP injector

Add _fill_card_in_shadow_dom() as fallback when iframe traversal
finds no card fields. Recursively walks shadowRoot trees via
page.evaluate(), fills fields using native setter + event dispatch.

Author: TPEmist

pop_pay/injector.py

@@ -630,8 +630,83 @@ async def _fill_across_frames(
                 logger.debug("Frame %s skipped: %s", frame.url, frame_exc)
                 continue
 
+        # Shadow DOM piercing fallback: search for shadow roots in main page
+        if not card_filled:
+            if await self._fill_card_in_shadow_dom(page, card_number, expiry, cvv):
+                card_filled = True
+
         return card_filled
 
+    async def _fill_card_in_shadow_dom(
+        self, page, card_number: str, expiry: str, cvv: str
+    ) -> bool:
+        """
+        Search for card fields inside Shadow DOM trees using recursive
+        queryShadowAll and fill them via native setters + event dispatch.
+        """
+        try:
+            card_selectors = ", ".join(CARD_NUMBER_SELECTORS)
+            expiry_selectors = ", ".join(EXPIRY_SELECTORS)
+            cvv_selectors = ", ".join(CVV_SELECTORS)
+
+            script = """
+            ([cardNumber, expiry, cvv, cardSels, expSels, cvvSels]) => {
+                function queryShadowFirst(root, selectors) {
+                    const selectorList = selectors.split(', ');
+                    for (const sel of selectorList) {
+                        try {
+                            const found = root.querySelector(sel);
+                            if (found) return found;
+                        } catch (e) {}
+                    }
+                    const allElements = root.querySelectorAll('*');
+                    for (const el of allElements) {
+                        if (el.shadowRoot) {
+                            const found = queryShadowFirst(el.shadowRoot, selectors);
+                            if (found) return found;
+                        }
+                    }
+                    return null;
+                }
+
+                function fillField(root, selectors, value) {
+                    const el = queryShadowFirst(root, selectors);
+                    if (!el) return false;
+                    try {
+                        const nativeSetter = Object.getOwnPropertyDescriptor(
+                            HTMLInputElement.prototype, 'value'
+                        ).set;
+                        if (nativeSetter) {
+                            nativeSetter.call(el, value);
+                        } else {
+                            el.value = value;
+                        }
+                        el.dispatchEvent(new Event('input', { bubbles: true }));
+                        el.dispatchEvent(new Event('change', { bubbles: true }));
+                        el.dispatchEvent(new Event('blur', { bubbles: true }));
+                        return true;
+                    } catch (e) {
+                        return false;
+                    }
+                }
+
+                const cardFilled = fillField(document, cardSels, cardNumber);
+                if (cardFilled) {
+                    fillField(document, expSels, expiry);
+                    fillField(document, cvvSels, cvv);
+                }
+                return cardFilled;
+            }
+            """
+            result = await page.evaluate(script, [
+                card_number, expiry, cvv,
+                card_selectors, expiry_selectors, cvv_selectors
+            ])
+            return bool(result)
+        except Exception as e:
+            logger.debug("PopBrowserInjector: Shadow DOM piercing failed: %s", e)
+            return False
+
     async def _fill_in_frame(
         self, frame, card_number: str, expiry: str, cvv: str
     ) -> bool:

tests/test_cdp_regression.py

@@ -436,6 +436,63 @@ async def mock_fill_in_frame(frame, cn, exp, cvv):
         assert call_count["iframe"] == 1
 
 
+class TestShadowDomPiercing:
+    """Test Shadow DOM piercing fallback when frame traversal fails."""
+
+    @pytest.mark.asyncio
+    async def test_shadow_dom_fallback_called_when_frames_fail(self):
+        """Verify _fill_card_in_shadow_dom is called if _fill_in_frame returns False."""
+        injector = _make_injector()
+        page = MagicMock()
+        frame = MagicMock()
+        frame.url = "https://example.com"
+        page.frames = [frame]
+
+        with patch.object(injector, "_fill_in_frame", return_value=False):
+            with patch.object(
+                injector, "_fill_card_in_shadow_dom", AsyncMock(return_value=True)
+            ) as mock_shadow:
+                result = await injector._fill_across_frames(
+                    page, "4242424242424242", "12/28", "123"
+                )
+
+                assert result is True
+                mock_shadow.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_shadow_dom_not_called_when_frames_succeed(self):
+        """Verify Shadow DOM piercing is NOT called if a frame already filled the card."""
+        injector = _make_injector()
+        page = MagicMock()
+        frame = MagicMock()
+        frame.url = "https://example.com"
+        page.frames = [frame]
+
+        with patch.object(injector, "_fill_in_frame", return_value=True):
+            with patch.object(
+                injector, "_fill_card_in_shadow_dom", AsyncMock()
+            ) as mock_shadow:
+                result = await injector._fill_across_frames(
+                    page, "4242424242424242", "12/28", "123"
+                )
+
+                assert result is True
+                mock_shadow.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_shadow_dom_returns_false_when_no_fields(self):
+        """Verify _fill_card_in_shadow_dom returns False if page.evaluate returns False."""
+        injector = _make_injector()
+        page = MagicMock()
+        # Mock page.evaluate to simulate no fields found in shadow DOM
+        page.evaluate = AsyncMock(return_value=False)
+
+        result = await injector._fill_card_in_shadow_dom(
+            page, "4242424242424242", "12/28", "123"
+        )
+        assert result is False
+
+
 # ---------------------------------------------------------------------------
 # Compatibility matrix documentation
 # ---------------------------------------------------------------------------