extension 4.0.1 → 4.0.2-canary.local-d776e4d9

package/dist/{315.cjs → 876.cjs}

@@ -1,8 +1,42 @@
 "use strict";
 exports.ids = [
-    315
+    876
 ];
 exports.modules = {
+    "./browsers/run-chromium/cdp/cdp-extension-controller/ensure.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        var fs__rspack_import_0 = __webpack_require__("fs");
+        var path__rspack_import_1 = __webpack_require__("path");
+        async function loadUnpackedIfNeeded(cdp, outPath) {
+            try {
+                const response = await cdp.sendCommand('Extensions.loadUnpacked', {
+                    extensionPath: outPath,
+                    options: {
+                        failOnError: false
+                    }
+                });
+                const id = String(response?.extensionId || '');
+                return id || null;
+            } catch  {
+                return null;
+            }
+        }
+        function readManifestInfo(outPath) {
+            try {
+                const manifestPath = path__rspack_import_1.join(outPath, 'manifest.json');
+                const manifest = JSON.parse(fs__rspack_import_0.readFileSync(manifestPath, 'utf-8'));
+                return {
+                    name: manifest?.name,
+                    version: manifest?.version
+                };
+            } catch  {
+                return null;
+            }
+        }
+        __webpack_require__.d(__webpack_exports__, {
+            M: ()=>readManifestInfo,
+            loadUnpackedIfNeeded: ()=>loadUnpackedIfNeeded
+        });
+    },
     "./browsers/run-chromium/chromium-launch/setup-cdp-after-launch.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             setupCdpAfterLaunch: ()=>setupCdpAfterLaunch
