extension 3.12.0 → 3.12.1

package/dist/859.cjs

@@ -0,0 +1,1932 @@
+"use strict";
+exports.ids = [
+    "859"
+];
+exports.modules = {
+    "../browser/run-chromium/chromium-launch/setup-cdp-after-launch.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            setupCdpAfterLaunch: ()=>setupCdpAfterLaunch
+        });
+        var messages = __webpack_require__("../browser/browsers-lib/messages.ts");
+        var shared_utils = __webpack_require__("../browser/browsers-lib/shared-utils.ts");
+        var banner = __webpack_require__("../browser/browsers-lib/banner.ts");
+        var external_path_ = __webpack_require__("path");
+        var external_fs_ = __webpack_require__("fs");
+        var content_script_targets = __webpack_require__("../browser/browsers-lib/content-script-targets.ts");
+        var content_script_contracts = __webpack_require__("../browser/browsers-lib/content-script-contracts.ts");
+        async function deriveExtensionIdFromTargetsHelper(cdp, outPath, maxRetries = 6, backoffMs = 150, profilePath, extensionPaths) {
+            let expectedName;
+            let expectedVersion;
+            let expectedManifestVersion;
+            let expectedNameIsMsg = false;
+            try {
+                const manifest = JSON.parse(external_fs_.readFileSync(external_path_.join(outPath, 'manifest.json'), 'utf-8'));
+                expectedName = manifest?.name;
+                expectedVersion = manifest?.version;
+                expectedManifestVersion = manifest?.manifest_version;
+                expectedNameIsMsg = 'string' == typeof expectedName && /__MSG_/i.test(expectedName);
+                if (expectedNameIsMsg) {
+                    const defaultLocale = String(manifest?.default_locale || '').trim();
+                    const msgKeyMatch = String(expectedName || '').match(/__MSG_(.+)__/i);
+                    const msgKey = msgKeyMatch ? msgKeyMatch[1] : '';
+                    if (defaultLocale && msgKey) {
+                        const messagesPath = external_path_.join(outPath, '_locales', defaultLocale, 'messages.json');
+                        if (external_fs_.existsSync(messagesPath)) {
+                            const messagesJson = JSON.parse(external_fs_.readFileSync(messagesPath, 'utf-8'));
+                            const resolved = String(messagesJson?.[msgKey]?.message || '').trim();
+                            if (resolved) {
+                                expectedName = resolved;
+                                expectedNameIsMsg = false;
+                            }
+                        }
+                    }
+                }
+            } catch  {}
+            const trimTrailingSep = (p)=>{
+                let end = p.length;
+                while(end > 0 && ('/' === p[end - 1] || '\\' === p[end - 1]))end--;
+                return p.slice(0, end);
+            };
+            const normalizePath = (p)=>{
+                try {
+                    const resolved = external_path_.resolve(p);
+                    if (external_fs_.existsSync(resolved)) return trimTrailingSep(external_fs_.realpathSync(resolved));
+                    return trimTrailingSep(resolved);
+                } catch  {
+                    return trimTrailingSep(external_path_.resolve(p));
+                }
+            };
+            const resolvedOutPath = normalizePath(outPath);
+            const normalizedCandidates = Array.isArray(extensionPaths) ? extensionPaths.map((p)=>p ? normalizePath(p) : '').filter(Boolean) : [];
+            const resolvedCandidates = normalizedCandidates.length ? normalizedCandidates : [
+                resolvedOutPath
+            ];
+            const platformIsCaseInsensitive = 'win32' === process.platform || 'darwin' === process.platform;
+            const normalizeForCompare = (p)=>platformIsCaseInsensitive ? p.toLowerCase() : p;
+            const matchesAnyCandidate = (p)=>{
+                const n = normalizeForCompare(p);
+                return resolvedCandidates.some((candidate)=>n === normalizeForCompare(candidate));
+            };
+            const deriveFromProfile = ()=>{
+                if (!profilePath) return null;
+                const candidates = [];
+                const pushPrefIfExists = (dir)=>{
+                    const prefPath = external_path_.join(dir, 'Preferences');
+                    if (external_fs_.existsSync(prefPath)) candidates.push(prefPath);
+                };
+                try {
+                    pushPrefIfExists(profilePath);
+                    pushPrefIfExists(external_path_.join(profilePath, 'Default'));
+                    const entries = external_fs_.readdirSync(profilePath);
+                    for (const entry of entries)if (/^Profile\s+\d+$/i.test(entry)) pushPrefIfExists(external_path_.join(profilePath, entry));
+                } catch  {}
+                for (const prefPath of candidates)try {
+                    if (!external_fs_.existsSync(prefPath)) continue;
+                    const prefs = JSON.parse(external_fs_.readFileSync(prefPath, 'utf-8'));
+                    const settings = prefs?.extensions?.settings;
+                    if (!settings || 'object' != typeof settings) continue;
+                    const entries = Object.entries(settings);
+                    let fallbackId = null;
+                    for (const [id, info] of entries){
+                        const storedPath = String(info?.path || '');
+                        if (!storedPath) continue;
+                        const normalized = normalizePath(storedPath);
+                        if (!matchesAnyCandidate(normalized)) continue;
+                        const manifestName = String(info?.manifest?.name || '');
+                        const manifestVersion = String(info?.manifest?.version || '');
+                        if (expectedName && manifestName === expectedName) return id;
+                        if (expectedVersion && manifestVersion === expectedVersion) return id;
+                        fallbackId = id;
+                    }
+                    if (fallbackId) return fallbackId;
+                } catch  {}
+                return null;
+            };
+            let retries = 0;
+            let deferredFirstEvalId = null;
+            let deferredUrlDerivedId = null;
+            const hasExpectedManifestIdentity = Boolean(expectedName || expectedVersion || expectedManifestVersion);
+            while(retries <= maxRetries){
+                try {
+                    const targets = await cdp.getTargets();
+                    const profileCandidateId = deriveFromProfile();
+                    let firstEvalId = null;
+                    let evalIdCount = 0;
+                    let urlDerivedId = null;
+                    for (const t of targets || []){
+                        const url = String(t?.url || '');
+                        const type = String(t?.type || '');
+                        const typeOk = [
+                            'service_worker',
+                            'background_page',
+                            'worker'
+                        ].includes(type);
+                        if (!typeOk) continue;
+                        const urlMatch = url.match(/^chrome-extension:\/\/([^\/]+)/);
+                        if (!urlDerivedId && urlMatch?.[1]) urlDerivedId = String(urlMatch[1]);
+                        if (url && !url.startsWith('chrome-extension://')) continue;
+                        const targetId = t?.targetId;
+                        if (targetId) try {
+                            const sessionId = await cdp.attachToTarget(targetId);
+                            if (!sessionId) continue;
+                            await cdp.sendCommand('Runtime.enable', {}, sessionId);
+                            const info = await cdp.evaluate(sessionId, '(()=>{try{const m=chrome.runtime.getManifest?.();return {id:chrome.runtime?.id||"",name:m?.name||"",version:m?.version||"",manifestVersion:m?.manifest_version||0}}catch(_){return null}})()');
+                            const id = String(info?.id || '').trim();
+                            if (!id) continue;
+                            evalIdCount += 1;
+                            if (!firstEvalId) firstEvalId = id;
+                            if (profileCandidateId && id === profileCandidateId) return id;
+                            const gotName = String(info?.name || '');
+                            const gotVersion = String(info?.version || '');
+                            const gotManifestVersion = Number(info?.manifestVersion || 0);
+                            const nameMatches = expectedName && !expectedNameIsMsg ? gotName === expectedName : false;
+                            const versionMatches = expectedVersion ? gotVersion === expectedVersion : false;
+                            const manifestVersionMatches = expectedManifestVersion ? gotManifestVersion === expectedManifestVersion : false;
+                            if (nameMatches && (!profileCandidateId || id === profileCandidateId)) return id;
+                            if (expectedVersion && versionMatches && (expectedManifestVersion ? manifestVersionMatches : true) && (!profileCandidateId || id === profileCandidateId)) return id;
+                        } catch  {}
+                    }
+                    if (1 === evalIdCount && firstEvalId) {
+                        if (!hasExpectedManifestIdentity) return firstEvalId;
+                        deferredFirstEvalId = deferredFirstEvalId || firstEvalId;
+                    }
+                    if (profileCandidateId) return profileCandidateId;
+                    if (urlDerivedId) {
+                        if (!hasExpectedManifestIdentity) return urlDerivedId;
+                        deferredUrlDerivedId = deferredUrlDerivedId || urlDerivedId;
+                    }
+                } catch  {}
+                await new Promise((r)=>setTimeout(r, backoffMs));
+                retries++;
+            }
+            return deriveFromProfile() || deferredFirstEvalId || deferredUrlDerivedId;
+        }
+        var wrapper = __webpack_require__("../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs");
+        var external_http_ = __webpack_require__("http");
+        var external_net_ = __webpack_require__("net");
+        const CDP_HTTP_REQUEST_TIMEOUT_MS = 1200;
+        async function getJson(host, port, path) {
+            return new Promise((resolve, reject)=>{
+                const req = external_http_.request({
+                    hostname: host,
+                    port,
+                    path,
+                    method: 'GET'
+                }, (res)=>{
+                    let data = '';
+                    res.on('data', (chunk)=>data += chunk);
+                    res.on('end', ()=>{
+                        try {
+                            resolve(JSON.parse(data));
+                        } catch (e) {
+                            reject(new Error(`Failed to parse ${path}: ${e}`));
+                        }
+                    });
+                });
+                req.on('error', (err)=>reject(err));
+                req.setTimeout(CDP_HTTP_REQUEST_TIMEOUT_MS, ()=>{
+                    req.destroy(new Error(`CDP endpoint timed out: ${path}`));
+                });
+                req.end();
+            });
+        }
+        async function discoverWebSocketDebuggerUrl(host, port, isDev) {
+            try {
+                const version = await getJson(host, port, '/json/version');
+                const wsUrl = 'string' == typeof version?.webSocketDebuggerUrl ? version.webSocketDebuggerUrl : void 0;
+                if (wsUrl) {
+                    if (isDev) console.log(messages.Ter());
+                    return wsUrl;
+                }
+            } catch (error) {
+                if (isDev) console.warn('[CDP] Failed to read /json/version:', String(error?.message || error));
+            }
+            const targets = await getJson(host, port, '/json');
+            if (isDev) console.log(messages.FFz((targets || []).length || 0));
+            const pageTarget = (targets || []).find((target)=>{
+                const type = String(target?.type || '');
+                const ws = 'string' == typeof target?.webSocketDebuggerUrl ? target.webSocketDebuggerUrl : '';
+                return 'page' === type && ws;
+            });
+            const pageWs = 'string' == typeof pageTarget?.webSocketDebuggerUrl ? pageTarget.webSocketDebuggerUrl : '';
+            if (pageWs) {
+                if (isDev) console.log(messages.Ter());
+                return pageWs;
+            }
+            throw new Error('No CDP WebSocket URL available');
+        }
+        async function checkChromeRemoteDebugging(port = 9222) {
+            return new Promise((resolve)=>{
+                const socket = new external_net_.Socket();
+                socket.on('connect', ()=>{
+                    socket.destroy();
+                    resolve(true);
+                });
+                socket.on('error', ()=>{
+                    resolve(false);
+                });
+                socket.on('timeout', ()=>{
+                    socket.destroy();
+                    resolve(false);
+                });
+                socket.setTimeout(2000);
+                socket.connect(port, 'localhost');
+            });
+        }
+        async function getExtensionInfo(cdp, extensionId) {
+            return await cdp.sendCommand('Extensions.getExtensionInfo', {
+                extensionId
+            });
+        }
+        async function loadUnpackedExtension(cdp, absPath) {
+            const response = await cdp.sendCommand('Extensions.loadUnpacked', {
+                extensionPath: absPath,
+                options: {
+                    failOnError: false
+                }
+            });
+            return String(response?.extensionId || '');
+        }
+        async function unloadExtension(cdp, extensionId) {
+            try {
+                await cdp.sendCommand('Extensions.unload', {
+                    extensionId
+                });
+                return true;
+            } catch  {
+                return false;
+            }
+        }
+        function mergeShadowIntoDocument(mainHTML, shadowContent) {
+            try {
+                if (!mainHTML) return '';
+                const hasRoot = /<div id=(["'])extension-root\1/i.test(mainHTML);
+                if (hasRoot) {
+                    const emptyRoot = /<div id=(["'])extension-root\1[^>]*><\/div>/i;
+                    const replacedEmpty = mainHTML.replace(emptyRoot, `<div id="extension-root">${shadowContent}</div>`);
+                    if (replacedEmpty !== mainHTML) return replacedEmpty;
+                    return mainHTML.replace(/<div id=(["'])extension-root\1[^>]*>[\s\S]*?<\/div>/i, `<div id="extension-root">${shadowContent}</div>`);
+                }
+                const hostOpen = /(<[^>]*data-extension-root=(["'])true\2[^>]*>)/i;
+                if (hostOpen.test(mainHTML)) return mainHTML.replace(hostOpen, `$1<div id="extension-root">${shadowContent}</div>`);
+                return mainHTML;
+            } catch  {
+                return mainHTML;
+            }
+        }
+        const CONTENT_ROOT_SELECTOR = '#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])';
+        const NON_DEVTOOLS_CONTENT_ROOT_SELECTOR = '#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])';
+        const EXTENSION_ROOT_META_EXPRESSION = `(() => {
+          const readGeneration = (node) => {
+            try {
+              const raw = node && node.getAttribute
+                ? node.getAttribute('data-extjs-reinject-generation')
+                : '';
+              const parsed = Number(raw);
+              return Number.isFinite(parsed) ? parsed : undefined;
+            } catch (error) {
+              return undefined;
+            }
+          };
+          const normalize = (node) => ({
+            tag: node && node.tagName ? String(node.tagName).toLowerCase() : 'unknown',
+            id: node && node.id ? String(node.id) : undefined,
+            key: node && node.getAttribute ? node.getAttribute('data-extjs-reinject-key') || undefined : undefined,
+            generation: readGeneration(node),
+            status: node && node.getAttribute ? node.getAttribute('data-extjs-reinject-status') || undefined : undefined,
+            build: node && node.getAttribute ? node.getAttribute('data-extjs-reinject-build') || undefined : undefined,
+            hasShadowRoot: !!(node && node.shadowRoot),
+            hasShadowContent: !!(node && node.shadowRoot && String(node.shadowRoot.innerHTML || '').trim())
+          });
+          const registry = (typeof globalThis === 'object' && globalThis)
+            ? (globalThis.__EXTENSIONJS_DEV_REINJECT__ || {})
+            : {};
+          const registries = Object.entries(registry)
+            .slice(0, 10)
+            .map(([key, entry]) => {
+              const candidate = entry && typeof entry === 'object' ? entry : {};
+              const cleanup = candidate && typeof candidate.cleanup === 'function'
+                ? candidate.cleanup
+                : (typeof entry === 'function' ? entry : undefined);
+              return {
+                key,
+                generation: typeof candidate.generation === 'number'
+                  ? candidate.generation
+                  : (cleanup && typeof cleanup.__extjsGeneration === 'number'
+                    ? cleanup.__extjsGeneration
+                    : undefined),
+                hasCleanup: typeof cleanup === 'function',
+                build: typeof candidate.build === 'string'
+                  ? candidate.build
+                  : (cleanup && typeof cleanup.__extjsBuild === 'string'
+                    ? cleanup.__extjsBuild
+                    : undefined)
+              };
+            });
+          const pageCandidate = {
+            key: document.documentElement.getAttribute('data-extjs-last-reinject-key') || undefined,
+            generation: (() => {
+              const parsed = Number(document.documentElement.getAttribute('data-extjs-last-reinject-generation') || '');
+              return Number.isFinite(parsed) ? parsed : undefined;
+            })(),
+            status: document.documentElement.getAttribute('data-extjs-last-reinject-status') || undefined,
+            build: document.documentElement.getAttribute('data-extjs-last-reinject-build') || undefined
+          };
+          const roots = Array.from(
+            document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])')
+          )
+            .slice(0, 10)
+            .map(normalize)
+            .filter((entry) =>
+              entry.hasShadowRoot ||
+              entry.hasShadowContent ||
+              typeof entry.key === 'string' ||
+              typeof entry.generation === 'number' ||
+              typeof entry.status === 'string' ||
+              typeof entry.build === 'string'
+            )
+            .map(({hasShadowRoot, hasShadowContent, ...entry}) => entry);
+          const markers = Array.from(
+            document.querySelectorAll('[data-extjs-reinject-marker="true"]')
+          )
+            .slice(0, 10)
+            .map(normalize);
+          const pageHasBackingEvidence =
+            roots.length > 0 ||
+            markers.length > 0 ||
+            registries.some((entry) =>
+              entry.key === pageCandidate.key ||
+              typeof entry.generation === 'number' ||
+              !!entry.hasCleanup ||
+              typeof entry.build === 'string'
+            );
+          const page = pageHasBackingEvidence ? pageCandidate : undefined;
+          const generations = roots
+            .concat(markers)
+            .map((entry) => entry.generation)
+            .concat(typeof page.generation === 'number' ? [page.generation] : [])
+            .concat(
+              registries
+                .map((entry) => entry.generation)
+                .filter((value) => typeof value === 'number')
+            )
+            .filter((value) => typeof value === 'number');
+          return {
+            rootCount: roots.length,
+            markerCount: markers.length,
+            latestGeneration: generations.length ? Math.max(...generations) : 0,
+            roots,
+            markers,
+            registries,
+            page
+          };
+        })()`;
+        const SHADOW_STYLE_SNAPSHOT_EXPRESSION = `(() => {
+          try {
+            const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+            if (!hosts.length) return null;
+            for (const host of hosts) {
+              const sr = host && host.shadowRoot;
+              if (!sr) continue;
+              const styles = Array.from(sr.querySelectorAll('style')).map((styleEl) => {
+                const html = String(styleEl.outerHTML || '');
+                const text = String(styleEl.textContent || '');
+                return {
+                  html,
+                  textLength: text.length,
+                  textSnippet: text.trim().slice(0, 200)
+                };
+              });
+              return {
+                rootMode: 'shadow',
+                count: styles.length,
+                styles
+              };
+            }
+            return null;
+          } catch {
+            return null;
+          }
+        })()`;
+        const HAS_VISIBLE_SHADOW_HOST_EXPRESSION = `(() => { try {
+                const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+                if (!hosts.length) return false;
+                for (const h of hosts) {
+                  try {
+                    const sr = h && h.shadowRoot;
+                    if (sr && (String(sr.innerHTML||'').length > 0)) return true;
+                  } catch { /* ignore */ }
+                }
+                return false;
+              } catch { return false } })()`;
+        async function collectExecutionContexts(cdp, sessionId) {
+            const rawCdp = cdp;
+            if ('function' != typeof rawCdp.sendCommand || 'function' != typeof rawCdp.onProtocolEvent) return [];
+            const contextsById = new Map();
+            const unsubscribe = rawCdp.onProtocolEvent((message)=>{
+                if (String(message.sessionId || '') !== sessionId) return;
+                if ('Runtime.executionContextCreated' !== String(message.method || '')) return;
+                const context = message.params?.context;
+                const contextId = context?.id;
+                if ('number' == typeof contextId) contextsById.set(contextId, context);
+            });
+            try {
+                await rawCdp.sendCommand('Runtime.enable', {}, sessionId, 3000);
+                await new Promise((resolve)=>setTimeout(resolve, 100));
+            } catch  {
+                return [];
+            } finally{
+                unsubscribe();
+            }
+            return Array.from(contextsById.values());
+        }
+        async function getIsolatedContextId(cdp, sessionId) {
+            const contexts = await collectExecutionContexts(cdp, sessionId);
+            const preferredContext = contexts.find((context)=>{
+                const auxData = context?.auxData || {};
+                return 'isolated' === auxData.type && String(context?.origin || '').startsWith('chrome-extension://');
+            });
+            if ('number' == typeof preferredContext?.id) return preferredContext.id;
+            const fallbackContext = contexts.find((context)=>context?.auxData?.type === 'isolated');
+            return 'number' == typeof fallbackContext?.id ? fallbackContext.id : void 0;
+        }
+        async function evaluateWithContentContext(cdp, sessionId, expression, shouldAccept) {
+            let pageResult;
+            try {
+                pageResult = await cdp.evaluate(sessionId, expression);
+                if (shouldAccept(pageResult)) return pageResult;
+            } catch  {}
+            try {
+                const isolatedContextId = await getIsolatedContextId(cdp, sessionId);
+                if ('number' == typeof isolatedContextId) {
+                    const isolatedResult = await cdp.evaluateInContext(sessionId, expression, isolatedContextId);
+                    if (shouldAccept(isolatedResult)) return isolatedResult;
+                    if (void 0 !== pageResult) return pageResult;
+                    return isolatedResult;
+                }
+            } catch  {}
+            return pageResult;
+        }
+        function isExtensionRootMetaPayload(value) {
+            if (!value || 'object' != typeof value) return false;
+            const v = value;
+            return 'number' == typeof v.rootCount && 'number' == typeof v.markerCount && 'number' == typeof v.latestGeneration && Array.isArray(v.roots) && Array.isArray(v.markers) && Array.isArray(v.registries);
+        }
+        async function evaluateExtensionRootMeta(cdp, sessionId) {
+            try {
+                const payload = await evaluateWithContentContext(cdp, sessionId, EXTENSION_ROOT_META_EXPRESSION, isExtensionRootMetaPayload);
+                return payload;
+            } catch  {
+                return;
+            }
+        }
+        async function evaluateShadowStyleSnapshot(cdp, sessionId) {
+            try {
+                const payload = await evaluateWithContentContext(cdp, sessionId, SHADOW_STYLE_SNAPSHOT_EXPRESSION, (value)=>null === value || 'object' == typeof value && null !== value);
+                if (null == payload) return;
+                return payload;
+            } catch  {
+                return;
+            }
+        }
+        async function pollForVisibleShadowHostContent(cdp, sessionId, deadlineMs = 4000) {
+            const deadline = Date.now() + deadlineMs;
+            const started = Date.now();
+            while(Date.now() < deadline){
+                try {
+                    const hasRoot = await hasVisibleShadowHostContent(cdp, sessionId);
+                    if (hasRoot) return;
+                } catch  {}
+                const elapsed = Date.now() - started;
+                const delay = elapsed < 1000 ? 150 : 350;
+                await new Promise((r)=>setTimeout(r, delay));
+            }
+        }
+        async function hasVisibleShadowHostContent(cdp, sessionId) {
+            try {
+                const v = await evaluateWithContentContext(cdp, sessionId, HAS_VISIBLE_SHADOW_HOST_EXPRESSION, (value)=>true === value || false === value);
+                return true === v;
+            } catch  {
+                return false;
+            }
+        }
+        async function getPageHTML(cdp, sessionId, includeShadow = 'open-only') {
+            try {
+                await cdp.evaluate(sessionId, 'document.title');
+            } catch  {}
+            const mainHTMLRaw = await cdp.evaluate(sessionId, `(() => {
+        try {
+          const serialize = () => {
+            const doctype = document.doctype  
+            const dt = doctype
+              ? '<!DOCTYPE '
+                + doctype.name
+                + (doctype.publicId ? ' PUBLIC "' + doctype.publicId + '"' : '')
+                + (doctype.systemId ? ' "' + doctype.systemId + '"' : '')
+                + '>'
+              : ''
+            return dt + '\n' + document.documentElement.outerHTML
+          }
+          return serialize()
+        } catch (e) {
+          return ''
+        }
+      })()`);
+            const mainHTML = 'string' == typeof mainHTMLRaw ? mainHTMLRaw : String(mainHTMLRaw || '');
+            if ('off' === includeShadow) return mainHTML;
+            const hasVisibleContentRoot = await evaluateWithContentContext(cdp, sessionId, `(() => {
+      try {
+        return !!document.querySelector(${JSON.stringify(NON_DEVTOOLS_CONTENT_ROOT_SELECTOR)})
+      } catch {
+        return false
+      }
+    })()`, (value)=>'boolean' == typeof value);
+            if (!hasVisibleContentRoot) return mainHTML;
+            try {
+                const mergedHtmlRaw = await evaluateWithContentContext(cdp, sessionId, `(() => { try { 
+        var cloned = document.documentElement.cloneNode(true); 
+        var selector = ${JSON.stringify(NON_DEVTOOLS_CONTENT_ROOT_SELECTOR)};
+        var s = new XMLSerializer(); 
+        try { 
+          var liveHosts = Array.from(document.querySelectorAll(selector));
+          if (!liveHosts.length) return '';
+          var clonedHosts = Array.from(cloned.querySelectorAll(selector));
+          if (clonedHosts.length < liveHosts.length) {
+            var cloneDoc = cloned.ownerDocument || document;
+            var cloneBody = cloned.querySelector('body') || cloned;
+            for (var missingIndex = clonedHosts.length; missingIndex < liveHosts.length; missingIndex++) {
+              var missingLiveHost = liveHosts[missingIndex];
+              if (!missingLiveHost || !missingLiveHost.tagName || !cloneBody || typeof cloneBody.appendChild !== 'function') continue;
+              var shell = cloneDoc.createElement(String(missingLiveHost.tagName || 'div').toLowerCase());
+              try {
+                Array.from(missingLiveHost.attributes || []).forEach(function(attr){
+                  try { shell.setAttribute(attr.name, attr.value); } catch(_) {}
+                });
+              } catch(_) {}
+              try { cloneBody.appendChild(shell); } catch(_) {}
+              clonedHosts.push(shell);
+            }
+          }
+          for (var index = 0; index < liveHosts.length; index++) {
+            var host = clonedHosts[index];
+            var liveHost = liveHosts[index];
+            if (!host || !liveHost || !liveHost.shadowRoot) continue;
+            var shadow = Array.from(liveHost.shadowRoot.childNodes).map(function(n){ 
+              try { return s.serializeToString(n) } catch(e){ return '' } 
+            }).join('');
+            if (!shadow) continue;
+            try { host.innerHTML = shadow; } catch(e) {}
+          } 
+        } catch(e) {} 
+        var doctype = document.doctype; 
+        var dt = doctype ? '<!DOCTYPE ' + doctype.name + (doctype.publicId ? ' PUBLIC \"' + doctype.publicId + '\"' : '') + (doctype.systemId ? ' \"' + doctype.systemId + '\"' : '') + '>' : ''; 
+        return String(dt + '\\n' + (cloned.outerHTML || document.documentElement.outerHTML)); 
+      } catch(e) { try { return String(document.documentElement.outerHTML); } catch(_) { return '' } } })()`, (value)=>'string' == typeof value && /<html[\s>]/i.test(value));
+                const mergedHtml = 'string' == typeof mergedHtmlRaw ? mergedHtmlRaw : String(mergedHtmlRaw || '');
+                if (mergedHtml && /<html[\s>]/i.test(mergedHtml)) return mergedHtml;
+            } catch  {}
+            let shadowContent = '';
+            try {
+                shadowContent = await evaluateWithContentContext(cdp, sessionId, `(() => {
+          try {
+            const hosts = Array.from(document.querySelectorAll(${JSON.stringify(CONTENT_ROOT_SELECTOR)}));
+            if (!hosts.length) return '';
+            const preferMarkers = ['iskilar_box','content_script','content_title','js-probe'];
+            let firstNonEmpty = '';
+            for (const host of hosts) {
+              try {
+                const sr = host && host.shadowRoot;
+                if (!sr) continue;
+                const html = String(sr.innerHTML || '');
+                if (html && html.length) {
+                  if (preferMarkers.some((m) => html.includes(m))) return html;
+                  if (!firstNonEmpty) firstNonEmpty = html;
+                  continue;
+                }
+                try {
+                  const parts = Array.from(sr.children)
+                    .map((n) => (n && n.outerHTML) ? String(n.outerHTML) : '')
+                    .join('');
+                  if (parts && parts.length) {
+                    if (preferMarkers.some((m) => parts.includes(m))) return parts;
+                    if (!firstNonEmpty) firstNonEmpty = parts;
+                  }
+                } catch { /* ignore */ }
+              } catch { /* ignore */ }
+            }
+            return firstNonEmpty || '';
+          } catch { return '' }
+        })()`, (value)=>'string' == typeof value && value.trim().length > 0);
+            } catch  {}
+            if (shadowContent) try {
+                const sc = 'string' == typeof shadowContent ? shadowContent : String(shadowContent || '');
+                return mergeShadowIntoDocument(mainHTML, sc);
+            } catch  {}
+            return mainHTML;
+        }
+        async function waitForLoadEvent(cdp, sessionId) {
+            return new Promise((resolve)=>{
+                let resolved = false;
+                const listener = (data)=>{
+                    try {
+                        const message = JSON.parse(data);
+                        if ('Page.loadEventFired' === message.method && message.sessionId === sessionId && !resolved) {
+                            resolved = true;
+                            resolve();
+                        }
+                    } catch  {}
+                };
+                const clientWithHandle = cdp;
+                const original = clientWithHandle.handleMessage.bind(cdp);
+                clientWithHandle.handleMessage = (data)=>{
+                    original(data);
+                    listener(data);
+                };
+                setTimeout(()=>{
+                    if (!resolved) {
+                        resolved = true;
+                        console.log(messages.Qiq());
+                        resolve();
+                    }
+                    clientWithHandle.handleMessage = original;
+                }, 2000);
+            });
+        }
+        async function waitForContentScriptInjection(cdp, sessionId) {
+            const deadline = Date.now() + 30000;
+            const started = Date.now();
+            while(Date.now() < deadline){
+                try {
+                    const injected = await evaluateWithContentContext(cdp, sessionId, `(() => { try {
+          const hosts = Array.from(document.querySelectorAll(${JSON.stringify(CONTENT_ROOT_SELECTOR)}));
+          if (!hosts.length) return false;
+          const markers = ['iskilar_box','content_script','content_title','js-probe'];
+          for (const h of hosts) {
+            try {
+              const sr = h && h.shadowRoot;
+              if (!sr) continue;
+              const html = String(sr.innerHTML||'');
+              if (html.length > 0) return true;
+              if (markers.some((m) => html.includes(m))) return true;
+              try {
+                const parts = Array.from(sr.children).map((n) => (n && n.outerHTML) ? String(n.outerHTML) : '').join('');
+                if (parts && parts.length) return true;
+                if (markers.some((m) => parts.includes(m))) return true;
+              } catch { /* ignore */ }
+            } catch { /* ignore */ }
+          }
+          return false;
+        } catch { return false } })()`, (value)=>Boolean(value));
+                    if (Boolean(injected)) return true;
+                } catch  {}
+                const elapsed = Date.now() - started;
+                const delay = elapsed < 2000 ? 150 : 500;
+                await new Promise((r)=>setTimeout(r, delay));
+            }
+            return false;
+        }
+        function establishBrowserConnection(url, isDev, onMessage, onRejectPending) {
+            return new Promise((resolve, reject)=>{
+                const ws = new wrapper.Ay(url);
+                ws.on('open', ()=>{
+                    if (isDev) console.log(messages.F1E());
+                    resolve(ws);
+                });
+                ws.on('message', (data)=>{
+                    onMessage(data.toString());
+                });
+                ws.on('error', (error)=>{
+                    if (isDev) console.error(messages.fRy(error.message));
+                    onRejectPending(error.message);
+                    reject(error);
+                });
+                ws.on('close', ()=>{
+                    if (isDev) console.log(messages.hE8());
+                    onRejectPending('CDP connection closed');
+                });
+            });
+        }
+        function _define_property(obj, key, value) {
+            if (key in obj) Object.defineProperty(obj, key, {
+                value: value,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+            else obj[key] = value;
+            return obj;
+        }
+        class CDPClient {
+            isDev() {
+                return 'true' === process.env.EXTENSION_AUTHOR_MODE;
+            }
+            async connect() {
+                return new Promise(async (resolve, reject)=>{
+                    try {
+                        this.targetWebSocketUrl = await discoverWebSocketDebuggerUrl(this.host, this.port, this.isDev());
+                        this.ws = await establishBrowserConnection(this.targetWebSocketUrl, this.isDev(), (data)=>this.handleMessage(data), (reason)=>{
+                            this.pendingRequests.forEach(({ reject, timeout }, id)=>{
+                                try {
+                                    reject(new Error(reason));
+                                } catch (error) {
+                                    if (this.isDev()) {
+                                        const err = error;
+                                        console.warn(messages.r0s(String(err.message || err)));
+                                    }
+                                }
+                                if (timeout) clearTimeout(timeout);
+                                this.pendingRequests.delete(id);
+                            });
+                        });
+                        if (this.isDev()) console.log(messages.M3V(this.host, this.port));
+                        resolve();
+                    } catch (error) {
+                        const err = error;
+                        reject(new Error(`Failed to connect to CDP: ${err.message || err}`));
+                    }
+                });
+            }
+            disconnect() {
+                if (this.ws) {
+                    try {
+                        this.ws.close();
+                    } catch  {}
+                    this.ws = null;
+                }
+            }
+            isConnected() {
+                return !!this.ws && this.ws.readyState === wrapper.Ay.OPEN;
+            }
+            onProtocolEvent(handler) {
+                this.eventCallbacks.add(handler);
+                return ()=>{
+                    this.eventCallbacks.delete(handler);
+                };
+            }
+            handleMessage(data) {
+                try {
+                    const message = JSON.parse(data);
+                    if (message.id) {
+                        const pending = this.pendingRequests.get(message.id);
+                        if (pending) {
+                            if (pending.timeout) clearTimeout(pending.timeout);
+                            this.pendingRequests.delete(message.id);
+                            if (message.error) pending.reject(new Error(JSON.stringify(message.error)));
+                            else pending.resolve(message.result);
+                        }
+                        return;
+                    }
+                    if ('Target.attachedToTarget' === message.method) {
+                        const params = message.params || {};
+                        if (this.isDev()) console.log(messages.p8m(String(params.sessionId || ''), String(params.targetInfo?.type || '')));
+                    }
+                    for (const eventCallback of this.eventCallbacks)eventCallback(message);
+                } catch (error) {
+                    if (this.isDev()) {
+                        const err = error;
+                        console.warn(messages.xxG(String(err.message || err)));
+                    }
+                }
+            }
+            async sendCommand(method, params = {}, sessionId, timeoutMs = 12000) {
+                return new Promise((resolve, reject)=>{
+                    if (!this.ws || this.ws.readyState !== wrapper.Ay.OPEN) return reject(new Error('WebSocket is not open'));
+                    const id = ++this.messageId;
+                    const message = {
+                        id,
+                        method,
+                        params
+                    };
+                    if (sessionId) message.sessionId = sessionId;
+                    try {
+                        const timeout = setTimeout(()=>{
+                            const pending = this.pendingRequests.get(id);
+                            if (!pending) return;
+                            this.pendingRequests.delete(id);
+                            pending.reject(new Error(`CDP command timed out (${timeoutMs}ms): ${String(pending.method || method)}`));
+                        }, timeoutMs);
+                        this.pendingRequests.set(id, {
+                            resolve,
+                            reject,
+                            timeout,
+                            method
+                        });
+                        this.ws.send(JSON.stringify(message));
+                    } catch (error) {
+                        const pending = this.pendingRequests.get(id);
+                        if (pending?.timeout) clearTimeout(pending.timeout);
+                        this.pendingRequests.delete(id);
+                        reject(error);
+                    }
+                });
+            }
+            async getTargets() {
+                const response = await this.sendCommand('Target.getTargets');
+                return response?.targetInfos || [];
+            }
+            async getBrowserVersion() {
+                const response = await this.sendCommand('Browser.getVersion');
+                return response || {};
+            }
+            async attachToTarget(targetId) {
+                const response = await this.sendCommand('Target.attachToTarget', {
+                    targetId,
+                    flatten: true
+                });
+                return response.sessionId || '';
+            }
+            async enableAutoAttach() {
+                await this.sendCommand('Target.setAutoAttach', {
+                    autoAttach: true,
+                    waitForDebuggerOnStart: false,
+                    flatten: true
+                });
+            }
+            async enableRuntimeAndLog(sessionId) {
+                await this.sendCommand('Log.enable', {}, sessionId);
+                if (sessionId) await this.sendCommand('Runtime.enable', {}, sessionId);
+            }
+            async navigate(sessionId, url) {
+                await this.sendCommand('Page.navigate', {
+                    url
+                }, sessionId);
+            }
+            async createTarget(url) {
+                const res = await this.sendCommand('Target.createTarget', {
+                    url
+                });
+                return String(res?.targetId || '');
+            }
+            async activateTarget(targetId) {
+                await this.sendCommand('Target.activateTarget', {
+                    targetId
+                });
+            }
+            async waitForLoadEvent(sessionId) {
+                return waitForLoadEvent(this, sessionId);
+            }
+            async waitForContentScriptInjection(sessionId) {
+                return waitForContentScriptInjection(this, sessionId);
+            }
+            async getExtensionRootMeta(sessionId) {
+                return evaluateExtensionRootMeta(this, sessionId);
+            }
+            async getShadowStyleSnapshot(sessionId) {
+                return evaluateShadowStyleSnapshot(this, sessionId);
+            }
+            async pollForVisibleShadowHostContent(sessionId, deadlineMs) {
+                return pollForVisibleShadowHostContent(this, sessionId, deadlineMs);
+            }
+            async hasVisibleShadowHostContent(sessionId) {
+                return hasVisibleShadowHostContent(this, sessionId);
+            }
+            async evaluate(sessionId, expression, options) {
+                const response = await this.sendCommand('Runtime.evaluate', {
+                    expression,
+                    returnByValue: true,
+                    awaitPromise: options?.awaitPromise === true
+                }, sessionId);
+                return response.result?.value;
+            }
+            async evaluateInContext(sessionId, expression, contextId, options) {
+                const response = await this.sendCommand('Runtime.evaluate', {
+                    expression,
+                    contextId,
+                    returnByValue: true,
+                    awaitPromise: options?.awaitPromise === true
+                }, sessionId);
+                return response.result?.value;
+            }
+            async getPageHTML(sessionId, includeShadow = 'open-only') {
+                return getPageHTML(this, sessionId, includeShadow);
+            }
+            async closeTarget(targetId) {
+                await this.sendCommand('Target.closeTarget', {
+                    targetId
+                });
+            }
+            async forceReloadExtension(extensionId) {
+                const attempts = 8;
+                let lastError = null;
+                for(let i = 0; i < attempts; i++){
+                    try {
+                        const ok = await this.reloadExtensionViaTargetEval(extensionId);
+                        if (ok) return true;
+                    } catch (error) {
+                        lastError = error;
+                    }
+                    const backoffMs = Math.min(1200, 150 * (i + 1));
+                    await new Promise((r)=>setTimeout(r, backoffMs));
+                }
+                console.warn(messages.ccn(extensionId, lastError?.message || String(lastError || 'runtime.reload failed')));
+                return false;
+            }
+            async getExtensionInfo(extensionId) {
+                try {
+                    return await getExtensionInfo(this, extensionId);
+                } catch (error) {
+                    throw new Error(messages.Z5i(extensionId, error.message));
+                }
+            }
+            async reloadExtensionViaTargetEval(extensionId) {
+                try {
+                    const targets = await this.getTargets();
+                    const preferredOrder = [
+                        'service_worker',
+                        'background_page',
+                        'worker',
+                        'page'
+                    ];
+                    for (const type of preferredOrder){
+                        const matchingTargets = (targets || []).filter((t)=>{
+                            const url = String(t?.url || '');
+                            const tt = String(t?.type || '');
+                            const inExtensionScope = url.startsWith(`chrome-extension://${extensionId}/`);
+                            return tt === type && inExtensionScope;
+                        });
+                        for (const target of matchingTargets){
+                            const targetId = target?.targetId;
+                            if (targetId) try {
+                                const sessionId = await this.attachToTarget(targetId);
+                                await this.sendCommand('Runtime.enable', {}, sessionId);
+                                await this.sendCommand('Runtime.evaluate', {
+                                    expression: '(function(){ try { if (!chrome || !chrome.runtime || !chrome.runtime.reload) return false; chrome.runtime.reload(); return true; } catch (error) { return false; } })()',
+                                    returnByValue: true
+                                }, sessionId);
+                                return true;
+                            } catch  {}
+                        }
+                    }
+                    return false;
+                } catch  {
+                    return false;
+                }
+            }
+            async loadUnpackedExtension(path) {
+                try {
+                    return await loadUnpackedExtension(this, path);
+                } catch (error) {
+                    throw new Error(messages.xlM(path, error.message));
+                }
+            }
+            async unloadExtension(extensionId) {
+                try {
+                    return await unloadExtension(this, extensionId);
+                } catch (error) {
+                    console.error(messages.yEr(extensionId, error.message));
+                    return false;
+                }
+            }
+            constructor(port = 9222, host = '127.0.0.1'){
+                _define_property(this, "port", void 0);
+                _define_property(this, "host", void 0);
+                _define_property(this, "ws", null);
+                _define_property(this, "targetWebSocketUrl", null);
+                _define_property(this, "eventCallbacks", new Set());
+                _define_property(this, "messageId", 0);
+                _define_property(this, "pendingRequests", new Map());
+                this.port = port;
+                this.host = host;
+            }
+        }
+        function isRecoverableBootstrapError(error) {
+            const msg = String(error?.message || error || '').toLowerCase();
+            return msg.includes('econnreset') || msg.includes('websocket is not open') || msg.includes('cdp connection closed') || msg.includes('socket hang up') || msg.includes('timed out') || msg.includes('no cdp websocket url');
+        }
+        async function connectToChromeCdp(cdpPort) {
+            let retries = 0;
+            const maxRetries = 60;
+            const backoffMs = 250;
+            while(retries < maxRetries){
+                const ready = await checkChromeRemoteDebugging(cdpPort);
+                if (ready) break;
+                retries++;
+                await new Promise((r)=>setTimeout(r, backoffMs));
+            }
+            const maxBootstrapAttempts = 4;
+            let lastError = null;
+            for(let attempt = 1; attempt <= maxBootstrapAttempts; attempt++){
+                const cdp = new CDPClient(cdpPort, '127.0.0.1');
+                try {
+                    await cdp.connect();
+                    await cdp.sendCommand('Target.setDiscoverTargets', {
+                        discover: true
+                    });
+                    await cdp.sendCommand('Target.setAutoAttach', {
+                        autoAttach: true,
+                        waitForDebuggerOnStart: false,
+                        flatten: true
+                    });
+                    return cdp;
+                } catch (error) {
+                    lastError = error;
+                    cdp.disconnect();
+                    const retryable = isRecoverableBootstrapError(error);
+                    const hasMoreAttempts = attempt < maxBootstrapAttempts;
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
+                        const base = String(error?.message || error);
+                        console.warn(`[CDP] bootstrap attempt ${attempt}/${maxBootstrapAttempts} failed: ${base}`);
+                    }
+                    if (!retryable || !hasMoreAttempts) throw error;
+                    const delayMs = 120 * attempt;
+                    await new Promise((r)=>setTimeout(r, delayMs));
+                }
+            }
+            throw lastError instanceof Error ? lastError : new Error('Failed to bootstrap CDP connection');
+        }
+        function readManifestInfo(outPath) {
+            try {
+                const manifestPath = external_path_.join(outPath, 'manifest.json');
+                const manifest = JSON.parse(external_fs_.readFileSync(manifestPath, 'utf-8'));
+                return {
+                    name: manifest?.name,
+                    version: manifest?.version
+                };
+            } catch  {
+                return null;
+            }
+        }
+        function registerAutoEnableLogging(cdp, getExtensionId) {
+            cdp.onProtocolEvent((message)=>{
+                try {
+                    if (!message || !message.method) return;
+                    if ('Target.attachedToTarget' === message.method) {
+                        const params = message.params || {};
+                        const targetInfo = params.targetInfo || {};
+                        const sessionId = params.sessionId;
+                        const url = String(targetInfo.url || '');
+                        const type = String(targetInfo.type || '');
+                        const extId = getExtensionId();
+                        const matchesExtension = !!(extId && url.includes(`chrome-extension://${extId}/`) || 'service_worker' === type);
+                        if (sessionId && matchesExtension) {
+                            cdp.sendCommand('Runtime.enable', {}, sessionId).catch(()=>{});
+                            cdp.sendCommand('Log.enable', {}, sessionId).catch(()=>{});
+                        }
+                    } else if ('Runtime.consoleAPICalled' === message.method || 'Log.entryAdded' === message.method) {
+                        if ('1' === String(process.env.EXTENSION_VERBOSE || '').trim()) {
+                            const ts = new Date().toISOString();
+                            console.log(messages.bvI(ts, message.params));
+                        }
+                    }
+                } catch (error) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.KK1(String(error?.message || error)));
+                }
+            });
+        }
+        function cdp_extension_controller_define_property(obj, key, value) {
+            if (key in obj) Object.defineProperty(obj, key, {
+                value: value,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+            else obj[key] = value;
+            return obj;
+        }
+        class CDPExtensionController {
+            async connect() {
+                if (this.cdp) return;
+                await this.connectFreshClient();
+            }
+            async ensureLoaded() {
+                if (!this.cdp) throw new Error('CDP not connected');
+                const exists = external_fs_.existsSync(this.outPath);
+                if (!exists) throw new Error(`Output path not found: ${this.outPath}`);
+                if (!this.extensionId) {
+                    const id = await this.deriveExtensionIdFromTargets();
+                    if (id) this.extensionId = id;
+                }
+                if (this.extensionId) {
+                    const belongsToOutPath = this.extensionIdBelongsToOutPath(this.extensionId);
+                    if (false === belongsToOutPath) this.extensionId = null;
+                }
+                if (this.extensionId) try {
+                    let info = null;
+                    try {
+                        info = await this.cdp.getExtensionInfo(this.extensionId);
+                    } catch  {}
+                    if (!info) {
+                        const manifest = JSON.parse(external_fs_.readFileSync(external_path_.join(this.outPath, 'manifest.json'), 'utf-8'));
+                        return {
+                            extensionId: this.extensionId,
+                            name: manifest.name,
+                            version: manifest.version
+                        };
+                    }
+                    return {
+                        extensionId: this.extensionId,
+                        name: info?.extensionInfo?.name,
+                        version: info?.extensionInfo?.version
+                    };
+                } catch  {}
+                try {
+                    if (!this.extensionId) this.extensionId = await this.deriveExtensionIdFromTargets(20, 200);
+                    if (!this.extensionId) throw new Error('Failed to determine extension ID via CDP');
+                    await this.enableLogging();
+                    let name;
+                    let version;
+                    try {
+                        const info = await this.cdp.getExtensionInfo(this.extensionId);
+                        name = info?.extensionInfo?.name;
+                        version = info?.extensionInfo?.version;
+                    } catch (error) {
+                        try {
+                            const manifest = readManifestInfo(this.outPath);
+                            name = String(manifest?.name || '') || void 0;
+                            version = String(manifest?.version || '') || void 0;
+                        } catch (e2) {
+                            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn('[CDP] Fallback manifest read failed:', String(e2?.message || e2));
+                        }
+                    }
+                    return {
+                        extensionId: this.extensionId,
+                        name,
+                        version
+                    };
+                } catch (error) {
+                    throw new Error(`Failed to load extension from ${external_path_.resolve(this.outPath)}: ${String(error.message || error)}`);
+                }
+            }
+            async deriveExtensionIdFromTargets(maxRetries = 20, backoffMs = 200) {
+                if (!this.cdp) return null;
+                return await deriveExtensionIdFromTargetsHelper(this.cdp, this.outPath, maxRetries, backoffMs, this.profilePath, this.extensionPaths);
+            }
+            normalizePath(input) {
+                try {
+                    return external_fs_.realpathSync(external_path_.resolve(input));
+                } catch  {
+                    return external_path_.resolve(input);
+                }
+            }
+            extensionIdBelongsToOutPath(extensionId) {
+                if (!this.profilePath || !extensionId) return null;
+                const prefCandidates = [];
+                const addPrefCandidate = (dir)=>{
+                    const prefPath = external_path_.join(dir, 'Preferences');
+                    if (external_fs_.existsSync(prefPath)) prefCandidates.push(prefPath);
+                };
+                try {
+                    addPrefCandidate(this.profilePath);
+                    addPrefCandidate(external_path_.join(this.profilePath, 'Default'));
+                    for (const entry of external_fs_.readdirSync(this.profilePath))if (/^Profile\s+\d+$/i.test(entry)) addPrefCandidate(external_path_.join(this.profilePath, entry));
+                } catch  {}
+                if (0 === prefCandidates.length) return null;
+                const normalizedOutPath = this.normalizePath(this.outPath);
+                for (const prefPath of prefCandidates)try {
+                    const prefs = JSON.parse(external_fs_.readFileSync(prefPath, 'utf-8'));
+                    const settings = prefs?.extensions?.settings;
+                    const info = settings?.[extensionId];
+                    const storedPath = String(info?.path || '');
+                    if (!storedPath) continue;
+                    return this.normalizePath(storedPath) === normalizedOutPath;
+                } catch  {}
+                return null;
+            }
+            getDeveloperModeStatus() {
+                if (!this.profilePath) return 'unknown';
+                const prefCandidates = [];
+                const seen = new Set();
+                const addPrefCandidate = (dir)=>{
+                    const prefPath = external_path_.join(dir, 'Preferences');
+                    if (!external_fs_.existsSync(prefPath)) return;
+                    const dedupeKey = external_path_.resolve(prefPath);
+                    if (seen.has(dedupeKey)) return;
+                    seen.add(dedupeKey);
+                    prefCandidates.push(prefPath);
+                };
+                try {
+                    addPrefCandidate(this.profilePath);
+                    addPrefCandidate(external_path_.join(this.profilePath, 'Default'));
+                    for (const entry of external_fs_.readdirSync(this.profilePath))if (/^Profile\s+\d+$/i.test(entry)) addPrefCandidate(external_path_.join(this.profilePath, entry));
+                } catch  {}
+                for (const prefPath of prefCandidates)try {
+                    const prefs = JSON.parse(external_fs_.readFileSync(prefPath, 'utf-8'));
+                    const uiFlag = prefs?.extensions?.ui?.developer_mode;
+                    if ('boolean' == typeof uiFlag) return uiFlag ? 'enabled' : 'disabled';
+                    const legacyFlag = prefs?.extensions?.developer_mode;
+                    if ('boolean' == typeof legacyFlag) return legacyFlag ? 'enabled' : 'disabled';
+                } catch  {}
+                return 'unknown';
+            }
+            getLastRuntimeReinjectionReport() {
+                return this.lastRuntimeReinjectionReport;
+            }
+            async reloadMatchingTabsForContentScripts(rules, options = {}) {
+                if (!this.cdp || 0 === rules.length) return 0;
+                let reinjectedTabs = 0;
+                const targets = await this.cdp.getTargets();
+                for (const target of targets || []){
+                    const targetType = String(target?.type || '');
+                    const targetId = String(target?.targetId || '');
+                    const targetUrl = String(target?.url || '');
+                    if ('page' !== targetType || !targetId || !targetUrl) continue;
+                    const matchingRules = rules.filter((rule)=>(0, content_script_targets.lM)(targetUrl, [
+                            rule
+                        ]));
+                    if (0 !== matchingRules.length) try {
+                        const sessionId = await this.cdp.attachToTarget(targetId);
+                        let reinjected = false;
+                        if (options.preferPageReload) reinjected = await this.reloadPageTarget(sessionId);
+                        else {
+                            for (const [index, rule] of matchingRules.entries()){
+                                const didReinject = await this.reinjectContentScriptRule(sessionId, rule, options.allowCoarseCleanup ?? 0 === index, options.sourceOverridesByBundleId);
+                                reinjected = reinjected || didReinject;
+                            }
+                            if (!reinjected) reinjected = await this.reloadPageTarget(sessionId);
+                        }
+                        if (reinjected) reinjectedTabs += 1;
+                    } catch (error) {
+                        if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(`[CDP] Failed to reinject content scripts into ${targetUrl}: ${String(error?.message || error)}`);
+                    }
+                }
+                return reinjectedTabs;
+            }
+            async reinjectMatchingTabsViaExtensionRuntime(rules) {
+                if (!this.cdp || 0 === rules.length) {
+                    this.lastRuntimeReinjectionReport = {
+                        phase: 'skipped',
+                        reason: 'missing_cdp_or_rules',
+                        hasCdp: !!this.cdp,
+                        ruleCount: rules.length
+                    };
+                    return 0;
+                }
+                const targets = await this.cdp.getTargets();
+                const matchingUrlsByRule = new Map();
+                for (const target of targets || []){
+                    const targetType = String(target?.type || '');
+                    const targetUrl = String(target?.url || '');
+                    if ('page' === targetType && targetUrl) for (const rule of rules){
+                        if (!(0, content_script_targets.lM)(targetUrl, [
+                            rule
+                        ])) continue;
+                        const urls = matchingUrlsByRule.get(rule.index) || new Set();
+                        urls.add(targetUrl);
+                        matchingUrlsByRule.set(rule.index, urls);
+                    }
+                }
+                const payload = rules.map((rule)=>{
+                    const jsPath = (0, content_script_targets.nG)(this.outPath, rule.index, 'js');
+                    const cssPath = (0, content_script_targets.nG)(this.outPath, rule.index, 'css');
+                    if (!jsPath || !external_fs_.existsSync(jsPath)) return null;
+                    const jsFile = external_path_.relative(this.outPath, jsPath).replace(/\\/g, '/');
+                    const cssFile = cssPath && external_fs_.existsSync(cssPath) ? external_path_.relative(this.outPath, cssPath).replace(/\\/g, '/') : null;
+                    const jsSource = external_fs_.readFileSync(jsPath, 'utf-8');
+                    const buildTokenMatch = jsSource.match(/__EXTENSIONJS_REINJECT_BUILD_TOKEN\s*=\s*"([^"]+)"/);
+                    const proofMatch = jsSource.match(/extjs-chromium-live-content-css-modules:script-primary-\d+/) || jsSource.match(/Live Update Proof [A-Za-z0-9_-]+/);
+                    return {
+                        index: rule.index,
+                        world: rule.world,
+                        matches: [
+                            ...rule.matches
+                        ],
+                        urls: Array.from(matchingUrlsByRule.get(rule.index) || []).sort(),
+                        jsFile,
+                        cssFile,
+                        buildToken: buildTokenMatch?.[1] || null,
+                        proofMarker: proofMatch?.[0] || null
+                    };
+                }).filter((entry)=>!!entry && entry.urls.length > 0);
+                if (0 === payload.length) {
+                    this.lastRuntimeReinjectionReport = {
+                        phase: 'skipped',
+                        reason: 'no_payload',
+                        ruleCount: rules.length
+                    };
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log('[CDP] extension-runtime reinjection skipped: no payload');
+                    return 0;
+                }
+                const runtimeTarget = await this.attachToExtensionRuntimeTarget();
+                if (!runtimeTarget) {
+                    const targetSummary = (targets || []).map((target)=>({
+                            type: String(target?.type || ''),
+                            url: String(target?.url || '')
+                        })).filter((entry)=>entry.type || entry.url);
+                    this.lastRuntimeReinjectionReport = {
+                        phase: 'unavailable',
+                        reason: 'no_runtime_target',
+                        extensionId: this.extensionId,
+                        targets: targetSummary
+                    };
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[CDP] extension-runtime reinjection unavailable: ${JSON.stringify({
+                        extensionId: this.extensionId,
+                        targets: targetSummary
+                    })}`);
+                    return 0;
+                }
+                const result = await this.cdp.evaluate(runtimeTarget.sessionId, `(() => (async () => {
+        const payload = ${JSON.stringify(payload)};
+        const chromeRuntime =
+          typeof globalThis === 'object' && globalThis && globalThis.chrome
+            ? globalThis.chrome
+            : null;
+        const runtimeChrome =
+          chromeRuntime &&
+          chromeRuntime.scripting &&
+          chromeRuntime.tabs
+            ? chromeRuntime
+            : null;
+        if (!runtimeChrome) {
+          return {
+            reinjectedTabs: 0,
+            hasRuntime: false,
+            hasChrome: !!chromeRuntime,
+            hasScripting: !!(chromeRuntime && chromeRuntime.scripting),
+            hasTabs: !!(chromeRuntime && chromeRuntime.tabs),
+            entries: payload.length,
+            matches: []
+          };
+        }
+        let reinjectedTabs = 0;
+        const matches = [];
+        for (const entry of payload) {
+          const queriedTabs = await runtimeChrome.tabs.query(
+            entry.matches.length > 0 ? { url: entry.matches } : {}
+          );
+          const matchingTabs = queriedTabs.filter((tab) => {
+            if (!tab || typeof tab.id !== 'number') return false;
+            if (typeof tab.url !== 'string' || !tab.url) return true;
+            return entry.urls.length === 0 || entry.urls.includes(tab.url);
+          });
+          matches.push({
+            index: entry.index,
+            queriedTabs: queriedTabs.length,
+            matchingTabs: matchingTabs.length
+          });
+          for (const tab of matchingTabs) {
+            const target = { tabId: tab.id, allFrames: false };
+            if (entry.cssFile) {
+              try {
+                await runtimeChrome.scripting.insertCSS({
+                  target,
+                  files: [entry.cssFile]
+                });
+              } catch (error) {}
+            }
+            await runtimeChrome.scripting.executeScript({
+              target,
+              files: [entry.jsFile],
+              world: entry.world === 'main' ? 'MAIN' : 'ISOLATED'
+            });
+            reinjectedTabs += 1;
+          }
+        }
+        return {
+          reinjectedTabs,
+          hasRuntime: true,
+          entries: payload.length,
+          matches
+        };
+      })())()`, {
+                    awaitPromise: true
+                });
+                this.lastRuntimeReinjectionReport = {
+                    phase: 'evaluated',
+                    targetType: runtimeTarget.targetType,
+                    targetUrl: runtimeTarget.targetUrl,
+                    result: result && 'object' == typeof result ? JSON.parse(JSON.stringify(result)) : result
+                };
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[CDP] extension-runtime reinjection result: ${JSON.stringify({
+                    targetType: runtimeTarget.targetType,
+                    targetUrl: runtimeTarget.targetUrl,
+                    result
+                })}`);
+                if ('number' == typeof result) return result;
+                if (result && 'object' == typeof result) {
+                    const reinjectedTabs = Number(result.reinjectedTabs);
+                    return Number.isFinite(reinjectedTabs) ? reinjectedTabs : 0;
+                }
+                return 0;
+            }
+            async reloadPageTarget(sessionId) {
+                if (!this.cdp) return false;
+                try {
+                    await this.cdp.sendCommand('Page.reload', {
+                        ignoreCache: true
+                    }, sessionId);
+                    return true;
+                } catch  {
+                    return false;
+                }
+            }
+            async hardReload() {
+                if (!this.extensionId) return false;
+                try {
+                    if (!this.cdp) await this.connectFreshClient();
+                    if (this.cdp && await this.cdp.forceReloadExtension(this.extensionId)) return true;
+                } catch  {}
+                try {
+                    await this.reconnectForReload();
+                    return Boolean(this.cdp && this.extensionId && await this.cdp.forceReloadExtension(this.extensionId));
+                } catch  {
+                    return false;
+                }
+            }
+            async attachToExtensionRuntimeTarget() {
+                if (!this.cdp) return;
+                if (!this.extensionId) this.extensionId = await this.deriveExtensionIdFromTargets(10, 150);
+                if (!this.extensionId) return;
+                const extensionOrigin = `chrome-extension://${this.extensionId}/`;
+                for(let attempt = 0; attempt < 20; attempt++){
+                    const targets = await this.cdp.getTargets();
+                    const runtimeTargets = (targets || []).filter((target)=>{
+                        const targetType = String(target?.type || '');
+                        const targetId = String(target?.targetId || '');
+                        return ('service_worker' === targetType || 'background_page' === targetType || 'worker' === targetType) && !!targetId;
+                    });
+                    const runtimeTarget = runtimeTargets.find((target)=>String(target?.url || '').startsWith(extensionOrigin)) || runtimeTargets.find((target)=>String(target?.url || '').startsWith('chrome-extension://'));
+                    if (runtimeTarget) try {
+                        const sessionId = await this.cdp.attachToTarget(String(runtimeTarget.targetId));
+                        await this.cdp.sendCommand('Runtime.enable', {}, sessionId);
+                        return {
+                            sessionId,
+                            targetType: String(runtimeTarget?.type || ''),
+                            targetUrl: String(runtimeTarget?.url || '')
+                        };
+                    } catch  {}
+                    this.extensionId = await this.deriveExtensionIdFromTargets(4, 100) || this.extensionId;
+                    await new Promise((resolve)=>setTimeout(resolve, 250));
+                }
+            }
+            async connectFreshClient() {
+                this.cdp = await connectToChromeCdp(this.cdpPort);
+                try {
+                    await this.cdp.sendCommand('Target.setDiscoverTargets', {
+                        discover: true
+                    });
+                    await this.cdp.sendCommand('Target.setAutoAttach', {
+                        autoAttach: true,
+                        waitForDebuggerOnStart: false,
+                        flatten: true
+                    });
+                } catch (error) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.wXK(String(error?.message || error)));
+                }
+                registerAutoEnableLogging(this.cdp, ()=>this.extensionId);
+            }
+            async reconnectForReload() {
+                try {
+                    this.cdp?.disconnect?.();
+                } catch  {}
+                this.cdp = null;
+                await this.connectFreshClient();
+                try {
+                    const derivedExtensionId = await this.deriveExtensionIdFromTargets(10, 150);
+                    if (derivedExtensionId) this.extensionId = derivedExtensionId;
+                } catch  {}
+            }
+            onProtocolEvent(cb) {
+                if (!this.cdp) throw new Error('CDP not connected');
+                this.cdp.onProtocolEvent((raw)=>{
+                    const evt = raw;
+                    cb(evt);
+                });
+            }
+            clearProtocolEventHandler() {
+                if (!this.cdp) return;
+            }
+            async enableUnifiedLogging() {
+                if (!this.cdp) return;
+                try {
+                    await this.cdp.enableAutoAttach();
+                    await this.cdp.enableRuntimeAndLog();
+                    try {
+                        const targets = await this.cdp.getTargets();
+                        for (const t of targets || []){
+                            const type = String(t?.type || '');
+                            if ('page' === type || 'service_worker' === type || 'background_page' === type || 'worker' === type) {
+                                const targetId = String(t?.targetId || '');
+                                if (!targetId) continue;
+                                const sessionId = await this.cdp.attachToTarget(targetId);
+                                await this.cdp.enableRuntimeAndLog(sessionId);
+                            }
+                        }
+                    } catch  {}
+                } catch  {}
+            }
+            async enableRuntimeForSession(sessionId) {
+                if (!this.cdp) return;
+                try {
+                    await this.cdp.enableRuntimeAndLog(sessionId);
+                } catch  {}
+            }
+            async enableLogging() {
+                if (!this.cdp) return;
+                try {
+                    const extId = this.extensionId;
+                    this.onProtocolEvent(async (message)=>{
+                        try {
+                            if (!message || !message.method) return;
+                            if ('Target.attachedToTarget' === message.method) {
+                                const params = message.params || {};
+                                const targetInfo = params.targetInfo || {
+                                    url: '',
+                                    type: ''
+                                };
+                                const sessionId = params.sessionId;
+                                const url = String(targetInfo.url || '');
+                                const type = String(targetInfo.type || '');
+                                const matchesExtension = !!(this.extensionId && url.includes(`chrome-extension://${this.extensionId}/`) || extId && url.includes(`chrome-extension://${extId}/`) || 'service_worker' === type);
+                                if (sessionId && matchesExtension) {
+                                    await this.cdp.sendCommand('Runtime.enable', {}, sessionId);
+                                    await this.cdp.sendCommand('Log.enable', {}, sessionId);
+                                }
+                            } else if ('Runtime.consoleAPICalled' === message.method || 'Log.entryAdded' === message.method) {
+                                if ('1' === String(process.env.EXTENSION_VERBOSE || '').trim()) {
+                                    const ts = new Date().toISOString();
+                                    console.log(messages.bvI(ts, message.params));
+                                }
+                            }
+                        } catch  {}
+                    });
+                } catch (e) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn('[CDP] enableLogging failed:', String(e));
+                }
+            }
+            async getInfoBestEffort() {
+                try {
+                    if (!this.cdp) return null;
+                    if (!this.extensionId) this.extensionId = await this.deriveExtensionIdFromTargets(6, 150);
+                    if (this.extensionId) {
+                        const belongsToOutPath = this.extensionIdBelongsToOutPath(this.extensionId);
+                        if (false === belongsToOutPath) this.extensionId = await this.deriveExtensionIdFromTargets(10, 150);
+                    }
+                    if (!this.extensionId) return null;
+                    let name;
+                    let version;
+                    try {
+                        const info = await this.cdp.getExtensionInfo(this.extensionId);
+                        name = info?.extensionInfo?.name;
+                        version = info?.extensionInfo?.version;
+                    } catch  {
+                        try {
+                            const manifest = JSON.parse(external_fs_.readFileSync(external_path_.join(this.outPath, 'manifest.json'), 'utf-8'));
+                            name = manifest?.name;
+                            version = manifest?.version;
+                        } catch  {}
+                    }
+                    return {
+                        extensionId: this.extensionId,
+                        name,
+                        version
+                    };
+                } catch (error) {
+                    return null;
+                }
+            }
+            async reinjectContentScriptRule(sessionId, rule, allowCoarseCleanup, sourceOverridesByBundleId) {
+                if (!this.cdp) return false;
+                const bundleId = (0, content_script_contracts.Y)(rule.index);
+                const bundlePath = (0, content_script_targets.nG)(this.outPath, rule.index, 'js');
+                if (!bundlePath || !external_fs_.existsSync(bundlePath)) return false;
+                const sourceOverride = sourceOverridesByBundleId && 'object' == typeof sourceOverridesByBundleId ? sourceOverridesByBundleId[bundleId] : void 0;
+                const source = this.patchReinjectSourceForInvalidatedRuntime('string' == typeof sourceOverride ? sourceOverride : external_fs_.readFileSync(bundlePath, 'utf-8'));
+                const buildTokenMatch = source.match(/__EXTENSIONJS_REINJECT_BUILD_TOKEN\s*=\s*"([^"]+)"/);
+                const proofMatch = source.match(/extjs-chromium-live-content-css-modules:script-primary-\d+/) || source.match(/Live Update Proof [A-Za-z0-9_-]+/);
+                if (!source.trim()) return false;
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[CDP] reinject bundle ${bundleId} from ${bundlePath}${proofMatch ? ` (${proofMatch[0]})` : ''} build=${buildTokenMatch?.[1] || '<none>'} sourceOverride=${'string' == typeof sourceOverride}`);
+                const contextId = await this.resolveExecutionContextId(sessionId, rule);
+                if (!contextId) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(`[CDP] No execution context found for ${bundleId} (${rule.world})`);
+                    return false;
+                }
+                const result = await this.cdp.evaluateInContext(sessionId, this.buildReinjectExpression(bundleId, source, allowCoarseCleanup), contextId);
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[CDP] reinject result ${bundleId}: ${JSON.stringify(result)}`);
+                if (result && 'object' == typeof result && 'ok' in result) return false !== result.ok;
+                return true;
+            }
+            buildReinjectExpression(bundleId, source, allowCoarseCleanup) {
+                const annotatedSource = `${source}\n//# sourceURL=extension.js-reinject://${bundleId}.js`;
+                const extensionBase = this.extensionId ? `chrome-extension://${this.extensionId}/` : '';
+                return `(() => {
+  const bundleId = ${JSON.stringify(bundleId)};
+  const source = ${JSON.stringify(annotatedSource)};
+  const extensionBase = ${JSON.stringify(extensionBase)};
+  const rootSelector = '[data-extension-root], #extension-root';
+  const keyedSelector = '[data-extjs-reinject-key="${bundleId}"]';
+  const registry = (typeof globalThis === 'object' && globalThis)
+    ? (globalThis.__EXTENSIONJS_DEV_REINJECT__ || (globalThis.__EXTENSIONJS_DEV_REINJECT__ = {}))
+    : {};
+  const existing = registry[bundleId];
+  const readGeneration = (entry) => {
+    try {
+      if (!entry) return 0;
+      if (typeof entry === 'function' && typeof entry.__extjsGeneration === 'number') {
+        return entry.__extjsGeneration;
+      }
+      if (typeof entry === 'object') {
+        if (typeof entry.__extjsGeneration === 'number') return entry.__extjsGeneration;
+        if (typeof entry.generation === 'number') return entry.generation;
+        if (typeof entry.cleanup === 'function' && typeof entry.cleanup.__extjsGeneration === 'number') {
+          return entry.cleanup.__extjsGeneration;
+        }
+      }
+    } catch (error) {}
+    return 0;
+  };
+  const previousGeneration = readGeneration(existing);
+  try {
+    if (typeof existing === 'function') existing();
+    if (existing && typeof existing.cleanup === 'function') existing.cleanup();
+  } catch (error) {}
+  if (${allowCoarseCleanup ? 'true' : 'false'}) {
+    try {
+      const staleRoots = Array.from(document.querySelectorAll(rootSelector));
+      for (const root of staleRoots) {
+        if (root && typeof root.remove === 'function') root.remove();
+      }
+    } catch (error) {}
+  }
+  const trackedNodes = new Set();
+  const trackNode = (node) => {
+    try {
+      if (!node || typeof Element !== 'function' || !(node instanceof Element)) return;
+      const matchesRoot = typeof node.matches === 'function' && node.matches(rootSelector);
+      if (!matchesRoot) return;
+      trackedNodes.add(node);
+      if (typeof node.setAttribute === 'function') {
+        node.setAttribute('data-extjs-reinject-key', bundleId);
+      }
+    } catch (error) {}
+  };
+  const trackTree = (node) => {
+    trackNode(node);
+    try {
+      if (!node || typeof node.querySelectorAll !== 'function') return;
+      const nested = node.querySelectorAll(rootSelector);
+      for (const nestedNode of nested) trackNode(nestedNode);
+    } catch (error) {}
+  };
+  const observer = typeof MutationObserver === 'function'
+    ? new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+          const addedNodes = Array.from(mutation.addedNodes || []);
+          for (const addedNode of addedNodes) {
+            trackTree(addedNode);
+          }
+        }
+      })
+    : null;
+  try {
+    if (observer && document && document.documentElement) {
+      observer.observe(document.documentElement, {childList: true, subtree: true});
+    }
+  } catch (error) {}
+  const cleanupTrackedNodes = () => {
+    try {
+      if (observer) observer.disconnect();
+    } catch (error) {}
+    try {
+      const keyedNodes = Array.from(document.querySelectorAll(keyedSelector));
+      for (const keyedNode of keyedNodes) {
+        if (keyedNode && typeof keyedNode.remove === 'function') keyedNode.remove();
+      }
+    } catch (error) {}
+    try {
+      for (const trackedNode of trackedNodes) {
+        if (trackedNode && trackedNode.isConnected && typeof trackedNode.remove === 'function') {
+          trackedNode.remove();
+        }
+      }
+    } catch (error) {}
+  };
+  registry[bundleId] = {
+    cleanup: cleanupTrackedNodes,
+    generation: previousGeneration,
+    __extjsGeneration: previousGeneration
+  };
+  try {
+    if (typeof globalThis === 'object' && globalThis && extensionBase) {
+      globalThis.__EXTJS_EXTENSION_BASE__ = extensionBase;
+    }
+    if (typeof document === 'object' && document && document.documentElement && extensionBase) {
+      document.documentElement.setAttribute('data-extjs-extension-base', extensionBase);
+    }
+    (0, eval)(source);
+  } catch (error) {
+    return {
+      ok: false,
+      error: String((error && error.stack) || (error && error.message) || error || 'unknown'),
+      trackedRoots: trackedNodes.size,
+      existingRootCount: (() => {
+        try { return document.querySelectorAll(rootSelector).length; } catch (innerError) { return -1; }
+      })()
+    };
+  }
+  setTimeout(() => {
+    try {
+      const keyedNodes = Array.from(document.querySelectorAll(keyedSelector));
+      for (const keyedNode of keyedNodes) trackedNodes.add(keyedNode);
+    } catch (error) {}
+  }, 0);
+  setTimeout(() => {
+    try {
+      if (observer) observer.disconnect();
+    } catch (error) {}
+  }, 2000);
+  return {
+    ok: true,
+    trackedRoots: trackedNodes.size,
+    existingRootCount: (() => {
+      try { return document.querySelectorAll(rootSelector).length; } catch (innerError) { return -1; }
+    })(),
+    liveRoots: (() => {
+      try {
+        return Array.from(document.querySelectorAll(rootSelector)).map((node) => ({
+          key: node && typeof node.getAttribute === 'function' ? node.getAttribute('data-extjs-reinject-key') || null : null,
+          root: node && typeof node.getAttribute === 'function' ? node.getAttribute('data-extension-root') || null : null,
+          build: node && typeof node.getAttribute === 'function' ? node.getAttribute('data-extjs-reinject-build') || null : null,
+          text: String(node && node.textContent || '').slice(0, 120)
+        }));
+      } catch (error) {
+        return [];
+      }
+    })(),
+    hasChromeRuntime: (() => {
+      try { return !!(globalThis && globalThis.chrome && globalThis.chrome.runtime); } catch (error) { return false; }
+    })()
+  };
+})()`;
+            }
+            patchReinjectSourceForInvalidatedRuntime(source) {
+                return source.replace('__webpack_require__.p = __webpack_require__.webExtRt.runtime.getURL("/");', 'try {\n  __webpack_require__.p = __webpack_require__.webExtRt.runtime.getURL("/");\n} catch (_extjsRuntimeError) {\n  if (__extjsBase) {\n    __webpack_require__.p = __extjsBase.replace(/\\/+$/, "/") + String("/").replace(/^\\/+/, "");\n  } else {\n    __webpack_require__.p = "";\n  }\n}');
+            }
+            async resolveExecutionContextId(sessionId, rule) {
+                if (!this.cdp) return;
+                const frameId = await this.getTopFrameId(sessionId);
+                const contexts = await this.collectExecutionContexts(sessionId);
+                if ('main' === rule.world) {
+                    const defaultContext = contexts.find((context)=>{
+                        const auxData = context?.auxData || {};
+                        return 'default' === auxData.type && true === auxData.isDefault && (!frameId || !auxData.frameId || String(auxData.frameId) === frameId);
+                    });
+                    return 'number' == typeof defaultContext?.id ? defaultContext.id : void 0;
+                }
+                const extensionId = this.extensionId || await this.deriveExtensionIdFromTargets();
+                if (!extensionId) return;
+                const extensionOrigin = `chrome-extension://${extensionId}`;
+                const isolatedContext = contexts.find((context)=>{
+                    const auxData = context?.auxData || {};
+                    return 'isolated' === auxData.type && String(context?.origin || '') === extensionOrigin && (!frameId || !auxData.frameId || String(auxData.frameId) === frameId);
+                });
+                return 'number' == typeof isolatedContext?.id ? isolatedContext.id : void 0;
+            }
+            async getTopFrameId(sessionId) {
+                if (!this.cdp) return;
+                try {
+                    const frameTree = await this.cdp.sendCommand('Page.getFrameTree', {}, sessionId);
+                    const frameId = frameTree?.frameTree?.frame?.id;
+                    return 'string' == typeof frameId && frameId ? frameId : void 0;
+                } catch  {
+                    return;
+                }
+            }
+            async collectExecutionContexts(sessionId) {
+                if (!this.cdp) return [];
+                const contextsById = new Map();
+                const unsubscribe = this.cdp.onProtocolEvent((message)=>{
+                    if (String(message.sessionId || '') !== sessionId) return;
+                    if ('Runtime.executionContextCreated' !== String(message.method || '')) return;
+                    const context = message.params?.context;
+                    const contextId = context?.id;
+                    if ('number' == typeof contextId) contextsById.set(contextId, context);
+                });
+                try {
+                    await this.cdp.sendCommand('Runtime.enable', {}, sessionId);
+                    await new Promise((resolve)=>setTimeout(resolve, 100));
+                } finally{
+                    unsubscribe();
+                }
+                return Array.from(contextsById.values());
+            }
+            constructor(args){
+                cdp_extension_controller_define_property(this, "outPath", void 0);
+                cdp_extension_controller_define_property(this, "browser", void 0);
+                cdp_extension_controller_define_property(this, "cdpPort", void 0);
+                cdp_extension_controller_define_property(this, "profilePath", void 0);
+                cdp_extension_controller_define_property(this, "extensionPaths", void 0);
+                cdp_extension_controller_define_property(this, "cdp", null);
+                cdp_extension_controller_define_property(this, "extensionId", null);
+                cdp_extension_controller_define_property(this, "lastRuntimeReinjectionReport", null);
+                this.outPath = args.outPath;
+                this.browser = args.browser;
+                this.cdpPort = args.cdpPort;
+                this.profilePath = args.profilePath;
+                this.extensionPaths = args.extensionPaths;
+            }
+        }
+        var extension_output_path = __webpack_require__("../browser/run-chromium/chromium-launch/extension-output-path.ts");
+        async function setupCdpAfterLaunch(compilation, plugin, chromiumArgs) {
+            const loadExtensionFlag = chromiumArgs.find((flag)=>flag.startsWith('--load-extension='));
+            const extensionOutputPath = (0, extension_output_path.W)(compilation, loadExtensionFlag);
+            const extensionPaths = loadExtensionFlag ? loadExtensionFlag.replace('--load-extension=', '').split(',').map((s)=>s.trim()).filter(Boolean) : [];
+            const selectedExtensionPaths = extensionOutputPath && extensionOutputPath.length > 0 ? [
+                extensionOutputPath
+            ] : extensionPaths;
+            const remoteDebugPortFlag = chromiumArgs.find((flag)=>flag.startsWith('--remote-debugging-port='));
+            const chromeRemoteDebugPort = remoteDebugPortFlag ? parseInt(remoteDebugPortFlag.split('=')[1], 10) : (0, shared_utils.jl)(plugin.port, plugin.instanceId);
+            const userDataDirFlag = chromiumArgs.find((flag)=>flag.startsWith('--user-data-dir='));
+            const userDataDir = userDataDirFlag ? userDataDirFlag.replace('--user-data-dir=', '').replace(/^"|"$/g, '') : '';
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
+                if (userDataDir) console.log(messages.aIt(userDataDir));
+                console.log(messages.CYH(chromeRemoteDebugPort, chromeRemoteDebugPort));
+            }
+            const cdpExtensionController = new CDPExtensionController({
+                outPath: extensionOutputPath,
+                browser: 'chromium-based' === plugin.browser ? 'chrome' : plugin.browser,
+                cdpPort: chromeRemoteDebugPort,
+                profilePath: userDataDir || void 0,
+                extensionPaths: selectedExtensionPaths
+            });
+            await cdpExtensionController.connect();
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(messages.M3V('127.0.0.1', chromeRemoteDebugPort));
+            const mode = compilation?.options?.mode || 'development';
+            let earlyBannerPrinted = false;
+            if ('development' === mode) try {
+                earlyBannerPrinted = await (0, banner.ai)({
+                    outPath: extensionOutputPath,
+                    browser: plugin.browser,
+                    hostPort: {
+                        host: '127.0.0.1',
+                        port: chromeRemoteDebugPort
+                    },
+                    getInfo: async ()=>null,
+                    browserVersionLine: plugin.browserVersionLine
+                });
+            } catch  {}
+            if ('development' === mode) try {
+                earlyBannerPrinted = await (0, banner.ai)({
+                    outPath: extensionOutputPath,
+                    browser: plugin.browser,
+                    hostPort: {
+                        host: '127.0.0.1',
+                        port: chromeRemoteDebugPort
+                    },
+                    getInfo: async ()=>cdpExtensionController.getInfoBestEffort(),
+                    browserVersionLine: plugin.browserVersionLine
+                });
+            } catch  {}
+            let extensionControllerInfo = null;
+            try {
+                const ensureLoadedTimeoutMs = 10000;
+                extensionControllerInfo = await Promise.race([
+                    cdpExtensionController.ensureLoaded(),
+                    new Promise((_, reject)=>{
+                        setTimeout(()=>reject(new Error(`ensureLoaded timeout (${ensureLoadedTimeoutMs}ms)`)), ensureLoadedTimeoutMs);
+                    })
+                ]);
+            } catch (error) {
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(`[CDP] ensureLoaded failed: ${String(error?.message || error)}`);
+            }
+            try {
+                if ('development' === mode) {
+                    if (!earlyBannerPrinted) {
+                        const bannerPrinted = await (0, banner.ai)({
+                            outPath: extensionOutputPath,
+                            browser: plugin.browser,
+                            hostPort: {
+                                host: '127.0.0.1',
+                                port: chromeRemoteDebugPort
+                            },
+                            getInfo: async ()=>extensionControllerInfo,
+                            browserVersionLine: plugin.browserVersionLine
+                        });
+                        if (!bannerPrinted) await (0, banner.ai)({
+                            outPath: extensionOutputPath,
+                            browser: plugin.browser,
+                            hostPort: {
+                                host: '127.0.0.1',
+                                port: chromeRemoteDebugPort
+                            },
+                            getInfo: async ()=>cdpExtensionController.getInfoBestEffort(),
+                            browserVersionLine: plugin.browserVersionLine
+                        });
+                    }
+                } else if ('production' === mode) {
+                    const runtime = extensionControllerInfo ? {
+                        extensionId: extensionControllerInfo.extensionId,
+                        name: extensionControllerInfo.name,
+                        version: extensionControllerInfo.version
+                    } : void 0;
+                    await (0, banner.MK)({
+                        browser: plugin.browser,
+                        outPath: extensionOutputPath,
+                        browserVersionLine: plugin.browserVersionLine,
+                        runtime
+                    });
+                }
+            } catch (bannerErr) {
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.$wD(String(bannerErr)));
+                try {
+                    const mode = compilation?.options?.mode || 'development';
+                    if ('production' === mode) await (0, banner.MK)({
+                        browser: plugin.browser,
+                        outPath: extensionOutputPath,
+                        browserVersionLine: plugin.browserVersionLine
+                    });
+                } catch  {}
+            }
+            plugin.cdpController = cdpExtensionController;
+        }
+    }
+};