extension-develop 3.12.0 → 3.13.0

package/dist/323.cjs

@@ -1,1100 +0,0 @@
-"use strict";
-exports.ids = [
-    "323"
-];
-exports.modules = {
-    "./webpack/plugin-browsers/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__("./webpack/plugin-browsers/browsers-lib/messages.ts");
-        var shared_utils = __webpack_require__("./webpack/plugin-browsers/browsers-lib/shared-utils.ts");
-        var banner = __webpack_require__("./webpack/plugin-browsers/browsers-lib/banner.ts");
-        var external_path_ = __webpack_require__("path");
-        var external_fs_ = __webpack_require__("fs");
-        var content_script_targets = __webpack_require__("./webpack/plugin-browsers/browsers-lib/content-script-targets.ts");
-        var contracts = __webpack_require__("./webpack/plugin-web-extension/feature-scripts/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)=>p.replace(/[\\\/]+$/g, '');
-            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 cdp_client = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-source-inspection/cdp-client.ts");
-        var discovery = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-source-inspection/discovery.ts");
-        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 (0, discovery.z)(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 cdp_client.n(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 _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) {
-                                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, contracts.Y0)(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){
-                _define_property(this, "outPath", void 0);
-                _define_property(this, "browser", void 0);
-                _define_property(this, "cdpPort", void 0);
-                _define_property(this, "profilePath", void 0);
-                _define_property(this, "extensionPaths", void 0);
-                _define_property(this, "cdp", null);
-                _define_property(this, "extensionId", null);
-                _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__("./webpack/plugin-browsers/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.a)({
-                    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.a)({
-                    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.a)({
-                            outPath: extensionOutputPath,
-                            browser: plugin.browser,
-                            hostPort: {
-                                host: '127.0.0.1',
-                                port: chromeRemoteDebugPort
-                            },
-                            getInfo: async ()=>extensionControllerInfo,
-                            browserVersionLine: plugin.browserVersionLine
-                        });
-                        if (!bannerPrinted) await (0, banner.a)({
-                            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.M)({
-                        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.M)({
-                        browser: plugin.browser,
-                        outPath: extensionOutputPath,
-                        browserVersionLine: plugin.browserVersionLine
-                    });
-                } catch  {}
-            }
-            plugin.cdpController = cdpExtensionController;
-        }
-    }
-};