@@ -15,475 +49,29 @@ exports.modules = {
         var external_ws_ = __webpack_require__("ws");
         var external_ws_default = /*#__PURE__*/ __webpack_require__.n(external_ws_);
         var constants = __webpack_require__("./browsers/browsers-lib/constants.ts");
-        var discovery = __webpack_require__("./browsers/run-chromium/chromium-source-inspection/discovery.ts");
+        var discovery = __webpack_require__("./browsers/run-chromium/cdp/discovery.ts");
         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 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(page && 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(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(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 (external_ws_default())(url);
                 ws.on('open', ()=>{
-                    if (isDev) console.log(messages.F1E());
+                    if (isDev) console.log(messages.F1());
                     resolve(ws);
                 });
                 ws.on('message', (data)=>{
                     onMessage(data.toString());
                 });
                 ws.on('error', (error)=>{
-                    if (isDev) console.error(messages.fRy(error.message));
+                    if (isDev) console.error(messages.fR(error.message));
                     onRejectPending(error.message);
                     reject(error);
                 });
                 ws.on('close', ()=>{
-                    if (isDev) console.log(messages.hE8());
+                    if (isDev) console.log(messages.hE());
                     onRejectPending('CDP connection closed');
                     reject(new Error('CDP WebSocket closed before the connection opened'));
                 });
@@ -528,7 +116,7 @@ exports.modules = {
                                 } catch (error) {
                                     if (this.isDev()) {
                                         const err = error;
-                                        console.warn(messages.r0s(String(err.message || err)));
+                                        console.warn(messages.r0(String(err.message || err)));
                                     }
                                 }
                                 if (timeout) clearTimeout(timeout);
@@ -538,7 +126,7 @@ exports.modules = {
                         });
                         this.transport = 'websocket';
                         this.startHeartbeat();
-                        if (this.isDev()) console.log(messages.M3V(this.host, this.port));
+                        if (this.isDev()) console.log(messages.M3(this.host, this.port));
                         resolve();
                     } catch (error) {
                         const err = error;
@@ -573,7 +161,7 @@ exports.modules = {
                     this.pipeIn = null;
                 });
                 this.startHeartbeat();
-                if (this.isDev()) console.log(messages.M3V(this.host, this.port));
+                if (this.isDev()) console.log(messages.M3(this.host, this.port));
             }
             rejectAllPending(reason) {
                 this.pendingRequests.forEach(({ reject, timeout }, id)=>{
@@ -645,13 +233,13 @@ exports.modules = {
                     }
                     if ('Target.attachedToTarget' === message.method) {
                         const params = message.params || {};
-                        if (this.isDev()) console.log(messages.p8m(String(params.sessionId || ''), String(params.targetInfo?.type || '')));
+                        if (this.isDev()) console.log(messages.p8(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)));
+                        console.warn(messages.xx(String(err.message || err)));
                     }
                 }
             }
@@ -715,40 +303,6 @@ exports.modules = {
                 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,
@@ -757,150 +311,11 @@ exports.modules = {
                 }, 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 getClosedShadowRoots(sessionId, maxBytes = 65536) {
-                await this.sendCommand('DOM.enable', {}, sessionId);
-                const doc = await this.sendCommand('DOM.getDocument', {
-                    depth: -1,
-                    pierce: true
-                }, sessionId);
-                const found = [];
-                const walk = (node, hostName)=>{
-                    if (!node || 'object' != typeof node) return;
-                    const name = node.localName || node.nodeName || hostName;
-                    if (Array.isArray(node.shadowRoots)) for (const sr of node.shadowRoots){
-                        if (sr && 'closed' === sr.shadowRootType && 'number' == typeof sr.nodeId) found.push({
-                            nodeId: sr.nodeId,
-                            host: String(name)
-                        });
-                        walk(sr, name);
-                    }
-                    if (Array.isArray(node.children)) for (const c of node.children)walk(c, name);
-                    if (node.contentDocument) walk(node.contentDocument, name);
-                };
-                walk(doc.root, 'html');
-                const out = [];
-                for (const f of found)try {
-                    const oh = await this.sendCommand('DOM.getOuterHTML', {
-                        nodeId: f.nodeId
-                    }, sessionId);
-                    let html = String(oh?.outerHTML ?? '');
-                    let truncated = false;
-                    if (maxBytes > 0 && html.length > maxBytes) {
-                        html = html.slice(0, maxBytes);
-                        truncated = true;
-                    }
-                    out.push({
-                        host: f.host,
-                        type: 'closed',
-                        html,
-                        ...truncated ? {
-                            truncated
-                        } : {}
-                    });
-                } catch  {
-                    out.push({
-                        host: f.host,
-                        type: 'closed',
-                        html: ''
-                    });
-                }
-                return out;
-            }
-            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) continue;
-                            let sessionId;
-                            try {
-                                sessionId = await this.attachToTarget(targetId);
-                            } catch  {
-                                continue;
-                            }
-                            try {
-                                await this.sendCommand('Runtime.enable', {}, sessionId);
-                            } catch  {
-                                return true;
-                            }
-                            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).catch(()=>{});
-                            return true;
-                        }
-                    }
-                    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;
+                    throw new Error(messages.Z5(extensionId, error.message));
                 }
             }
             constructor(port = 9222, host = '127.0.0.1'){
@@ -1136,7 +551,7 @@ exports.modules = {
             }
             return deriveFromProfile() || deferredFirstEvalId || deferredUrlDerivedId;
         }
-        var ensure = __webpack_require__("./browsers/run-chromium/chromium-source-inspection/cdp-extension-controller/ensure.ts");
+        var ensure = __webpack_require__("./browsers/run-chromium/cdp/cdp-extension-controller/ensure.ts");
         function registerAutoEnableLogging(cdp, getExtensionId) {
             cdp.onProtocolEvent((message)=>{
                 try {
@@ -1156,11 +571,11 @@ exports.modules = {
                     } 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));
+                            console.log(messages.bv(ts, message.params));
                         }
                     }
                 } catch (error) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.KK1(String(error?.message || error)));
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.KK(String(error?.message || error)));
                 }
             });
         }
