await page.add_init_script("""
                // === Собираем перехваченные данные (пассивно, только копирование) ===
                window._interceptedData = {
                    logs: [],
                    submitRealCalls: [],
                    fetchCalls: [],
                };

                // === Отключаем ANTI_FRAUD_ENABLED ===
                const _origDefineProperty = Object.defineProperty;
                Object.defineProperty = function(obj, prop, descriptor) {
                    if (prop === 'ANTI_FRAUD_ENABLED') {
                        descriptor.value = false;
                    }
                    return _origDefineProperty.call(this, obj, prop, descriptor);
                };
                if (typeof window.ANTI_FRAUD_ENABLED !== 'undefined') {
                    window.ANTI_FRAUD_ENABLED = false;
                }

                // === Перехват loggerService.log — только копирование ===
                const _patchLoggerService = (logger) => {
                    if (logger && typeof logger.log === 'function' && !logger._intercepted) {
                        const _origLog = logger.log;
                        logger.log = function(...args) {
                            window._interceptedData.logs.push({ args: [...args], ts: Date.now() });
                            return _origLog.apply(this, args);
                        };
                        logger._intercepted = true;
                    }
                };

                let _currentLoggerService = window.loggerService;
                Object.defineProperty(window, 'loggerService', {
                    set: function(val) {
                        _currentLoggerService = val;
                        _patchLoggerService(val);
                    },
                    get: function() {
                        return _currentLoggerService;
                    },
                    configurable: true
                });
                if (window.loggerService) _patchLoggerService(window.loggerService);

                // === Перехват fetch — только копирование ===
                const _origFetch = window.fetch;
                window.fetch = async function(...fetchArgs) {
                    const url = fetchArgs[0];
                    const options = fetchArgs[1] || {};
                    const urlStr = typeof url === 'string' ? url : (url && url.url) || '';

                    const callData = {
                        url: urlStr,
                        method: options.method || 'GET',
                        ts: Date.now(),
                    };

                    if (options.body) {
                        try {
                            callData.body = typeof options.body === 'string'
                                ? JSON.parse(options.body)
                                : options.body;
                        } catch(e) {
                            callData.bodyRaw = String(options.body);
                        }
                    }

                    if (urlStr.includes('webhook') || urlStr.includes('real') || urlStr.includes('n8n.uplify')) {
                        window._interceptedData.fetchCalls.push(callData);
                    }

                    const response = await _origFetch.apply(this, fetchArgs);

                    if (urlStr.includes('webhook') || urlStr.includes('real') || urlStr.includes('n8n.uplify')) {
                        try {
                            const cloned = response.clone();
                            const body = await cloned.text();
                            callData.response = body.substring(0, 2000);
                            callData.status = response.status;
                        } catch(e) {}
                    }

                    return response;
                };

                // === Перехват submitReal — только копирование ===
                const _checkSubmitReal = setInterval(() => {
                    const searchIn = [window];
                    for (const key of Object.getOwnPropertyNames(window)) {
                        try {
                            const val = window[key];
                            if (val && typeof val === 'object') searchIn.push(val);
                        } catch(e) {}
                    }

                    for (const obj of searchIn) {
                        if (obj && typeof obj.submitReal === 'function' && !obj._intercepted) {
                            const _origSubmitReal = obj.submitReal;
                            obj.submitReal = async function(...args) {
                                window._interceptedData.submitRealCalls.push({
                                    ts: Date.now(),
                                    visitId: obj.appModel?.visitId,
                                    visitorId: obj.fingerprintModel?.visitorId,
                                    platform: obj.configModel?.platform,
                                    realUrl: obj.configModel?.realUrl,
                                    snapshot: obj.securityModel?.snapshot,
                                    gaInit: obj.validationModel?.gaInit,
                                    ymInit: obj.validationModel?.ymInit,
                                    adblockEnabled: obj.validationModel?.adblockEnabled,
                                    pageSource: obj.configModel?.pageSource,
                                    redirectAllowed: obj.securityModel?.redirectAllowed,
                                    fpBotType: obj.securityModel?.fpBotType,
                                    country: obj.userModel?.geo?.country_code,
                                });
                                return _origSubmitReal.apply(this, args);
                            };
                            obj._intercepted = true;
                        }
                    }
                }, 300);

                setTimeout(() => clearInterval(_checkSubmitReal), 30000);
            """)