extension-develop 3.10.3 → 3.11.1

package/dist/323.cjs

@@ -12,6 +12,8 @@ exports.modules = {
         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;
@@ -202,20 +204,6 @@ exports.modules = {
             }
             throw lastError instanceof Error ? lastError : new Error('Failed to bootstrap CDP connection');
         }
-        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 = external_path_.join(outPath, 'manifest.json');
@@ -302,11 +290,7 @@ exports.modules = {
                     };
                 } catch  {}
                 try {
-                    if (!this.extensionId && this.shouldAttemptLoadUnpacked()) {
-                        const id = await loadUnpackedIfNeeded(this.cdp, this.outPath);
-                        if (id) this.extensionId = id;
-                    }
-                    if (!this.extensionId) this.extensionId = await this.deriveExtensionIdFromTargets(10, 150);
+                    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;
@@ -337,12 +321,6 @@ exports.modules = {
                 if (!this.cdp) return null;
                 return await deriveExtensionIdFromTargetsHelper(this.cdp, this.outPath, maxRetries, backoffMs, this.profilePath, this.extensionPaths);
             }
-            shouldAttemptLoadUnpacked() {
-                const normalizedOutPath = this.normalizePath(this.outPath);
-                const normalizedExtensionPaths = (this.extensionPaths || []).map((candidate)=>String(candidate || '').trim()).filter(Boolean).map((candidate)=>this.normalizePath(candidate));
-                if (0 === normalizedExtensionPaths.length) return true;
-                return !normalizedExtensionPaths.includes(normalizedOutPath);
-            }
             normalizePath(input) {
                 try {
                     return external_fs_.realpathSync(external_path_.resolve(input));
@@ -400,6 +378,207 @@ exports.modules = {
                 } 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 {
@@ -413,6 +592,32 @@ exports.modules = {
                     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 {
@@ -449,7 +654,6 @@ exports.modules = {
             }
             clearProtocolEventHandler() {
                 if (!this.cdp) return;
-                this.cdp.onProtocolEvent(()=>{});
             }
             async enableUnifiedLogging() {
                 if (!this.cdp) return;
@@ -538,6 +742,231 @@ exports.modules = {
                     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);
@@ -546,6 +975,7 @@ exports.modules = {
                 _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;

package/dist/324.cjs

@@ -28,6 +28,12 @@ exports.modules = {
             else obj[key] = value;
             return obj;
         }
+        function resolveInstanceIdOverride() {
+            const raw = process.env.EXTENSION_INSTANCE_ID || process.env.EXTENSION_DEV_INSTANCE_ID || process.env.EXTJS_INSTANCE_ID || '';
+            const value = String(raw).trim();
+            if (!value) return;
+            return value.replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 64) || void 0;
+        }
         class PortManager {
             async allocatePorts(_browser, _projectPath, requestedPort) {
                 try {
@@ -35,7 +41,7 @@ exports.modules = {
                     const base = isValidRequested ? requestedPort : this.basePort;
                     const port = await (0, shared_utils.aY)(base);
                     const webSocketPort = await (0, shared_utils.aY)(port + 1);
-                    const instanceId = external_crypto_.randomBytes(8).toString('hex');
+                    const instanceId = resolveInstanceIdOverride() || external_crypto_.randomBytes(8).toString('hex');
                     this.currentInstance = {
                         instanceId,
                         port,
@@ -367,6 +373,10 @@ exports.modules = {
                 hostname: devServerHost,
                 port
             };
+            process.env.EXTENSION_DEV_SERVER_PROTOCOL = devServerWebSocketURL.protocol;
+            process.env.EXTENSION_DEV_SERVER_HOST = devServerHost;
+            process.env.EXTENSION_DEV_SERVER_PORT = String(port);
+            process.env.EXTENSION_DEV_SERVER_PATH = '/ws';
             const safeBrowserConfig = (0, sanitize.a)(browserConfig);
             const safeCommandConfig = (0, sanitize.a)(commandConfig);
             const safeDevOptions = (0, sanitize.a)(devOptions);
@@ -406,6 +416,7 @@ exports.modules = {
                     }
                 }
             };
+            delete compilerConfig.devServer;
             const compiler = (0, core_.rspack)(compilerConfig);
             const manifestOutputPath = external_path_.join(packageJsonDir, 'dist', devOptions.browser, 'manifest.json');
             installManifestDiskWriteGuard(manifestOutputPath);
@@ -454,18 +465,13 @@ exports.modules = {
                         interval: 1000
                     }
                 },
-                client: {
-                    logging: 'none',
-                    progress: false,
-                    overlay: false,
-                    webSocketURL: devServerWebSocketURL
-                },
+                client: false,
                 headers: {
                     'Access-Control-Allow-Origin': '*'
                 },
                 port,
-                hot: 'only',
-                liveReload: true
+                hot: true,
+                liveReload: false
             };
             const devServer = new dev_server_.RspackDevServer(serverConfig, compiler);
             const START_TIMEOUT_MS = parseInt(String(process.env.EXTENSION_START_TIMEOUT_MS || '30000'), 10);