@@ -1232,7 +647,7 @@ exports.modules = {
                 const exists = external_fs_.existsSync(this.outPath);
                 if (!exists) throw new Error(`Output path not found: ${this.outPath}`);
                 if (!this.extensionId) try {
-                    const { loadUnpackedIfNeeded } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./browsers/run-chromium/chromium-source-inspection/cdp-extension-controller/ensure.ts"));
+                    const { loadUnpackedIfNeeded } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./browsers/run-chromium/cdp/cdp-extension-controller/ensure.ts"));
                     const cdpId = await loadUnpackedIfNeeded(this.cdp, this.outPath);
                     if (cdpId) this.extensionId = cdpId;
                 } catch  {}
@@ -1312,32 +727,6 @@ exports.modules = {
             classifyOwnership(extensionId) {
                 return classifyExtensionOwnership(this.profilePath, this.outPath, extensionId);
             }
-            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';
-            }
             async connectFreshClient() {
                 if (this.pipeIn && this.pipeOut && !this.pipeIn.destroyed) this.cdp = await connectToChromeCdpViaPipe(this.pipeIn, this.pipeOut, this.cdpPort);
                 else this.cdp = await connectToChromeCdp(this.cdpPort);
@@ -1352,7 +741,7 @@ exports.modules = {
                         filter: EXTENSION_AUTO_ATTACH_FILTER
                     });
                 } catch (error) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.wXK(String(error?.message || error)));
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.wX(String(error?.message || error)));
                 }
                 registerAutoEnableLogging(this.cdp, ()=>this.extensionId);
             }
@@ -1362,9 +751,6 @@ exports.modules = {
                     cb(message);
                 });
             }
-            clearProtocolEventHandler() {
-                if (!this.cdp) return;
-            }
             async enableUnifiedLogging() {
                 if (!this.cdp) return;
                 try {
@@ -1408,7 +794,7 @@ exports.modules = {
                             } 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));
+                                    console.log(messages.bv(ts, message.params));
                                 }
                             }
                         } catch  {}
@@ -1482,8 +868,8 @@ exports.modules = {
             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));
+                if (userDataDir) console.log(messages.aI(userDataDir));
+                console.log(messages.CY(chromeRemoteDebugPort, chromeRemoteDebugPort));
             }
             const cdpExtensionController = new CDPExtensionController({
                 outPath: extensionOutputPath,
@@ -1495,7 +881,7 @@ exports.modules = {
                 pipeOut: pipeStreams?.output
             });
             await cdpExtensionController.connect();
-            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(messages.M3V('127.0.0.1', chromeRemoteDebugPort));
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(messages.M3('127.0.0.1', chromeRemoteDebugPort));
             try {
                 if (extensionOutputPath && Number.isFinite(chromeRemoteDebugPort)) {
                     const readyPath = external_path_.join(external_path_.dirname(extensionOutputPath), 'extension-js', external_path_.basename(extensionOutputPath), 'ready.json');
@@ -1584,7 +970,7 @@ exports.modules = {
                     });
                 }
             } catch (bannerErr) {
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.$wD(String(bannerErr)));
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.$w(String(bannerErr)));
                 try {
                     const mode = compilation?.options?.mode || 'development';
                     if ('production' === mode) await (0, banner.MK)({
@@ -1596,39 +982,5 @@ exports.modules = {
             }
             plugin.cdpController = cdpExtensionController;
         }
-    },
-    "./browsers/run-chromium/chromium-source-inspection/cdp-extension-controller/ensure.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        async function loadUnpackedIfNeeded(cdp, outPath) {
-            try {
-                const response = await cdp.sendCommand('Extensions.loadUnpacked', {
-                    extensionPath: outPath,
-                    options: {
-                        failOnError: false
-                    }
-                });
-                const id = String(response?.extensionId || '');
-                return id || null;
-            } catch  {
-                return null;
-            }
-        }
-        function readManifestInfo(outPath) {
-            try {
-                const manifestPath = path__rspack_import_1.join(outPath, 'manifest.json');
-                const manifest = JSON.parse(fs__rspack_import_0.readFileSync(manifestPath, 'utf-8'));
-                return {
-                    name: manifest?.name,
-                    version: manifest?.version
-                };
-            } catch  {
-                return null;
-            }
-        }
-        __webpack_require__.d(__webpack_exports__, {
-            M: ()=>readManifestInfo,
-            loadUnpackedIfNeeded: ()=>loadUnpackedIfNeeded
-        });
     }
 };