extension-develop 4.0.11 → 4.0.12

package/dist/839.mjs

@@ -4,10 +4,11 @@ import { execFileSync, spawn, spawnSync as external_child_process_spawnSync } fr
 import { buildExecEnv, detectPackageManagerFromLockfile } from "prefers-yarn";
 import pintor from "pintor";
 import { EventEmitter } from "node:events";
-import { package_namespaceObject, buildSuccessWithWarnings, buildWarningsDetails, loadCommandConfig, needsInstall, getDirs, buildCommandFailed, getSpecialFoldersDataForProjectRoot, writingTypeDefinitions, sanitize, projectInstallFallbackToNpm, buildWebpack, assertNoManagedDependencyConflicts, debugDirs, debugBrowser, normalizeBrowser, debugOutputPath, loadCustomConfig, buildSuccess, devCommandFailed, writingTypeDefinitionsError, getDistPath, loadBrowserConfig, projectInstallScriptsDisabled, authorInstallNotice, getProjectStructure, resolveCompanionExtensionsConfig } from "./101.mjs";
+import { Compilation as core_Compilation, WebpackError as core_WebpackError, sources as core_sources } from "@rspack/core";
+import { package_namespaceObject, buildWarningsDetails, sanitize, getDirs, projectInstallFallbackToNpm, assertNoManagedDependencyConflicts, debugDirs, buildSuccess, writingTypeDefinitionsError, projectInstallScriptsDisabled, authorInstallNotice, getSpecialFoldersDataForProjectRoot, buildSuccessWithWarnings, loadCommandConfig, needsInstall, buildCommandFailed, writingTypeDefinitions, constants_isGeckoBasedBrowser, buildWebpack, debugBrowser, normalizeBrowser, debugOutputPath, loadCustomConfig, isChromiumBasedBrowser, devCommandFailed, getDistPath, loadBrowserConfig, getProjectStructure, resolveCompanionExtensionsConfig } from "./101.mjs";
 import { stripBom, parseJsonSafe } from "./23.mjs";
 import { hasProjectDependency, findNearestProjectManifestDirSync } from "./80.mjs";
-import { getCanonicalContentScriptEntryName } from "./291.mjs";
+import { getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName } from "./291.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
@@ -1227,6 +1228,7 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
             extensions: resolvedExtensionsConfig,
             browser,
             mode: resolvedMode,
+            metadataCommand: buildOptions?.metadataCommand || 'build',
             output: {
                 clean: true,
                 path: distPath
@@ -1299,48 +1301,3077 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
         process.exit(1);
     }
 }
-function viaBroker(broker, instruction) {
-    return broker.broadcastReload({
-        type: instruction.type,
-        changedContentScriptEntries: instruction.changedContentScriptEntries,
-        label: instruction.label,
-        changedFiles: instruction.changedAssets
+function TemplateFn(compilation, Template) {
+    return {
+        f: (args, body)=>{
+            if (!compilation) throw new TypeError('No compilation is found.');
+            if (compilation.runtimeTemplate) return compilation.runtimeTemplate.basicFunction(args, body);
+            return compilation.outputOptions.environment.arrowFunction ? `(${args}) => {\n${Template.indent(body)}\n}` : `function(${args}) {\n${Template.indent(body)}\n}`;
+        },
+        retF: (returnValue, args = '')=>{
+            if (!compilation) throw new TypeError('No compilation is found.');
+            if (compilation.runtimeTemplate) return compilation.runtimeTemplate.returningFunction(returnValue, args);
+            return compilation.outputOptions.environment.arrowFunction ? `(${args}) => (${returnValue})` : `function(${args}) { return ${returnValue}; }`;
+        }
+    };
+}
+const RuntimeGlobal = '__webpack_require__.webExtRt';
+const RuntimeGlobalIsBrowser = '__webpack_require__.webExtRtModern';
+function BrowserRuntimeModule(webpack, acceptWeak) {
+    const { RuntimeModule, Template } = webpack;
+    class BrowserRuntime extends RuntimeModule {
+        constructor(){
+            super('WebExtensionBrowserRuntime', RuntimeModule.STAGE_NORMAL);
+        }
+        generate() {
+            const { compilation } = this;
+            if (!compilation) return Template.asString('/* [webpack-target-webextension] BrowserRuntimeModule skipped because no compilation is found. */');
+            const optionalChaining = compilation.outputOptions.environment.optionalChaining;
+            const _let = compilation.outputOptions.environment.const ? 'let' : 'var';
+            return Template.asString([
+                `${_let} isChrome, runtime;`,
+                'try {',
+                Template.indent([
+                    `if (typeof globalThis === "object" && globalThis && typeof globalThis.browser !== "undefined" && ${optionalChaining ? 'typeof globalThis.browser.runtime?.getURL === "function"' : 'typeof globalThis.browser.runtime === "object" && typeof globalThis.browser.runtime.getURL === "function"'}) {`,
+                    Template.indent([
+                        'runtime = globalThis.browser;'
+                    ]),
+                    '}'
+                ]),
+                '} catch (_) {}',
+                'if (!runtime) {',
+                Template.indent([
+                    'try {',
+                    Template.indent([
+                        `if (typeof globalThis === "object" && globalThis && typeof globalThis.chrome !== "undefined" && ${optionalChaining ? 'typeof globalThis.chrome.runtime?.getURL === "function"' : 'typeof globalThis.chrome.runtime === "object" && typeof globalThis.chrome.runtime.getURL === "function"'}) {`,
+                        Template.indent([
+                            'isChrome = true;',
+                            'runtime = globalThis.chrome;'
+                        ]),
+                        '}'
+                    ]),
+                    '} catch (_) {}'
+                ]),
+                '}',
+                `${RuntimeGlobalIsBrowser} = !isChrome;`,
+                `${RuntimeGlobal} = runtime || { runtime: null };`,
+                acceptWeak ? 'if (!runtime && (typeof self !== "object" || !self.addEventListener)) {' : '',
+                acceptWeak ? Template.indent([
+                    `${RuntimeGlobal} = { runtime: { getURL: String } };`
+                ]) : '',
+                acceptWeak ? '}' : ''
+            ].filter(Boolean));
+        }
+    }
+    return new BrowserRuntime();
+}
+const DYNAMIC_IMPORT_LOADER = 'dynamicImportLoader';
+const DOM_LOADER = "scriptLoader";
+const WORKER_LOADER = 'workerLoader';
+const CLASSIC_LOADER = 'classicLoader';
+const MAIN_CLASSIC_LOADER = 'classicLoaderMainWorld';
+const FALLBACK_LOADER = 'fallbackLoader';
+function LoadScriptRuntimeModule(webpack, supportDynamicImport, classicLoaderEnabled, contentScriptsMeta) {
+    const { Template, RuntimeGlobals, RuntimeModule } = webpack;
+    class LoadScriptRuntime extends RuntimeModule {
+        supportDynamicImport;
+        classicLoaderEnabled;
+        contentScriptsMeta;
+        constructor(){
+            super("load script", RuntimeModule.STAGE_BASIC);
+            this.supportDynamicImport = Boolean(supportDynamicImport);
+            this.classicLoaderEnabled = Boolean(classicLoaderEnabled);
+            this.contentScriptsMeta = contentScriptsMeta || {};
+        }
+        generate() {
+            const { compilation } = this;
+            if (!compilation) return Template.asString('/* [webpack-target-webextension] ChunkLoaderFallbackRuntimeModule skipped because no compilation is found. */');
+            const { f } = TemplateFn(compilation, Template);
+            const _const = compilation.outputOptions.environment.const ? 'const' : 'var';
+            const _let = compilation.outputOptions.environment.const ? 'let' : 'var';
+            const chunkName = (this.chunk && this.chunk.name ? this.chunk.name : '') || (compilation && compilation.chunk && compilation.chunk.name ? compilation.chunk.name : '');
+            const bundleId = chunkName ? `${chunkName}.js` : '';
+            const world = bundleId && this.contentScriptsMeta[bundleId] ? this.contentScriptsMeta[bundleId].world : void 0;
+            const isMainWorld = 'main' === world;
+            const HasExtensionRuntime = `${_const} hasExtensionRuntime = (function(){ try {return ((typeof globalThis === "object" && globalThis && globalThis.browser && globalThis.browser.runtime && typeof globalThis.browser.runtime.sendMessage === "function") || (typeof globalThis === "object" && globalThis && globalThis.chrome && globalThis.chrome.runtime && typeof globalThis.chrome.runtime.sendMessage === "function"));} catch (e) { return false; } })();`;
+            const DynamicImportLoader = `${_const} ${DYNAMIC_IMPORT_LOADER} = ` + f('url, done, key, chunkId', `import(url).then(${f('', [
+                'if (isNotIframe) return done();',
+                'try {',
+                Template.indent([
+                    "// It's a Chrome bug, if the import() is called in a sandboxed iframe, it _fails_ the script loading but _resolve_ the Promise.",
+                    `// we call ${RuntimeGlobals.ensureChunkHandlers}.j(chunkId) to check if it is loaded.`,
+                    '// if it is, this is a no-op. if it is not, it will throw a TypeError because this function requires 2 parameters.',
+                    '// This call will not trigger the chunk loading because it is already loading.',
+                    '// see https://github.com/awesome-webextension/webpack-target-webextension/issues/41',
+                    `chunkId !== undefined && ${RuntimeGlobals.ensureChunkHandlers}.j(chunkId);`,
+                    'done();'
+                ]),
+                '}',
+                'catch (_) {',
+                Template.indent([
+                    'if (!bug816121warned) {',
+                    Template.indent([
+                        'console.warn("Chrome bug https://crbug.com/816121 hit.");',
+                        'bug816121warned = true;'
+                    ]),
+                    '}',
+                    `return ${FALLBACK_LOADER}(url, done, key, chunkId);`
+                ]),
+                '}'
+            ])}, ${f('e', [
+                'console.warn("Dynamic import loader failed. Using fallback loader (see https://github.com/awesome-webextension/webpack-target-webextension#content-script).", e);',
+                `${FALLBACK_LOADER}(url, done, key, chunkId);`
+            ])});`);
+            const DOMLoader = `${_const} ${DOM_LOADER} = ` + f('url, done', [
+                `${_const} script = document.createElement('script');`,
+                "script.src = url;",
+                "script.onload = done;",
+                "script.onerror = done;",
+                "document.body.appendChild(script);"
+            ]);
+            const WorkerLoader = `${_const} ${WORKER_LOADER} = ` + f('url, done', [
+                'try {',
+                Template.indent([
+                    'importScripts(url);',
+                    'done();'
+                ]),
+                '} catch (e) {',
+                Template.indent([
+                    'done(e);'
+                ]),
+                '}'
+            ]);
+            const ClassicLoader = `${_const} ${CLASSIC_LOADER} = ` + f('url, done', Template.asString([
+                `${_const} msg = { type: "WTW_INJECT", file: url };`,
+                `${_const} onError = ${f('e', 'done(Object.assign(e, { type: "missing" }))')};`,
+                'try {',
+                `if (${RuntimeGlobalIsBrowser}) {`,
+                Template.indent([
+                    `${RuntimeGlobal}.runtime.sendMessage(msg).then(done, onError);`
+                ]),
+                '} else {',
+                Template.indent([
+                    `${RuntimeGlobal}.runtime.sendMessage(msg, ${f('', [
+                        `${_const} error = ${RuntimeGlobal}.runtime.lastError;`,
+                        'if (error) onError(error);',
+                        'else done();'
+                    ])});`
+                ]),
+                '}',
+                '} catch (e) { onError(e); }'
+            ])) + ';';
+            const ClassicLoaderDisabled = `${_const} ${CLASSIC_LOADER} = ` + f('', [
+                "throw new Error(\"[webpack-target-webextension] Failed to load async chunk in the content script. No script loader is found. You can either\\n - Set output.environment.dynamicImport to true if your environment supports native ES Module\\n - Specify the background entry to enable the fallback loader\\n - Set module.parser.javascript.dynamicImportMode to 'eager' to inline all async chunks.\");"
+            ]);
+            return Template.asString([
+                this.supportDynamicImport ? `${_let} bug816121warned, isNotIframe;` : '',
+                this.supportDynamicImport ? Template.asString([
+                    'try {',
+                    Template.indent([
+                        'isNotIframe = typeof window === "object" ? window.top === window : true;'
+                    ]),
+                    '} catch(e) {',
+                    Template.indent([
+                        'isNotIframe = false /* CORS error */;'
+                    ]),
+                    '}'
+                ]) : '',
+                HasExtensionRuntime,
+                this.classicLoaderEnabled ? ClassicLoader : ClassicLoaderDisabled,
+                this.supportDynamicImport ? DynamicImportLoader : '',
+                DOMLoader,
+                WorkerLoader,
+                `${_const} isWorker = typeof importScripts === 'function'`,
+                "if (typeof location === 'object' && location.protocol.includes('-extension:')) {",
+                Template.indent([
+                    `${RuntimeGlobals.loadScript} = isWorker ? ${WORKER_LOADER} : ${DOM_LOADER};`
+                ]),
+                "} else {",
+                Template.indent(isMainWorld ? Template.asString([
+                    `${_const} __extjsMark = "__extjs__";`,
+                    `${_const} __extjsReqType = "EXTJS_WTW_LOAD";`,
+                    `${_const} __extjsResType = "EXTJS_WTW_LOADED";`,
+                    `${_const} ${MAIN_CLASSIC_LOADER} = ` + f('url, done', [
+                        `${_const} requestId = String(Date.now()) + "-" + Math.random().toString(16).slice(2);`,
+                        `${_const} onMessage = ${f('event', [
+                            'try {',
+                            Template.indent([
+                                'if (!event || event.source !== window) return;',
+                                `${_const} data = event.data || null;`,
+                                "if (!data || data[__extjsMark] !== true) return;",
+                                "if (data.type !== __extjsResType || data.requestId !== requestId) return;",
+                                'window.removeEventListener("message", onMessage);',
+                                'if (data.ok) done();',
+                                'else done(Object.assign(new Error(data.error || "Bridge failed"), { type: "missing" }));'
+                            ]),
+                            '} catch (e) {',
+                            Template.indent([
+                                'window.removeEventListener("message", onMessage);',
+                                'done(Object.assign(e, { type: "missing" }));'
+                            ]),
+                            '}'
+                        ])};`,
+                        'window.addEventListener("message", onMessage);',
+                        'try {',
+                        Template.indent([
+                            'window.postMessage({ [__extjsMark]: true, type: __extjsReqType, requestId: requestId, url: url }, "*");'
+                        ]),
+                        '} catch (e) {',
+                        Template.indent([
+                            'window.removeEventListener("message", onMessage);',
+                            'done(Object.assign(e, { type: "missing" }));'
+                        ]),
+                        '}',
+                        'setTimeout(function(){ try { window.removeEventListener("message", onMessage); } catch(_){} done(Object.assign(new Error("Bridge timeout"), { type: "missing" })); }, 5000);'
+                    ]) + ';',
+                    `if (!isWorker) ${RuntimeGlobals.loadScript} = ${MAIN_CLASSIC_LOADER};`
+                ]) : Template.asString([
+                    `if (!isWorker && hasExtensionRuntime) ${RuntimeGlobals.loadScript} = ${CLASSIC_LOADER};`,
+                    `else if (!isWorker) ${RuntimeGlobals.loadScript} = ${DOM_LOADER};`
+                ])),
+                "}",
+                this.supportDynamicImport ? `${_const} ${FALLBACK_LOADER} = ${RuntimeGlobals.loadScript};` : '',
+                this.supportDynamicImport ? `${RuntimeGlobals.loadScript} = ${DYNAMIC_IMPORT_LOADER};` : ''
+            ].filter(Boolean));
+        }
+    }
+    return new LoadScriptRuntime();
+}
+function PublicPathRuntimeModule(webpack) {
+    const { RuntimeGlobals, RuntimeModule, Template } = webpack;
+    class PublicPathRuntime extends RuntimeModule {
+        constructor(){
+            super('publicPath', RuntimeModule.STAGE_BASIC);
+        }
+        generate() {
+            const { compilation } = this;
+            if (!compilation) return Template.asString('/* [webpack-target-webextension] PublicPathRuntimeModule skipped because no compilation is found. */');
+            const { publicPath } = compilation.outputOptions;
+            const path = JSON.stringify(compilation.getPath(publicPath || '', {
+                hash: compilation.hash || 'XXXX'
+            }));
+            return Template.asString([
+                'var __extjsBase = (typeof globalThis === "object" && globalThis && globalThis.__EXTJS_EXTENSION_BASE__) ? String(globalThis.__EXTJS_EXTENSION_BASE__) : "";',
+                'if (!__extjsBase && typeof document === "object" && document && document.documentElement) {',
+                Template.indent([
+                    'try { __extjsBase = document.documentElement.getAttribute("data-extjs-extension-base") || ""; } catch(_) { __extjsBase = ""; }'
+                ]),
+                "}",
+                'var __extjsRuntimePath = "";',
+                `if (${RuntimeGlobal} && ${RuntimeGlobal}.runtime && typeof ${RuntimeGlobal}.runtime.getURL === "function") {`,
+                Template.indent([
+                    `try { __extjsRuntimePath = ${RuntimeGlobal}.runtime.getURL(${path}); } catch (_) { __extjsRuntimePath = ""; }`
+                ]),
+                "}",
+                "if (__extjsRuntimePath) {",
+                Template.indent([
+                    `${RuntimeGlobals.publicPath} = __extjsRuntimePath;`
+                ]),
+                "} else if (__extjsBase) {",
+                Template.indent([
+                    `${RuntimeGlobals.publicPath} = __extjsBase.replace(/\\/+$/, "/") + String(${path}).replace(/^\\/+/, "");`
+                ]),
+                "} else {",
+                Template.indent([
+                    `${RuntimeGlobals.publicPath} = "";`
+                ]),
+                "}",
+                'if (!__extjsBase && typeof document === "object" && document && document.documentElement) {',
+                Template.indent([
+                    "try {",
+                    Template.indent([
+                        "var __extjsRetries = 0;",
+                        "var __extjsUpdateBase = function(){",
+                        Template.indent([
+                            'var base = "";',
+                            'try { base = document.documentElement.getAttribute("data-extjs-extension-base") || ""; } catch(_) { base = ""; }',
+                            "if (base) {",
+                            Template.indent([
+                                `${RuntimeGlobals.publicPath} = base.replace(/\\/+$/, "/") + String(${path}).replace(/^\\/+/, "");`
+                            ]),
+                            "} else if (__extjsRetries++ < 50) {",
+                            Template.indent([
+                                "setTimeout(__extjsUpdateBase, 100);"
+                            ]),
+                            "}"
+                        ]),
+                        "};",
+                        "__extjsUpdateBase();"
+                    ]),
+                    "} catch (_) {}"
+                ]),
+                "}"
+            ]);
+        }
+    }
+    return new PublicPathRuntime();
+}
+function AutoPublicPathRuntimeModule(webpack) {
+    const { RuntimeModule, RuntimeGlobals, Template, javascript: { JavascriptModulesPlugin }, HotUpdateChunk } = webpack;
+    const getChunkFilenameTemplate = JavascriptModulesPlugin.getChunkFilenameTemplate || function(chunk, outputOptions) {
+        if (chunk.filenameTemplate) return chunk.filenameTemplate;
+        if ('function' == typeof HotUpdateChunk && chunk instanceof HotUpdateChunk) return outputOptions.hotUpdateChunkFilename;
+        if (chunk.canBeInitial()) return outputOptions.filename;
+        return outputOptions.chunkFilename;
+    };
+    class AutoPublicPathRuntime extends RuntimeModule {
+        constructor(){
+            super('publicPath', RuntimeModule.STAGE_BASIC);
+        }
+        generate() {
+            const { compilation } = this;
+            if (!compilation || !this.chunk) return Template.asString('/* [webpack-target-webextension] AutoPublicPathRuntimeModule skipped because no compilation/chunk is found. */');
+            const { scriptType, importMetaName } = compilation.outputOptions;
+            const chunkName = compilation.getPath(getChunkFilenameTemplate(this.chunk, compilation.outputOptions), {
+                chunk: this.chunk,
+                contentHashType: "javascript"
+            });
+            const outputPath = compilation.outputOptions.path;
+            if (!outputPath) return Template.asString('/* [webpack-target-webextension] AutoPublicPathRuntimeModule skipped because no output path is found. */');
+            const undoPath = getUndoPath(chunkName, outputPath, false);
+            const optionalChaining = compilation.outputOptions.environment.optionalChaining;
+            const _const = compilation.outputOptions.environment.const ? 'const' : 'var';
+            const _let = compilation.outputOptions.environment.const ? 'let' : 'var';
+            return Template.asString([
+                `${_let} scriptUrl;`,
+                'module' === scriptType ? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url;` : Template.asString([
+                    `if (${RuntimeGlobals.global}.importScripts) scriptUrl = ${RuntimeGlobals.global}.location + "";`,
+                    `${_const} document = ${RuntimeGlobals.global}.document;`,
+                    `if (!scriptUrl && ${optionalChaining ? 'document?.currentScript' : 'document && document.currentScript'}) {`,
+                    Template.indent("scriptUrl = document.currentScript.src;"),
+                    '}'
+                ]),
+                '// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration',
+                '// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.',
+                'var __extjsBase = (typeof globalThis === "object" && globalThis && globalThis.__EXTJS_EXTENSION_BASE__) ? String(globalThis.__EXTJS_EXTENSION_BASE__) : "";',
+                'if (!__extjsBase && typeof document === "object" && document && document.documentElement) {',
+                Template.indent([
+                    'try { __extjsBase = document.documentElement.getAttribute("data-extjs-extension-base") || ""; } catch(_) { __extjsBase = ""; }'
+                ]),
+                "}",
+                "if (__extjsBase && scriptUrl && !/^((chrome|moz)-extension):///.test(scriptUrl)) {",
+                Template.indent([
+                    "scriptUrl = __extjsBase;"
+                ]),
+                "}",
+                "if (!scriptUrl) {",
+                Template.indent([
+                    'var __extjsRuntimeRoot = "";',
+                    `if (${RuntimeGlobal} && ${RuntimeGlobal}.runtime && typeof ${RuntimeGlobal}.runtime.getURL === "function") {`,
+                    Template.indent(`try { __extjsRuntimeRoot = ${RuntimeGlobal}.runtime.getURL("/"); } catch (_) { __extjsRuntimeRoot = ""; }`),
+                    Template.indent("scriptUrl = __extjsRuntimeRoot || scriptUrl;"),
+                    "} else {",
+                    Template.indent('scriptUrl = __extjsBase || "";'),
+                    "}"
+                ]),
+                '}',
+                'scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\\?.*$/, "").replace(/\\/[^\\/]+$/, "/");',
+                undoPath ? `${RuntimeGlobals.publicPath} = scriptUrl + ${JSON.stringify(undoPath)};` : `${RuntimeGlobals.publicPath} = scriptUrl;`,
+                'if (!scriptUrl && typeof document === "object" && document && document.documentElement) {',
+                Template.indent([
+                    "try {",
+                    Template.indent([
+                        "var __extjsRetries = 0;",
+                        "var __extjsUpdateBase = function(){",
+                        Template.indent([
+                            'var base = "";',
+                            'try { base = document.documentElement.getAttribute("data-extjs-extension-base") || ""; } catch(_) { base = ""; }',
+                            "if (base) {",
+                            Template.indent([
+                                'var normalized = base.replace(/\\/+$/, "/");',
+                                undoPath ? `${RuntimeGlobals.publicPath} = normalized + ${JSON.stringify(undoPath)};` : `${RuntimeGlobals.publicPath} = normalized;`
+                            ]),
+                            "} else if (__extjsRetries++ < 50) {",
+                            Template.indent([
+                                "setTimeout(__extjsUpdateBase, 100);"
+                            ]),
+                            "}"
+                        ]),
+                        "};",
+                        "__extjsUpdateBase();"
+                    ]),
+                    "} catch (_) {}"
+                ]),
+                "}"
+            ]);
+        }
+    }
+    return new AutoPublicPathRuntime();
+}
+function getUndoPath(filename, outputPath, enforceRelative) {
+    let depth = -1;
+    let append = '';
+    outputPath = outputPath.replace(/[\\/]$/, '');
+    for (const part of filename.split(/[/\\]+/))if ('..' === part) if (depth > -1) depth--;
+    else {
+        const i = outputPath.lastIndexOf('/');
+        const j = outputPath.lastIndexOf('\\');
+        const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
+        if (pos < 0) return outputPath + '/';
+        append = outputPath.slice(pos + 1) + '/' + append;
+        outputPath = outputPath.slice(0, pos);
+    }
+    else if ('.' !== part) depth++;
+    return depth > 0 ? `${'../'.repeat(depth)}${append}` : enforceRelative ? `./${append}` : append;
+}
+function BaseUriRuntimeModule(webpack) {
+    const { RuntimeGlobals, RuntimeModule, Template } = webpack;
+    class BaseUriRuntime extends RuntimeModule {
+        constructor(){
+            super('baseURI', RuntimeModule.STAGE_BASIC);
+        }
+        generate() {
+            return Template.asString([
+                'var __extjsBase = "";',
+                "try {",
+                Template.indent([
+                    `if (${RuntimeGlobal} && ${RuntimeGlobal}.runtime && typeof ${RuntimeGlobal}.runtime.getURL === "function") {`,
+                    Template.indent([
+                        `__extjsBase = String(${RuntimeGlobal}.runtime.getURL("/"));`
+                    ]),
+                    "}"
+                ]),
+                "} catch (_) {}",
+                'if (!__extjsBase && typeof globalThis === "object" && globalThis && globalThis.__EXTJS_EXTENSION_BASE__) {',
+                Template.indent([
+                    '__extjsBase = String(globalThis.__EXTJS_EXTENSION_BASE__ || "");'
+                ]),
+                "}",
+                'if (!__extjsBase && typeof document === "object" && document && document.documentElement) {',
+                Template.indent([
+                    'try { __extjsBase = String(document.documentElement.getAttribute("data-extjs-extension-base") || ""); } catch (_) { __extjsBase = ""; }'
+                ]),
+                "}",
+                "if (__extjsBase) {",
+                Template.indent([
+                    `${RuntimeGlobals.baseURI} = __extjsBase;`
+                ]),
+                '} else if (typeof document !== "undefined" && document.baseURI) {',
+                Template.indent([
+                    `${RuntimeGlobals.baseURI} = document.baseURI;`
+                ]),
+                "} else {",
+                Template.indent([
+                    `${RuntimeGlobals.baseURI} = self.location.href;`
+                ]),
+                "}"
+            ]);
+        }
+    }
+    return new BaseUriRuntime();
+}
+function ChunkLoaderFallbackRuntimeModule(webpack) {
+    const { RuntimeModule, Template } = webpack;
+    class ChunkLoaderFallbackRuntime extends RuntimeModule {
+        constructor(){
+            super('chunk loader fallback', RuntimeModule.STAGE_TRIGGER);
+        }
+        generate() {
+            const { compilation } = this;
+            if (!compilation) return Template.asString('/* [webpack-target-webextension] ChunkLoaderFallbackRuntimeModule skipped because no compilation is found. */');
+            const { f } = TemplateFn(compilation, Template);
+            const optionalChain = compilation.outputOptions.environment.optionalChaining;
+            const _const = compilation.outputOptions.environment.const ? 'const' : 'var';
+            const _let = compilation.outputOptions.environment.const ? 'let' : 'var';
+            return `if (${RuntimeGlobal} && ${RuntimeGlobal}.runtime && ${RuntimeGlobal}.runtime.onMessage) {${RuntimeGlobal}.runtime.onMessage.addListener(` + f('message, sender, sendResponse', [
+                optionalChain ? 'if (message?.type != "WTW_INJECT" || typeof sender?.tab?.id != "number") return;' : 'if (!message || message.type != "WTW_INJECT" || !sender || !sender.tab || sender.tab.id == null) return;',
+                `${_let} file = message.file;`,
+                'try {',
+                Template.indent([
+                    'file = new URL(file).pathname;'
+                ]),
+                '} catch (_) {}',
+                'if (!file) return;',
+                `if (${RuntimeGlobal}.scripting) {`,
+                Template.indent([
+                    `${RuntimeGlobal}.scripting.executeScript({`,
+                    Template.indent([
+                        'target: { tabId: sender.tab.id, frameIds: [sender.frameId] },',
+                        'files: [file],'
+                    ]),
+                    '}).then(sendResponse);'
+                ]),
+                "} else {",
+                Template.indent([
+                    `${_const} details = { frameId: sender.frameId, file, matchAboutBlank: true };`,
+                    `if (${RuntimeGlobalIsBrowser}) {`,
+                    `${RuntimeGlobal}.tabs.executeScript(sender.tab.id, details).then(sendResponse);`,
+                    '} else {',
+                    `${RuntimeGlobal}.tabs.executeScript(sender.tab.id, details, sendResponse);`,
+                    '}'
+                ]),
+                '}',
+                'return true;'
+            ]) + ");}";
+        }
+    }
+    return new ChunkLoaderFallbackRuntime();
+}
+class WebExtensionChuckLoaderRuntimePlugin {
+    pluginOptions;
+    options;
+    contentScriptsMeta;
+    rspackAutoPublicPath = false;
+    constructor(options){
+        this.pluginOptions = options || {};
+        this.options = this.pluginOptions.background || this.pluginOptions || {};
+        this.contentScriptsMeta = this.pluginOptions.contentScriptsMeta || {};
+    }
+    apply(compiler) {
+        if ('rspack' in compiler) {
+            const { output } = compiler.options;
+            if (void 0 === output.publicPath || 'auto' === output.publicPath) {
+                output.publicPath = '';
+                this.rspackAutoPublicPath = true;
+            }
+        }
+        compiler.hooks.compilation.tap(WebExtensionChuckLoaderRuntimePlugin.name, (compilation)=>{
+            this.tap(compiler, compilation);
+        });
+    }
+    tap(compiler, compilation) {
+        const { RuntimeGlobals } = compiler.webpack;
+        const { options } = this;
+        compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.loadScript).tap(WebExtensionChuckLoaderRuntimePlugin.name, (_chunk, set)=>{
+            set.add(RuntimeGlobal);
+            compilation.addRuntimeModule(_chunk, LoadScriptRuntimeModule(compiler.webpack, false !== compilation.outputOptions.environment.dynamicImport, false !== options.classicLoader, this.contentScriptsMeta));
+            return true;
+        });
+        compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.baseURI).tap(WebExtensionChuckLoaderRuntimePlugin.name, (chunk, set)=>{
+            set.add(RuntimeGlobal);
+            compilation.addRuntimeModule(chunk, BaseUriRuntimeModule(compiler.webpack));
+            return true;
+        });
+        compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.publicPath).tap(WebExtensionChuckLoaderRuntimePlugin.name, (chunk, set)=>{
+            const { outputOptions } = compilation;
+            const { publicPath, scriptType } = outputOptions;
+            if ('auto' === publicPath || '' === publicPath && this.rspackAutoPublicPath) {
+                const module = AutoPublicPathRuntimeModule(compiler.webpack);
+                set.add(RuntimeGlobal);
+                if ('module' !== scriptType) set.add(RuntimeGlobals.global);
+                compilation.addRuntimeModule(chunk, module);
+            } else {
+                set.add(RuntimeGlobal);
+                const module = PublicPathRuntimeModule(compiler.webpack);
+                if ('string' != typeof publicPath || /\[(full)?hash\]/.test(publicPath)) module.fullHash = true;
+                compilation.addRuntimeModule(chunk, module);
+            }
+            return true;
+        });
+        if (false !== options.classicLoader) compilation.hooks.afterOptimizeModules.tap(WebExtensionChuckLoaderRuntimePlugin.name, ()=>{
+            const { pageEntry, serviceWorkerEntry } = options;
+            const entryPoint1 = pageEntry && compilation.entrypoints.get(pageEntry);
+            const entryPoint2 = serviceWorkerEntry && compilation.entrypoints.get(serviceWorkerEntry);
+            if (entryPoint1) compilation.addRuntimeModule(entryPoint1.chunks[0], ChunkLoaderFallbackRuntimeModule(compiler.webpack));
+            if (entryPoint2) compilation.addRuntimeModule(entryPoint2.chunks[0], ChunkLoaderFallbackRuntimeModule(compiler.webpack));
+        });
+    }
+}
+class NoDangerNamePlugin {
+    apply(compiler) {
+        const { Compilation, WebpackError } = compiler.webpack;
+        compiler.hooks.thisCompilation.tap(NoDangerNamePlugin.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: NoDangerNamePlugin.name,
+                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            }, (assets)=>{
+                for (const name of Object.keys(assets || {})){
+                    if (!name.startsWith('_')) continue;
+                    const e = new WebpackError(`[webpack-extension-target] Output file name ${JSON.stringify(name)} starts with "_" which is prohibited.`);
+                    e.stack = '';
+                    compilation.errors.push(e);
+                }
+            });
+        });
+    }
+}
+function createEagerlyLoadChunksRuntimeModule(webpack) {
+    const { RuntimeGlobals, RuntimeModule, Template } = webpack;
+    return class extends RuntimeModule {
+        chunkIds;
+        constructor(chunkIds){
+            super('eagerly load chunks', RuntimeModule.STAGE_NORMAL);
+            this.chunkIds = chunkIds;
+        }
+        generate() {
+            const { compilation } = this;
+            if (!compilation) return Template.asString('/* [webpack-target-webextension] EagerlyLoadChunksRuntimeModule skipped because no compilation is found. */');
+            const _const = compilation.outputOptions.environment.const ? 'const' : 'var';
+            return Template.asString([
+                `${_const} __extjsChunkIds = ${JSON.stringify(this.chunkIds)};`,
+                `${_const} __extjsLoad = ${RuntimeGlobals.ensureChunkHandlers};`,
+                `for (${_const} __extjsId of __extjsChunkIds) __extjsLoad(__extjsId);`
+            ]);
+        }
+    };
+}
+class WebExtensionServiceWorkerEntryPlugin {
+    options;
+    backgroundOutputEmitted;
+    constructor(options, backgroundOutputEmitted){
+        this.options = options;
+        this.backgroundOutputEmitted = backgroundOutputEmitted;
+    }
+    apply(compiler) {
+        const { javascript, sources } = compiler.webpack;
+        const entry = this.options.serviceWorkerEntry;
+        if (void 0 === entry) return;
+        if (!(compiler.options.output.module || compiler.options.experiments.outputModule)) {
+            const hook = compiler.hooks.entryOption;
+            hook.tap(WebExtensionServiceWorkerEntryPlugin.name, (_context, entries)=>{
+                if ('function' == typeof entries) {
+                    if (this.options.noDynamicEntryWarning) return;
+                    console.warn(`[webpack-extension-target] Dynamic entry points not supported yet.
+You must manually set the chuck loading of entry point ${entry} to "import-scripts".
+
+See https://webpack.js.org/configuration/entry-context/#entry-descriptor
+
+Set background.noDynamicEntryWarning to true to disable this warning.
+`);
+                }
+                const selectedEntry = entries?.[entry];
+                if (!selectedEntry) throw new Error(`[webpack-extension-target] There is no entry called ${entry}.`);
+                selectedEntry.chunkLoading = "import-scripts";
+            });
+        }
+        if (false !== this.options.eagerChunkLoading) compiler.hooks.compilation.tap(WebExtensionServiceWorkerEntryPlugin.name, (compilation)=>{
+            compilation.hooks.afterOptimizeChunkIds?.tap(WebExtensionServiceWorkerEntryPlugin.name, ()=>{
+                const entryPoint = compilation.entrypoints.get(entry);
+                if (!entryPoint) return;
+                const entryChunk = entryPoint.getEntrypointChunk();
+                const reachableChunks = getReachableChunks(entryPoint, new Set(entryPoint.chunks));
+                const reachableChunkIds = new Set([
+                    ...reachableChunks
+                ].map((x)=>x.id));
+                for (const id of getInitialChunkIds(entryChunk, compilation.chunkGraph, chunkHasJs))reachableChunkIds.delete(id);
+                if (reachableChunkIds.size) {
+                    const EagerlyLoadChunksRuntimeModule = createEagerlyLoadChunksRuntimeModule(compiler.webpack);
+                    compilation.hooks.additionalTreeRuntimeRequirements.tap(EagerlyLoadChunksRuntimeModule.name, (chunk, set)=>{
+                        if (chunk.id !== entryChunk.id) return;
+                        set.add(compiler.webpack.RuntimeGlobals.ensureChunkHandlers);
+                        compilation.addRuntimeModule(entryChunk, new EagerlyLoadChunksRuntimeModule([
+                            ...reachableChunkIds
+                        ]));
+                    });
+                }
+            });
+        });
+        if (false !== this.options.tryCatchWrapper && 'module' !== compiler.options.output.chunkFormat && !this.backgroundOutputEmitted) compiler.hooks.compilation.tap(WebExtensionServiceWorkerEntryPlugin.name, (compilation)=>{
+            const hooks = javascript.JavascriptModulesPlugin.getCompilationHooks(compilation);
+            if (hooks.renderContent) hooks.renderContent.tap(WebExtensionServiceWorkerEntryPlugin.name, (source, context)=>{
+                const entryPoint = compilation.entrypoints.get(entry);
+                const entryChunk = entryPoint?.getEntrypointChunk();
+                if (entryChunk !== context.chunk) return source;
+                return new sources.ConcatSource('/******/ try { // If the initial code of the serviceWorkerEntry throws, the console cannot be opened.\n', source, '\n/******/ } catch (e) {\n/******/ \tPromise.reject(e);\n/******/ }');
+            });
+        });
+    }
+}
+function getInitialChunkIds(chunk, chunkGraph, filterFn) {
+    const initialChunkIds = new Set(chunk.ids);
+    for (const c of chunk.getAllInitialChunks())if (!(c === chunk || filterFn(c, chunkGraph)) && c.ids) for (const id of c.ids)initialChunkIds.add(id);
+    return initialChunkIds;
+}
+function chunkHasJs(chunk, chunkGraph) {
+    if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return true;
+    return !!chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript");
+}
+function getReachableChunks(chunkGroup, reachableChunks = new Set(), visitedChunkGroups = new Set()) {
+    for (const x of chunkGroup.getChildren())if (!visitedChunkGroups.has(x)) {
+        visitedChunkGroups.add(x);
+        x.chunks.forEach((c)=>reachableChunks.add(c));
+        getReachableChunks(x, reachableChunks, visitedChunkGroups);
+    }
+    return reachableChunks;
+}
+class WebExtensionContentScriptEntryPlugin {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    apply(compiler) {
+        const { WebpackError, sources, Template } = compiler.webpack;
+        const { experimental_output } = this.options;
+        if (!experimental_output) return;
+        {
+            const sw = this.options.background?.serviceWorkerEntry;
+            if (sw && sw in experimental_output && 'function' == typeof experimental_output[sw]) throw new Error(`[webpack-extension-target] options.experimental_output[${JSON.stringify(sw)}] cannot be a function because it is a service worker entry. Use { file, touch(manifest, file) { manifest.background.service_worker = file; } } instead.`);
+        }
+        compiler.hooks.thisCompilation.tap(WebExtensionContentScriptEntryPlugin.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: WebExtensionContentScriptEntryPlugin.name,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_DERIVED
+            }, (assets)=>{
+                let manifest;
+                const serviceWorkerEntry = this.options.background?.serviceWorkerEntry;
+                if (serviceWorkerEntry && !(serviceWorkerEntry in experimental_output) && (getInitialFiles(compilation, serviceWorkerEntry)?.length || 0) > 1) {
+                    const e = new WebpackError(`[webpack-extension-target] Entry ${JSON.stringify(serviceWorkerEntry)} is not specified in options.experimental_output.`);
+                    e.stack = '';
+                    compilation.warnings.push(e);
+                }
+                for(const entry in experimental_output){
+                    const isBackgroundEntry = entry === serviceWorkerEntry;
+                    const entryOption = experimental_output[entry];
+                    const initialFiles = getInitialFiles(compilation, entry);
+                    if (!initialFiles || 0 === initialFiles.length) {
+                        const name = JSON.stringify(entry);
+                        const e = new WebpackError(initialFiles ? `[webpack-extension-target] Entry ${name} does not emit any initial file (specified in options.experimental_output).` : `[webpack-extension-target] Entry ${name} does not exist (specified in options.experimental_output).`);
+                        e.stack = '';
+                        compilation.errors.push(e);
+                        continue;
+                    }
+                    if (false === entryOption) {
+                        if (initialFiles.length > 1) {
+                            const name = JSON.stringify(entry);
+                            const e = new WebpackError(`[webpack-extension-target] Entry ${name} emits more than one initial file which is prohibited (specified in options.experimental_output).`);
+                            e.stack = '';
+                            compilation.errors.push(e);
+                        }
+                        continue;
+                    }
+                    const emitFile = (entryOptionFile, files)=>{
+                        if (entryOptionFile in assets) {
+                            const e = new WebpackError(`[webpack-extension-target] Cannot override an existing file ${JSON.stringify(entryOptionFile)} (specified by options.experimental_output[${JSON.stringify(entry)}]).`);
+                            e.stack = '';
+                            compilation.errors.push(e);
+                            return;
+                        }
+                        let code;
+                        if (isBackgroundEntry) {
+                            const asyncAndSyncFiles = getInitialAndAsyncFiles(compilation, entry);
+                            code = 'module' === compilation.outputOptions.chunkFormat ? asyncAndSyncFiles.map((file)=>`import ${JSON.stringify('./' + file)};`) : [
+                                'try {',
+                                Template.indent('importScripts(' + asyncAndSyncFiles.map((file)=>JSON.stringify(file)).join(', ') + ');'),
+                                '} catch (e) {',
+                                Template.indent('Promise.reject(e);'),
+                                '}'
+                            ];
+                        } else code = [
+                            ';(() => {',
+                            Template.indent([
+                                'const getURL = typeof globalThis === "object" && globalThis && typeof globalThis.browser === "object" ? globalThis.browser.runtime.getURL : globalThis.chrome.runtime.getURL;',
+                                `${JSON.stringify(files)}.forEach(file => import(getURL(file)));`
+                            ]),
+                            '})();',
+                            'null;'
+                        ];
+                        const source = new compiler.webpack.sources.RawSource(Template.asString(code));
+                        compilation.emitAsset(entryOptionFile, source);
+                    };
+                    if ('string' == typeof entryOption) {
+                        emitFile(entryOption, initialFiles);
+                        continue;
+                    }
+                    if (!manifest) {
+                        const manifestAsset = assets['manifest.json'];
+                        const name = JSON.stringify(entry);
+                        if (!manifestAsset) {
+                            const e = new WebpackError(`[webpack-extension-target] A manifest.json is required (required by options.experimental_output[${name}]). You can emit this file by using CopyPlugin or any other plugins.`);
+                            e.stack = '';
+                            compilation.errors.push(e);
+                            continue;
+                        }
+                        try {
+                            const source = manifestAsset.source();
+                            manifest = 'string' == typeof source ? JSON.parse(source) : JSON.parse(source.toString('utf-8'));
+                        } catch  {
+                            const e = new WebpackError(`[webpack-extension-target] Failed to parse manifest.json (required by options.experimental_output[${name}]).`);
+                            e.stack = '';
+                            e.file = 'manifest.json';
+                            compilation.errors.push(e);
+                            continue;
+                        }
+                    }
+                    if ('function' == typeof entryOption) entryOption(manifest, initialFiles);
+                    else if ('object' == typeof entryOption) {
+                        emitFile(entryOption.file, initialFiles);
+                        entryOption.touch(manifest, entryOption.file);
+                    }
+                }
+                if (manifest) compilation.updateAsset('manifest.json', new sources.RawSource(JSON.stringify(manifest, void 0, 4)));
+            });
+        });
+    }
+}
+function getInitialFiles(compilation, entry) {
+    const entryPoint = compilation.entrypoints.get(entry);
+    if (!entryPoint) return;
+    const files = new Set();
+    const runtimeChunk = entryPoint.getRuntimeChunk();
+    if (runtimeChunk) runtimeChunk.files.forEach((file)=>{
+        if (!isJSFile(file)) return;
+        const asset = compilation.getAsset(file);
+        if (!asset) return;
+        if (!asset.info.hotModuleReplacement) files.add(file);
+    });
+    entryPoint.getFiles().forEach((file)=>{
+        if (!isJSFile(file)) return;
+        const asset = compilation.getAsset(file);
+        if (!asset) return;
+        if (!asset.info.hotModuleReplacement) files.add(file);
+    });
+    return [
+        ...files
+    ];
+}
+function getInitialAndAsyncFiles(compilation, entry) {
+    const entryPoint = compilation.entrypoints.get(entry);
+    if (!entryPoint) return [];
+    const files = new Set();
+    const visitedChunk = new Set();
+    function visit(chunk) {
+        const chunkId = 'rspack' in compilation.compiler ? chunk.id && chunk.hash ? chunk.id + chunk.hash : Array.from(chunk.files).join('') : chunk;
+        if (visitedChunk.has(chunkId)) return;
+        visitedChunk.add(chunkId);
+        chunk.files.forEach((file)=>{
+            if (!isJSFile(file)) return;
+            const asset = compilation.getAsset(file);
+            if (!asset) return;
+            if (!asset.info.hotModuleReplacement) files.add(file);
+        });
+        for (const child of chunk.getAllAsyncChunks())visit(child);
+    }
+    entryPoint.chunks.forEach(visit);
+    const allFiles = [
+        ...files
+    ].filter((file)=>isJSFile(file) && compilation.getAsset(file));
+    return allFiles;
+}
+function isJSFile(file) {
+    return file.endsWith('.js') || file.endsWith('.mjs');
+}
+class DevServerConfigPlugin {
+    apply(compiler) {
+        if (!compiler.options.devServer) compiler.options.devServer = {};
+        const devServer = compiler.options.devServer;
+        setDefault(devServer, 'devMiddleware', {});
+        setDefault(devServer.devMiddleware, 'writeToDisk', true);
+        if (void 0 === devServer.hot) devServer.hot = 'only';
+        if (!devServer.hot) return;
+        setDefault(devServer, 'host', '127.0.0.1');
+        setDefault(devServer, 'client', {
+            overlay: false,
+            progress: false,
+            webSocketURL: {
+                protocol: 'ws'
+            }
+        });
+        setDefault(devServer.client, 'overlay', false);
+        setDefault(devServer.client, 'progress', false);
+        setDefault(devServer.client, 'webSocketURL', {
+            protocol: 'ws'
+        });
+        setDefault(devServer.client.webSocketURL, 'protocol', 'ws');
+        const connectableHost = resolveClientHost(process.env.EXTENSION_DEV_SERVER_CONNECTABLE_HOST, devServer.host);
+        if (connectableHost) setDefault(devServer.client.webSocketURL, 'hostname', connectableHost);
+        if (devServer.port) setDefault(devServer.client.webSocketURL, 'port', devServer.port);
+        setDefault(devServer, 'allowedHosts', 'all');
+        setDefault(devServer, 'headers', {
+            'Access-Control-Allow-Origin': '*'
+        });
+        setDefault(devServer, 'static', {
+            watch: {
+                ignored: /\bnode_modules\b/
+            }
+        });
+        setDefault(devServer.static, 'watch', {
+            ignored: /\bnode_modules\b/
+        });
+        isObject(devServer.static) && 'watch' in devServer.static && isObject(devServer.static.watch) && setDefault(devServer.static.watch, 'ignored', /\bnode_modules\b/);
+    }
+}
+function setDefault(obj, key, val) {
+    if (isObject(obj) && void 0 === obj[key]) obj[key] = val;
+}
+const WILDCARD_HOSTS = new Set([
+    '0.0.0.0',
+    '::',
+    '[::]',
+    '::0',
+    '*',
+    ''
+]);
+function resolveClientHost(connectable, bindHost) {
+    const resolved = String(connectable ?? '').trim();
+    if (resolved) return resolved;
+    const bind = 'string' == typeof bindHost ? bindHost.trim() : '';
+    if (!bind) return;
+    return WILDCARD_HOSTS.has(bind) ? '127.0.0.1' : bind;
+}
+function isObject(x) {
+    return 'object' == typeof x && null !== x;
+}
+class WebExtensionPlugin {
+    options;
+    constructor(options = {}){
+        const { background } = options;
+        if (background) {
+            const { serviceWorkerEntry, pageEntry } = background;
+            if ('entry' in background || 'manifest' in background) throw new Error('[webpack-extension-target] background.entry and background.manifest has been removed. Use background.pageEntry and/or background.serviceWorkerEntry instead.');
+            if (serviceWorkerEntry && serviceWorkerEntry === pageEntry) throw new Error(`[webpack-extension-target] background.serviceWorkerEntry must not be the same as background.pageEntry. Service Worker entry only supports importScript, but importScript does not exist in background page (mv2) or limited event page (mv3).
+    A possible fix is to create two new files to be the service worker entry and the page entry, then those two files imports the background entry.`);
+        }
+        this.options = options;
+    }
+    apply(compiler) {
+        const { background, experimental_output } = this.options;
+        if (background?.serviceWorkerEntry) {
+            const serviceWorkerEntry = this.options.background?.serviceWorkerEntry;
+            const output = serviceWorkerEntry ? this.options.experimental_output?.[serviceWorkerEntry] : false;
+            new WebExtensionServiceWorkerEntryPlugin(background, !!output).apply(compiler);
+        }
+        if (experimental_output) new WebExtensionContentScriptEntryPlugin(this.options).apply(compiler);
+        if (false !== this.options.hmrConfig) new DevServerConfigPlugin().apply(compiler);
+        new WebExtensionChuckLoaderRuntimePlugin(this.options).apply(compiler);
+        new NoDangerNamePlugin().apply(compiler);
+        compiler.hooks.environment.tap(WebExtensionPlugin.name, ()=>{
+            const { output } = compiler.options;
+            if (false !== output.environment.dynamicImport) output.environment.dynamicImport = true;
+            if (void 0 !== output.hotUpdateChunkFilename) output.hotUpdateChunkFilename = 'hot/[id].[fullhash].js';
+            if (void 0 !== output.hotUpdateMainFilename) output.hotUpdateMainFilename = 'hot/[runtime].[fullhash].json';
+        });
+        compiler.hooks.compilation.tap(WebExtensionPlugin.name, (compilation)=>{
+            compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobal).tap(WebExtensionPlugin.name, (chunk)=>{
+                compilation.addRuntimeModule(chunk, BrowserRuntimeModule(compiler.webpack, !!this.options.weakRuntimeCheck));
+                return true;
+            });
+        });
+    }
+}
+const webpack_target_webextension_fork = WebExtensionPlugin;
+function isFromFilepathList(filePath, filepathList) {
+    return Object.values(filepathList || {}).some((value)=>value === filePath);
+}
+function getFilename(feature, filePath) {
+    const entryExt = __rspack_external_path.extname(filePath);
+    let fileOutputpath = feature;
+    if ([
+        '.js',
+        '.jsx',
+        '.tsx',
+        '.ts',
+        '.vue',
+        '.svelte'
+    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.js');
+    if ([
+        '.html',
+        '.njk',
+        '.nunjucks'
+    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.html');
+    if ([
+        '.css',
+        '.scss',
+        '.sass',
+        '.less'
+    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.css');
+    return unixify(fileOutputpath || '');
+}
+function unixify(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+function resolveRootAbsoluteRef(ref, projectRoot, publicRoot) {
+    if (!ref || !ref.startsWith('/')) return;
+    if (projectRoot && ref.startsWith(projectRoot)) return;
+    if (ref.startsWith('//')) return;
+    const trimmed = ref.replace(/^\/+/, '');
+    if (!trimmed) return;
+    if (publicRoot && __rspack_external_fs.existsSync(__rspack_external_path.join(publicRoot, trimmed))) return;
+    const candidate = __rspack_external_path.resolve(projectRoot, trimmed);
+    const rel = __rspack_external_path.relative(projectRoot, candidate);
+    if (rel.startsWith('..') || __rspack_external_path.isAbsolute(rel)) return;
+    if (!__rspack_external_fs.existsSync(candidate) || !__rspack_external_fs.statSync(candidate).isFile()) return;
+    return candidate;
+}
+function collectRootAbsoluteRefs(source) {
+    const refs = new Set();
+    const attrRe = /(?:src|href)\s*=\s*["'](\/[^"'#?]*)["']/gi;
+    const urlRe = /url\(\s*["']?(\/[^"')#?]+)["']?\s*\)/gi;
+    let m;
+    while(m = attrRe.exec(source))refs.add(m[1]);
+    while(m = urlRe.exec(source))refs.add(m[1]);
+    return refs;
+}
+function background_background(manifest) {
+    return manifest.background && manifest.background.scripts && {
+        background: {
+            scripts: [
+                ...new Set(manifest.background.scripts.map((script)=>getFilename("background/scripts.js", String(script))))
+            ]
+        }
+    };
+}
+function normalizeManifestOutputPath(originalPath) {
+    if (!originalPath) return originalPath;
+    const unixPath = originalPath.replace(/\\/g, '/');
+    if (/^\/public\//i.test(unixPath)) return unixPath.replace(/^\/public\//i, '');
+    if (/^(?:\.\/)?public\//i.test(unixPath)) return unixPath.replace(/^(?:\.\/)?public\//i, '');
+    if (/^\//.test(unixPath)) return unixPath.replace(/^\//, '');
+    return unixPath;
+}
+function manifestPageOutputTarget(raw, compiledTarget, manifestPath) {
+    const unixPath = raw.replace(/\\/g, '/');
+    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(unixPath)) return normalizeManifestOutputPath(unixPath);
+    if (/^\//.test(unixPath)) {
+        const rest = unixPath.replace(/^\/+/, '');
+        if (manifestPath && rest) {
+            const manifestDir = __rspack_external_path.dirname(manifestPath);
+            const inPublic = __rspack_external_fs.existsSync(__rspack_external_path.join(manifestDir, 'public', rest));
+            const inRoot = __rspack_external_fs.existsSync(__rspack_external_path.join(manifestDir, rest));
+            if (inRoot && !inPublic) return compiledTarget;
+        }
+        return normalizeManifestOutputPath(unixPath);
+    }
+    return compiledTarget;
+}
+function iconOutputPath(raw) {
+    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw)) return normalizeManifestOutputPath(raw);
+    const normalized = normalizeManifestOutputPath(raw).replace(/^\.\//, '');
+    const escapes = !normalized || normalized.split('/').includes('..') || /^[A-Za-z]:/.test(normalized);
+    return escapes ? `icons/${normalized.split('/').pop() || ''}` : normalized;
+}
+function browserAction(manifest) {
+    return manifest.browser_action && {
+        browser_action: {
+            ...manifest.browser_action,
+            ...manifest.browser_action.default_popup && {
+                default_popup: getFilename('action/index.html', manifest.browser_action.default_popup)
+            },
+            ...manifest.browser_action.default_icon && {
+                default_icon: 'string' == typeof manifest.browser_action.default_icon ? (()=>{
+                    const raw = String(manifest.browser_action.default_icon);
+                    return getFilename(iconOutputPath(raw), raw);
+                })() : Object.fromEntries(Object.entries(manifest.browser_action.default_icon).map(([size, icon])=>{
+                    const raw = String(icon);
+                    return [
+                        size,
+                        getFilename(iconOutputPath(raw), raw)
+                    ];
+                }))
+            },
+            ...manifest.browser_action.theme_icons && {
+                theme_icons: manifest.browser_action.theme_icons.map((themeIcon)=>({
+                        ...themeIcon,
+                        ...themeIcon.light && {
+                            light: (()=>{
+                                const raw = String(themeIcon.light);
+                                const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
+                                const target = isPublic ? normalizeManifestOutputPath(raw) : `browser_action/${__rspack_external_path.basename(raw)}`;
+                                return getFilename(target, raw);
+                            })()
+                        },
+                        ...themeIcon.dark && {
+                            dark: (()=>{
+                                const raw = String(themeIcon.dark);
+                                const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
+                                const target = isPublic ? normalizeManifestOutputPath(raw) : `browser_action/${__rspack_external_path.basename(raw)}`;
+                                return getFilename(target, raw);
+                            })()
+                        }
+                    }))
+            }
+        }
+    };
+}
+function chromeSettingsOverrides(manifest) {
+    return manifest.chrome_settings_overrides && {
+        chrome_settings_overrides: {
+            ...manifest.chrome_settings_overrides.homepage && {
+                homepage: manifest.chrome_settings_overrides.homepage
+            },
+            ...manifest.chrome_settings_overrides.search_provider && {
+                search_provider: {
+                    ...manifest.chrome_settings_overrides.search_provider,
+                    ...manifest.chrome_settings_overrides.search_provider.favicon_url && {
+                        favicon_url: (()=>{
+                            const fav = manifest.chrome_settings_overrides.search_provider.favicon_url;
+                            const isUrl = /^(?:[a-z]+:)?\/\//i.test(fav);
+                            return isUrl ? fav : getFilename(`chrome_settings_overrides/${fav.split('/').pop()}`, fav);
+                        })()
+                    }
+                }
+            },
+            ...manifest.chrome_settings_overrides.startup_pages && {
+                startup_pages: manifest.chrome_settings_overrides.startup_pages.map((page, index)=>getFilename(`chrome_settings_overrides/startup-${index}.html`, page))
+            }
+        }
+    };
+}
+function pageAction(manifest) {
+    return manifest.page_action && {
+        page_action: {
+            ...manifest.page_action,
+            ...manifest.page_action.default_popup && {
+                default_popup: getFilename('action/index.html', manifest.page_action.default_popup)
+            },
+            ...manifest.page_action.default_icon && {
+                default_icon: 'string' == typeof manifest.page_action.default_icon ? (()=>{
+                    const raw = String(manifest.page_action.default_icon);
+                    return getFilename(iconOutputPath(raw), raw);
+                })() : Object.fromEntries(Object.entries(manifest.page_action.default_icon).map(([size, icon])=>{
+                    const raw = String(icon);
+                    return [
+                        size,
+                        getFilename(iconOutputPath(raw), raw)
+                    ];
+                }))
+            }
+        }
+    };
+}
+function sidebarAction(manifest) {
+    return manifest.sidebar_action && {
+        sidebar_action: {
+            ...manifest.sidebar_action,
+            ...manifest.sidebar_action.default_panel && {
+                default_panel: getFilename("sidebar/index.html", manifest.sidebar_action.default_panel)
+            },
+            ...manifest.sidebar_action.default_icon && {
+                default_icon: 'string' == typeof manifest.sidebar_action.default_icon ? (()=>{
+                    const raw = String(manifest.sidebar_action.default_icon);
+                    return getFilename(iconOutputPath(raw), raw);
+                })() : Object.fromEntries(Object.entries(manifest.sidebar_action.default_icon).map(([size, icon])=>{
+                    const raw = String(icon);
+                    return [
+                        size,
+                        getFilename(iconOutputPath(raw), raw)
+                    ];
+                }))
+            }
+        }
+    };
+}
+const getBasename = (filepath)=>__rspack_external_path.basename(filepath);
+function themeExperiment(manifest) {
+    const te = manifest.theme_experiment;
+    return te && {
+        theme_experiment: {
+            ...te,
+            ...'string' == typeof te.stylesheet && {
+                stylesheet: getFilename(`theme_experiment/${getBasename(te.stylesheet)}`, te.stylesheet)
+            },
+            ...Array.isArray(te.stylesheets) && {
+                stylesheets: te.stylesheets.map((s, i)=>getFilename(`theme_experiment/stylesheet-${i}.css`, s))
+            }
+        }
+    };
+}
+function manifestV2(manifest) {
+    return {
+        ...background_background(manifest),
+        ...browserAction(manifest),
+        ...pageAction(manifest),
+        ...sidebarAction(manifest),
+        ...chromeSettingsOverrides(manifest),
+        ...themeExperiment(manifest)
+    };
+}
+function action(manifest) {
+    return manifest.action && {
+        action: {
+            ...manifest.action,
+            ...manifest.action.default_popup && {
+                default_popup: getFilename("action/index.html", manifest.action.default_popup)
+            },
+            ...manifest.action.default_icon && {
+                default_icon: 'string' == typeof manifest.action.default_icon ? (()=>{
+                    const raw = String(manifest.action.default_icon);
+                    return getFilename(iconOutputPath(raw), raw);
+                })() : Object.fromEntries(Object.entries(manifest.action.default_icon).map(([size, icon])=>{
+                    const raw = String(icon);
+                    return [
+                        size,
+                        getFilename(iconOutputPath(raw), raw)
+                    ];
+                }))
+            }
+        }
+    };
+}
+function backgroundServiceWorker(manifest) {
+    return manifest.background && manifest.background.service_worker && {
+        background: {
+            service_worker: (()=>{
+                const raw = String(manifest.background.service_worker);
+                return getFilename('background/service_worker.js', raw);
+            })()
+        }
+    };
+}
+function declarativeNetRequest(manifest) {
+    return manifest.declarative_net_request && {
+        declarative_net_request: {
+            ...manifest.declarative_net_request,
+            rule_resources: manifest.declarative_net_request.rule_resources.map((resourceObj)=>({
+                    ...resourceObj,
+                    path: resourceObj.path && getFilename(`declarative_net_request/${resourceObj.id}.json`, resourceObj.path)
+                }))
+        }
+    };
+}
+function hostPermissions(manifest) {
+    return manifest.host_permissions && {
+        host_permissions: manifest.host_permissions
+    };
+}
+function sidePanel(manifest) {
+    return manifest.side_panel && {
+        side_panel: {
+            ...manifest.side_panel,
+            ...manifest.side_panel.default_path && {
+                default_path: (()=>{
+                    const raw = String(manifest.side_panel.default_path);
+                    return getFilename('sidebar/index.html', raw);
+                })()
+            }
+        }
+    };
+}
+function manifestV3(manifest) {
+    return {
+        ...action(manifest),
+        ...backgroundServiceWorker(manifest),
+        ...declarativeNetRequest(manifest),
+        ...hostPermissions(manifest),
+        ...sidePanel(manifest)
+    };
+}
+function backgroundPage(manifest) {
+    return manifest.background && manifest.background.page && {
+        background: {
+            page: (()=>{
+                const raw = String(manifest.background.page);
+                return getFilename('background/index.html', raw);
+            })()
+        }
+    };
+}
+function chromeUrlOverrides(manifest, manifestPath) {
+    return manifest.chrome_url_overrides && {
+        chrome_url_overrides: {
+            ...manifest.chrome_url_overrides.bookmarks && {
+                bookmarks: (()=>{
+                    const raw = String(manifest.chrome_url_overrides.bookmarks);
+                    return getFilename(manifestPageOutputTarget(raw, 'chrome_url_overrides/bookmarks.html', manifestPath), raw);
+                })()
+            },
+            ...manifest.chrome_url_overrides.history && {
+                history: (()=>{
+                    const raw = String(manifest.chrome_url_overrides.history);
+                    return getFilename(manifestPageOutputTarget(raw, 'chrome_url_overrides/history.html', manifestPath), raw);
+                })()
+            },
+            ...manifest.chrome_url_overrides.newtab && {
+                newtab: (()=>{
+                    const raw = String(manifest.chrome_url_overrides.newtab);
+                    return getFilename(manifestPageOutputTarget(raw, 'chrome_url_overrides/newtab.html', manifestPath), raw);
+                })()
+            }
+        }
+    };
+}
+function isBundledContentPath(filePath, ext) {
+    const normalized = String(filePath || '').replace(/\\/g, '/');
+    const bundledAsset = parseCanonicalContentScriptAsset(normalized);
+    return bundledAsset?.extension === ext;
+}
+function isAlreadyBundledContentScripts(contentScripts) {
+    if (!Array.isArray(contentScripts) || 0 === contentScripts.length) return false;
+    return contentScripts.every((contentObj)=>{
+        const js = Array.isArray(contentObj?.js) ? contentObj.js : [];
+        const css = Array.isArray(contentObj?.css) ? contentObj.css : [];
+        return js.every((filePath)=>isBundledContentPath(filePath, 'js')) && css.every((filePath)=>isBundledContentPath(filePath, 'css'));
+    });
+}
+function content_scripts_contentScripts(manifest, manifestPath) {
+    if (!manifest.content_scripts) return;
+    const original = manifest.content_scripts;
+    if (isAlreadyBundledContentScripts(original)) return {
+        content_scripts: original
+    };
+    const originalCount = original.length;
+    const result = [];
+    let bridgeOrdinal = 0;
+    for(let index = 0; index < original.length; index++){
+        const contentObj = original[index] || {};
+        const contentJs = [
+            ...new Set(contentObj.js || [])
+        ];
+        const contentCss = [
+            ...new Set(contentObj.css || [])
+        ];
+        if ('MAIN' === contentObj.world) {
+            const bridgeIndex = originalCount + bridgeOrdinal++;
+            const { world: _ignoredWorld, js: _ignoredJs, css: _ignoredCss, ...rest } = contentObj;
+            result.push({
+                ...rest,
+                js: [
+                    getFilename(getCanonicalContentScriptJsAssetName(bridgeIndex), 'main-world-bridge.js')
+                ],
+                css: []
+            });
+        }
+        result.push({
+            ...original[index] || {},
+            js: [
+                ...new Set(contentJs.map((js)=>getFilename(getCanonicalContentScriptJsAssetName(index), js)))
+            ],
+            css: [
+                ...new Set(contentCss.map((css)=>getFilename(getCanonicalContentScriptCssAssetName(index), css)))
+            ]
+        });
+    }
+    return {
+        content_scripts: result
+    };
+}
+function devtoolsPage(manifest, manifestPath) {
+    return manifest.devtools_page && {
+        devtools_page: (()=>{
+            const raw = String(manifest.devtools_page);
+            return getFilename(manifestPageOutputTarget(raw, 'devtools/index.html', manifestPath), raw);
+        })()
+    };
+}
+function icons(manifest) {
+    return manifest.icons && {
+        icons: Object.fromEntries(Object.entries(manifest.icons).map(([size, icon])=>{
+            const raw = String(icon);
+            return [
+                size,
+                getFilename(iconOutputPath(raw), raw)
+            ];
+        }))
+    };
+}
+function commands(manifest) {
+    return manifest.commands && {
+        commands: manifest.commands
+    };
+}
+function permissions(manifest) {
+    return manifest.permissions && {
+        permissions: manifest.permissions
+    };
+}
+function optionsPage(manifest, manifestPath) {
+    return manifest.options_page && {
+        options_page: (()=>{
+            const raw = String(manifest.options_page);
+            return getFilename(manifestPageOutputTarget(raw, 'options/index.html', manifestPath), raw);
+        })()
+    };
+}
+function optionsUi(manifest, manifestPath) {
+    return manifest.options_ui && {
+        options_ui: {
+            ...manifest.options_ui,
+            ...manifest.options_ui.page && {
+                page: (()=>{
+                    const raw = String(manifest.options_ui.page);
+                    return getFilename(manifestPageOutputTarget(raw, 'options/index.html', manifestPath), raw);
+                })()
+            }
+        }
+    };
+}
+function sandbox(manifest) {
+    return manifest.sandbox && {
+        sandbox: {
+            ...manifest.sandbox,
+            ...manifest.sandbox.pages && {
+                pages: manifest.sandbox.pages.map((page, index)=>getFilename(`sandbox/page-${index}.html`, page))
+            }
+        }
+    };
+}
+function storage(manifest) {
+    return manifest.storage && {
+        storage: {
+            ...manifest.storage.managed_schema && {
+                managed_schema: getFilename('storage/managed_schema.json', manifest.storage.managed_schema)
+            }
+        }
+    };
+}
+const theme_getBasename = (filepath)=>__rspack_external_path.basename(filepath);
+const rewriteThemeImage = (value)=>getFilename(`theme/images/${theme_getBasename(value)}`, value);
+function theme(manifest) {
+    return manifest.theme && {
+        theme: {
+            ...manifest.theme,
+            ...manifest.theme.images && {
+                images: Object.fromEntries(Object.entries(manifest.theme.images).map(([key, value])=>[
+                        key,
+                        Array.isArray(value) ? value.map(rewriteThemeImage) : rewriteThemeImage(value)
+                    ]))
+            }
+        }
+    };
+}
+function userScripts(manifest) {
+    return manifest.user_scripts && {
+        user_scripts: {
+            ...manifest.user_scripts,
+            ...manifest.user_scripts.api_script && {
+                api_script: getFilename("user_scripts/api_script.js", manifest.user_scripts.api_script)
+            }
+        }
+    };
+}
+function normalizeOutputPath(originalPath) {
+    if (!originalPath) return originalPath;
+    const unix = originalPath.replace(/\\/g, '/');
+    if (/[*?\[\]{}]/.test(unix)) return unix;
+    if (/^\/public\//i.test(unix)) return unix.replace(/^\/public\//i, '');
+    if (/^(?:\.\/)?public\//i.test(unix)) return unix.replace(/^(?:\.\/)?public\//i, '');
+    if (/^\//.test(unix)) return unix.replace(/^\//, '');
+    return unix;
+}
+function webAccessibleResources(manifest) {
+    if (!manifest.web_accessible_resources || !manifest.web_accessible_resources.length) return;
+    const mapResource = (resource)=>getFilename(normalizeOutputPath(resource), resource);
+    const entries = manifest.web_accessible_resources.map((entry)=>{
+        if ('string' == typeof entry) return mapResource(entry);
+        if (!entry || !Array.isArray(entry.resources)) return;
+        return {
+            ...entry,
+            resources: entry.resources.map(mapResource)
+        };
+    }).filter((entry)=>void 0 !== entry);
+    if (0 === entries.length) return;
+    return {
+        web_accessible_resources: entries
+    };
+}
+function contentSecurityPolicy(manifest) {
+    return manifest.content_security_policy && {
+        content_security_policy: manifest.content_security_policy
+    };
+}
+const omnibox_getBasename = (filepath)=>__rspack_external_path.basename(filepath);
+function omnibox_omnibox(manifest) {
+    const omnibox = manifest.omnibox;
+    return omnibox && {
+        omnibox: {
+            ...omnibox,
+            ...omnibox.default_icon && {
+                default_icon: 'string' == typeof omnibox.default_icon ? getFilename(`icons/${omnibox_getBasename(omnibox.default_icon)}`, omnibox.default_icon) : Object.fromEntries(Object.entries(omnibox.default_icon).map(([size, icon])=>[
+                        size,
+                        getFilename(`icons/${omnibox_getBasename(icon)}`, icon)
+                    ]))
+            }
+        }
+    };
+}
+function manifestCommon(manifest, manifestPath) {
+    return {
+        ...backgroundPage(manifest),
+        ...chromeUrlOverrides(manifest, manifestPath),
+        ...content_scripts_contentScripts(manifest, manifestPath),
+        ...devtoolsPage(manifest, manifestPath),
+        ...icons(manifest),
+        ...commands(manifest),
+        ...permissions(manifest),
+        ...optionsPage(manifest, manifestPath),
+        ...optionsUi(manifest, manifestPath),
+        ...sandbox(manifest),
+        ...storage(manifest),
+        ...theme(manifest),
+        ...userScripts(manifest),
+        ...webAccessibleResources(manifest),
+        ...contentSecurityPolicy(manifest),
+        ...omnibox_omnibox(manifest)
+    };
+}
+function getManifestOverrides(manifestPath, manifest) {
+    const manifestContent = manifest || JSON.parse(stripBom(__rspack_external_fs.readFileSync(manifestPath, 'utf8')));
+    const omit = (obj, key)=>{
+        if (!obj) return {};
+        const { [key]: _ignored, ...rest } = obj;
+        return rest;
+    };
+    const pickBackground = (obj)=>{
+        const value = obj.background;
+        return value && 'object' == typeof value ? value : {};
+    };
+    const common = manifestCommon(manifestContent, manifestPath);
+    const mv2 = manifestV2(manifestContent);
+    const mv3 = manifestV3(manifestContent);
+    const backgroundMerged = {
+        ...manifestContent.background || {},
+        ...pickBackground(common),
+        ...pickBackground(mv2),
+        ...pickBackground(mv3)
+    };
+    const merged = {
+        ...manifestContent,
+        ...omit(common, 'background'),
+        ...omit(mv2, 'background'),
+        ...omit(mv3, 'background')
+    };
+    if (Object.keys(backgroundMerged).length) merged.background = backgroundMerged;
+    return JSON.stringify(merged, null, 2);
+}
+function filterKeysForThisBrowser(manifest, browser) {
+    const isSafariTarget = 'safari' === browser || 'webkit-based' === browser || String(browser).includes('webkit');
+    const isChromiumTarget = isChromiumBasedBrowser(String(browser)) || isSafariTarget;
+    const isGeckoTarget = constants_isGeckoBasedBrowser(String(browser));
+    const chromiumPrefixes = new Set([
+        'chromium',
+        'chrome',
+        'edge'
+    ]);
+    const geckoPrefixes = new Set([
+        'gecko',
+        'firefox'
+    ]);
+    const webkitPrefixes = new Set([
+        'safari',
+        'webkit'
+    ]);
+    const isFamilyPrefix = (prefix)=>isChromiumTarget && chromiumPrefixes.has(prefix) || isGeckoTarget && geckoPrefixes.has(prefix);
+    const isSpecificPrefix = (prefix)=>prefix === browser || isSafariTarget && webkitPrefixes.has(prefix);
+    const resolve = (node)=>{
+        if (Array.isArray(node)) return node.map((item)=>resolve(item));
+        if (node && 'object' == typeof node) {
+            const result = {};
+            const familyMatches = {};
+            const specificMatches = {};
+            for (const [key, value] of Object.entries(node)){
+                const indexOfColon = key.indexOf(':');
+                if (-1 === indexOfColon) {
+                    result[key] = resolve(value);
+                    continue;
+                }
+                const prefix = key.substring(0, indexOfColon);
+                const strippedKey = key.substring(indexOfColon + 1);
+                if (isSpecificPrefix(prefix)) specificMatches[strippedKey] = resolve(value);
+                else if (isFamilyPrefix(prefix)) familyMatches[strippedKey] = resolve(value);
+            }
+            for (const [strippedKey, value] of Object.entries(familyMatches))result[strippedKey] = value;
+            for (const [strippedKey, value] of Object.entries(specificMatches))result[strippedKey] = value;
+            return result;
+        }
+        return node;
+    };
+    return resolve(manifest);
+}
+const manifest_cjsRequire = createRequire(import.meta.url);
+const INTERNAL_MANIFEST_SOURCE = '__extensionjs_manifest_source__';
+const INTERNAL_MANIFEST_CURRENT_SOURCE = '__extensionjs_manifest_current_source__';
+function readAssetSource(asset) {
+    if (!asset) return '';
+    const source = asset.source;
+    if ('string' == typeof source) return source;
+    if ('function' == typeof source) {
+        const out = source();
+        return 'string' == typeof out ? out : String(out || '');
+    }
+    if (source && 'function' == typeof source.source) {
+        const out = source.source();
+        return 'string' == typeof out ? out : String(out || '');
+    }
+    return '';
+}
+function setOriginalManifestContent(compilation, source) {
+    compilation[INTERNAL_MANIFEST_SOURCE] = source;
+}
+function getOriginalManifestContent(compilation) {
+    return compilation[INTERNAL_MANIFEST_SOURCE];
+}
+function setCurrentManifestContent(compilation, source) {
+    compilation[INTERNAL_MANIFEST_CURRENT_SOURCE] = source;
+}
+function getCurrentManifestContent(compilation) {
+    return compilation[INTERNAL_MANIFEST_CURRENT_SOURCE];
+}
+function getManifestContent(compilation, manifestPath) {
+    const currentManifest = getCurrentManifestContent(compilation);
+    if (currentManifest) return parseJsonSafe(currentManifest);
+    const getAsset = compilation.getAsset;
+    if ('function' == typeof getAsset) {
+        const manifestAsset = getAsset.call(compilation, 'manifest.json');
+        const manifest = readAssetSource(manifestAsset);
+        if (manifest) return parseJsonSafe(manifest);
+    }
+    const manifestAsset = compilation.assets?.['manifest.json'];
+    if (manifestAsset) {
+        const manifest = readAssetSource(manifestAsset);
+        if (manifest) return parseJsonSafe(manifest);
+    }
+    const originalManifest = getOriginalManifestContent(compilation);
+    if (originalManifest) return parseJsonSafe(originalManifest);
+    try {
+        const text = __rspack_external_fs.readFileSync(manifestPath, 'utf8');
+        return parseJsonSafe(text);
+    } catch  {
+        try {
+            const resolved = manifest_cjsRequire.resolve(manifestPath);
+            delete manifest_cjsRequire.cache[resolved];
+        } catch  {}
+        return manifest_cjsRequire(manifestPath);
+    }
+}
+function buildCanonicalManifest(manifestPath, manifest, browser) {
+    const filteredManifest = filterKeysForThisBrowser(manifest, browser);
+    return {
+        ...filteredManifest,
+        ...JSON.parse(getManifestOverrides(manifestPath, filteredManifest))
+    };
+}
+function backgroundIsRequiredMessageOnly(backgroundChunkName) {
+    return `Check the ${pintor.yellow(backgroundChunkName.replace('/', '.'))} field in your ${pintor.yellow('manifest.json')} file.`;
+}
+function createIssue(compiler, message, type = 'error') {
+    const ErrorCtor = compiler?.rspack?.WebpackError || Error;
+    const issue = new ErrorCtor(message);
+    issue.name = 'warning' === type ? 'ExtensionWarning' : 'ExtensionError';
+    return issue;
+}
+function reportToCompilation(compilation, compiler, message, type = 'error', file) {
+    const issue = createIssue(compiler, message, type);
+    if (file) issue.file = file;
+    const bucket = 'warning' === type ? 'warnings' : 'errors';
+    compilation[bucket] ||= [];
+    const already = compilation[bucket].some((e)=>(e?.file || '') === (issue.file || '') && String(e?.message) === String(issue.message));
+    if (already) return;
+    compilation[bucket].push(issue);
+}
+class SetupBackgroundEntry {
+    manifestPath;
+    browser;
+    constructor(options){
+        this.manifestPath = options.manifestPath;
+        this.browser = options.browser || 'chrome';
+    }
+    getMissingBackgroundError(bgFile) {
+        if (!__rspack_external_fs.existsSync(bgFile) && this.manifestPath) {
+            const manifest = JSON.parse(stripBom(__rspack_external_fs.readFileSync(this.manifestPath, 'utf8')));
+            const patched = filterKeysForThisBrowser(manifest, this.browser);
+            const fieldKey = 3 === patched.manifest_version ? 'background/service_worker' : "background/scripts";
+            return backgroundIsRequiredMessageOnly(fieldKey);
+        }
+    }
+    addDefaultEntry(compiler, name, defaultScript) {
+        compiler.options.entry = {
+            ...compiler.options.entry,
+            [name]: {
+                import: [
+                    defaultScript
+                ]
+            }
+        };
+    }
+    apply(compiler) {
+        const manifest = JSON.parse(stripBom(__rspack_external_fs.readFileSync(this.manifestPath, 'utf-8')));
+        const browser = this.browser;
+        const isGecko = constants_isGeckoBasedBrowser(String(browser));
+        const minimumBgScript = resolveDevelopDistFile(isGecko ? 'minimum-firefox-file' : 'minimum-chromium-file');
+        const dirname = __rspack_external_path.dirname(this.manifestPath);
+        const filteredManifest = filterKeysForThisBrowser(manifest, browser) || manifest;
+        const manifestBg = filteredManifest?.background ?? manifest.background;
+        const manifestVersion = filteredManifest?.manifest_version ?? manifest.manifest_version;
+        function hookError(maybeError) {
+            compiler.hooks.thisCompilation.tap('run-chromium:setup-background-entry', (compilation)=>{
+                reportToCompilation(compilation, compiler, maybeError, 'error');
+            });
+        }
+        if (isGecko) {
+            const bgScripts = manifestBg?.scripts;
+            if (bgScripts && bgScripts.length > 0) {
+                const bgScriptPath = __rspack_external_path.join(dirname, bgScripts[0]);
+                const maybeError = this.getMissingBackgroundError(bgScriptPath);
+                if (maybeError) hookError(maybeError);
+            } else this.addDefaultEntry(compiler, "background/script", minimumBgScript);
+            return;
+        }
+        if (2 === manifestVersion) {
+            const bgScripts = manifestBg?.scripts;
+            if (bgScripts && bgScripts.length > 0) {
+                const bgScriptPath = __rspack_external_path.join(dirname, bgScripts[0]);
+                const maybeError = this.getMissingBackgroundError(bgScriptPath);
+                if (maybeError) hookError(maybeError);
+            } else this.addDefaultEntry(compiler, "background/script", minimumBgScript);
+        } else {
+            const serviceWorker = manifestBg?.service_worker;
+            if (serviceWorker) {
+                const swPath = __rspack_external_path.join(dirname, serviceWorker);
+                const maybeError = this.getMissingBackgroundError(swPath);
+                if (maybeError) hookError(maybeError);
+                const existingEntry = compiler.options.entry && 'background/service_worker' in compiler.options.entry ? compiler.options.entry['background/service_worker'] : void 0;
+                if (!existingEntry && __rspack_external_fs.existsSync(swPath)) this.addDefaultEntry(compiler, 'background/service_worker', swPath);
+            } else this.addDefaultEntry(compiler, 'background/service_worker', minimumBgScript);
+        }
+    }
+}
+class SetupReloadStrategy {
+    manifestPath;
+    browser;
+    constructor(options){
+        this.manifestPath = options.manifestPath;
+        this.browser = options.browser || 'chrome';
+    }
+    getEntryName(manifest) {
+        if (manifest.background) {
+            if (constants_isGeckoBasedBrowser(String(this.browser))) return {
+                pageEntry: "background/script",
+                tryCatchWrapper: true,
+                eagerChunkLoading: false
+            };
+            if (3 === manifest.manifest_version) return {
+                serviceWorkerEntry: 'background/service_worker',
+                tryCatchWrapper: true,
+                eagerChunkLoading: false
+            };
+            if (2 === manifest.manifest_version) return {
+                pageEntry: "background/script",
+                tryCatchWrapper: true,
+                eagerChunkLoading: false
+            };
+        }
+        return {
+            pageEntry: 'background',
+            tryCatchWrapper: true,
+            eagerChunkLoading: false
+        };
+    }
+    apply(compiler) {
+        const manifest = JSON.parse(stripBom(__rspack_external_fs.readFileSync(this.manifestPath, 'utf-8')));
+        const patchedManifest = filterKeysForThisBrowser(manifest, this.browser);
+        const contentScriptsMeta = {};
+        try {
+            const csList = Array.isArray(patchedManifest.content_scripts) ? patchedManifest.content_scripts : [];
+            const originalCount = csList.length;
+            let bridgeOrdinal = 0;
+            for(let i = 0; i < csList.length; i++){
+                const cs = csList[i];
+                const bundleId = getCanonicalContentScriptJsAssetName(i);
+                const isMain = cs?.world === 'MAIN';
+                if (isMain) {
+                    const bridgeIndex = originalCount + bridgeOrdinal++;
+                    const bridgeBundleId = getCanonicalContentScriptJsAssetName(bridgeIndex);
+                    contentScriptsMeta[bundleId] = {
+                        index: i,
+                        bundleId,
+                        world: 'main',
+                        bridgeBundleId
+                    };
+                    contentScriptsMeta[bridgeBundleId] = {
+                        index: bridgeIndex,
+                        bundleId: bridgeBundleId,
+                        world: 'extension',
+                        role: 'main_world_bridge',
+                        mainBundleId: bundleId
+                    };
+                } else contentScriptsMeta[bundleId] = {
+                    index: i,
+                    bundleId,
+                    world: 'extension'
+                };
+            }
+        } catch  {}
+        new SetupBackgroundEntry({
+            manifestPath: this.manifestPath,
+            browser: this.browser
+        }).apply(compiler);
+        new webpack_target_webextension_fork({
+            background: this.getEntryName(patchedManifest),
+            hmrConfig: false,
+            weakRuntimeCheck: true,
+            contentScriptsMeta
+        }).apply(compiler);
+    }
+}
+const DEV_SERVER_STRONG_MARKERS = [
+    '@rspack/dev-server/client/index.js?',
+    '@rspack/dev-server/client/utils/ansiHTML.js',
+    '[HMR] Waiting for update signal from WDS...'
+];
+const DEV_SERVER_WEAK_MARKERS = [
+    'webpack-dev-server',
+    'WebSocketClient',
+    '.hot.check()',
+    '[HMR] Cannot find update. Need to do a full reload!'
+];
+function contentScriptRetainsDevServerRuntime(source) {
+    return source.includes('@rspack/dev-server/client');
+}
+function stripDevServerStartupFromContentScript(source) {
+    let nextSource = source;
+    const startupModuleIds = getStartupModuleIds(source);
+    for (const moduleId of startupModuleIds){
+        const moduleBody = getModuleBody(source, moduleId);
+        if (!moduleBody) continue;
+        const strongHit = DEV_SERVER_STRONG_MARKERS.some((marker)=>moduleBody.includes(marker));
+        const weakHits = DEV_SERVER_WEAK_MARKERS.filter((marker)=>moduleBody.includes(marker)).length;
+        if (strongHit || weakHits >= 2) nextSource = stripStartupRequire(nextSource, moduleId);
+    }
+    return nextSource;
+}
+function getStartupModuleIds(source) {
+    const startupIndex = source.indexOf('// startup');
+    if (-1 === startupIndex) return [];
+    const startupSection = source.slice(startupIndex);
+    const requirePattern = /__webpack_require__\((\d+)\);/g;
+    const ids = [];
+    let match = null;
+    while(match = requirePattern.exec(startupSection))ids.push(match[1]);
+    return ids;
+}
+function getModuleBody(source, moduleId) {
+    const moduleHeaderPattern = new RegExp(`(?:^|\\n)${moduleId}\\([^)]*\\)\\s*\\{`, 'm');
+    const headerMatch = moduleHeaderPattern.exec(source);
+    if (!headerMatch) return null;
+    const moduleStart = headerMatch.index;
+    const nextHeaderPattern = /(?:^|\n)\d+\([^)]*\)\s*\{/g;
+    nextHeaderPattern.lastIndex = moduleStart + headerMatch[0].length;
+    const nextHeaderMatch = nextHeaderPattern.exec(source);
+    return source.slice(moduleStart, nextHeaderMatch ? nextHeaderMatch.index : source.length);
+}
+function stripStartupRequire(source, moduleId) {
+    const startupRequirePattern = new RegExp(`^\\s*__webpack_require__\\(${moduleId}\\);\\n?`, 'm');
+    return source.replace(startupRequirePattern, '');
+}
+const CONTENT_SCRIPT_ASSET = /(^|\/)content_scripts\/content-\d+(?:\.[a-f0-9]+)?\.js$/i;
+class StripContentScriptDevServerRuntime {
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(StripContentScriptDevServerRuntime.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: StripContentScriptDevServerRuntime.name,
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT
+            }, ()=>{
+                for (const asset of compilation.getAssets()){
+                    if (!CONTENT_SCRIPT_ASSET.test(asset.name)) continue;
+                    const originalSource = asset.source.source().toString();
+                    const strippedSource = stripDevServerStartupFromContentScript(originalSource);
+                    if (strippedSource !== originalSource) compilation.updateAsset(asset.name, new core_sources.RawSource(strippedSource));
+                    if (contentScriptRetainsDevServerRuntime(strippedSource)) {
+                        const warning = new core_WebpackError(`Could not strip the dev-server runtime from ${asset.name}. This usually means the bundler's output format changed and Extension.js needs an update. The content script may try to open a dev-server connection on the host page. Please report this at https://github.com/extension-js/extension.js/issues.`);
+                        warning.name = 'ContentScriptDevServerRuntimeWarning';
+                        warning.file = asset.name;
+                        compilation.warnings ||= [];
+                        compilation.warnings.push(warning);
+                    }
+                }
+            });
+        });
+    }
+}
+const SCRIPTS_REPLAY_SHIM_SOURCE = `;(function () {
+  try {
+    if (typeof globalThis !== "object" || !globalThis) return;
+    var chromeRef =
+      (globalThis.chrome && globalThis.chrome.scripting && typeof globalThis.chrome.scripting.executeScript === "function")
+        ? globalThis.chrome
+        : (globalThis.browser && globalThis.browser.scripting && typeof globalThis.browser.scripting.executeScript === "function")
+          ? globalThis.browser
+          : null;
+    if (!chromeRef) return;
+    if (globalThis.__extjsScriptsReplayInstalled) return;
+    globalThis.__extjsScriptsReplayInstalled = true;
+
+    var registry = new Map();
+    var originalExecuteScript = chromeRef.scripting.executeScript.bind(chromeRef.scripting);
+
+    var serialize = function (entry) {
+      try {
+        return JSON.stringify({
+          files: entry && Array.isArray(entry.files) ? entry.files : [],
+          world: entry && entry.world ? String(entry.world) : ""
+        });
+      } catch (error) {
+        return "";
+      }
+    };
+
+    var track = function (injection) {
+      try {
+        var tabId = injection && injection.target && injection.target.tabId;
+        var files =
+          injection && Array.isArray(injection.files) ? injection.files.slice() : null;
+        if (typeof tabId !== "number") return;
+        if (!files || !files.length) return;
+        var world = injection.world ? String(injection.world) : undefined;
+        var entry = { files: files, world: world, sig: serialize({ files: files, world: world }) };
+        var existing = registry.get(tabId) || [];
+        // Dedupe by signature — repeated identical injections (e.g. user
+        // clicks the action twice) shouldn't stack in the replay list.
+        if (existing.some(function (e) { return e.sig === entry.sig; })) return;
+        existing.push(entry);
+        // Cap to the most recent 50 distinct injections per tab so a misbehaving
+        // user loop can't grow the registry unbounded.
+        registry.set(tabId, existing.slice(-50));
+      } catch (error) {
+        // Tracking is best-effort; never break the user's executeScript call.
+      }
+    };
+
+    chromeRef.scripting.executeScript = function (injection, callback) {
+      track(injection);
+      return originalExecuteScript(injection, callback);
+    };
+
+    var normalizeFile = function (value) {
+      return String(value || "").replace(/^[/\\\\]+/, "");
+    };
+
+    var fileMatches = function (entryFile, changedNormalized) {
+      var fn = normalizeFile(entryFile);
+      for (var i = 0; i < changedNormalized.length; i++) {
+        var c = changedNormalized[i];
+        if (!c) continue;
+        if (fn === c) return true;
+        if (fn.length > c.length && fn.slice(fn.length - c.length - 1) === "/" + c) return true;
+        if (c.length > fn.length && c.slice(c.length - fn.length - 1) === "/" + fn) return true;
+      }
+      return false;
+    };
+
+    globalThis.__extjsScriptsReplay = function (changedFiles) {
+      var changedNormalized = (Array.isArray(changedFiles) ? changedFiles : []).map(normalizeFile);
+      var promises = [];
+      registry.forEach(function (entries, tabId) {
+        entries.forEach(function (entry) {
+          var matches = false;
+          for (var i = 0; i < entry.files.length; i++) {
+            if (fileMatches(entry.files[i], changedNormalized)) {
+              matches = true;
+              break;
+            }
+          }
+          if (!matches) return;
+          try {
+            promises.push(
+              originalExecuteScript({
+                target: { tabId: tabId },
+                files: entry.files,
+                world: entry.world
+              }).then(
+                function () { return { ok: true, tabId: tabId, files: entry.files }; },
+                function (error) {
+                  return {
+                    ok: false,
+                    tabId: tabId,
+                    files: entry.files,
+                    error: String((error && error.message) || error)
+                  };
+                }
+              )
+            );
+          } catch (error) {
+            // Tab may have closed; skip silently.
+          }
+        });
+      });
+      return Promise.all(promises);
+    };
+  } catch (error) {
+    // Best-effort shim; do not break the SW bootstrap on any failure.
+  }
+})();
+`;
+const BACKGROUND_ASSET = /(^|\/)background\/(?:service_worker|script)\.js$/i;
+class InjectScriptsReplayShim {
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(InjectScriptsReplayShim.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: InjectScriptsReplayShim.name,
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 100
+            }, ()=>{
+                for (const asset of compilation.getAssets()){
+                    if (!BACKGROUND_ASSET.test(asset.name)) continue;
+                    const original = asset.source.source().toString();
+                    if (-1 !== original.indexOf('__extjsScriptsReplayInstalled')) continue;
+                    const next = SCRIPTS_REPLAY_SHIM_SOURCE + '\n' + original;
+                    compilation.updateAsset(asset.name, new core_sources.RawSource(next));
+                }
+            });
+        });
+    }
+}
+const BRIDGE_PRODUCER_SOURCE = `;(function () {
+  try {
+    var g = (typeof globalThis === "object" && globalThis) ? globalThis : this;
+    if (!g || g.__extjsBridgeProducerInstalled) return;
+
+    var PORT = parseInt("__EXTJS_CONTROL_PORT__", 10);
+    var INSTANCE_ID = "__EXTJS_INSTANCE_ID__";
+    var CONTEXT = "__EXTJS_CONTEXT__";
+    // Connectable host of the dev-server control WS. Baked from the resolved
+    // connectable host (loopback locally; the public host for remote/devcontainer).
+    var HOST = "__EXTJS_CONTROL_HOST__";
+    if (!HOST || HOST.indexOf("__EXTJS") === 0) HOST = "127.0.0.1";
+    if (!PORT || PORT < 1) return;
+
+    var WS = g.WebSocket;
+    if (typeof WS !== "function") return;
+
+    var consoleRef = g.console || {};
+    g.__extjsBridgeProducerInstalled = true;
+
+    // Capture extension event listeners at install time. The producer is
+    // prepended to the background bundle, so these wraps run BEFORE user code
+    // registers its listeners — letting the bridge replay them on demand. The
+    // platform exposes no API to dispatch these events, and CDP attaches too
+    // late to wrap addListener, so this is the only path. Replay invokes the
+    // handler WITHOUT a user gesture, so the gesture-derived activeTab grant
+    // does NOT apply (callers are told gesture:false). This is engine-agnostic:
+    // it works on Chromium and Gecko because it only touches addListener.
+    //
+    // captureEvent transparently wraps addListener/removeListener (delegating to
+    // the originals) and records callbacks into the sink array.
+    function captureEvent(event, sink) {
+      try {
+        if (!event || typeof event.addListener !== "function") return;
+        var origAdd = event.addListener.bind(event);
+        event.addListener = function (cb) {
+          if (typeof cb === "function" && sink.indexOf(cb) === -1) sink.push(cb);
+          return origAdd(cb);
+        };
+        if (typeof event.removeListener === "function") {
+          var origRemove = event.removeListener.bind(event);
+          event.removeListener = function (cb) {
+            var i = sink.indexOf(cb);
+            if (i !== -1) sink.splice(i, 1);
+            return origRemove(cb);
+          };
+        }
+      } catch (e) { /* non-fatal: trigger falls back to its no-listener reply */ }
+    }
+
+    // Use g.chrome (not the hoisted chrome var below) — this runs first.
+    var actionClickedListeners = [];
+    var commandListeners = [];
+    if (g.chrome) {
+      captureEvent(g.chrome.action && g.chrome.action.onClicked, actionClickedListeners);
+      captureEvent(g.chrome.commands && g.chrome.commands.onCommand, commandListeners);
+    }
+
+    var LEVELS = ["log", "info", "warn", "error", "debug", "trace"];
+    var socket = null;
+    var open = false;
+    var queue = [];
+    var backoff = 250;
+    var MAX_BACKOFF = 5000;
+    var MAX_QUEUE = 1000;
+    var MAX_RESULT_BYTES = 256 * 1024;
+
+    function nowId() {
+      return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+    }
+
+    function engineName() {
+      try {
+        return (typeof navigator !== "undefined" && /firefox/i.test(navigator.userAgent)) ? "firefox" : "chromium";
+      } catch (e) { return "chromium"; }
+    }
+
+    // JSON-safe, byte-capped clone of a result value.
+    function safeValue(v) {
+      try {
+        var s = JSON.stringify(v);
+        if (s === undefined) return {value: undefined, truncated: false};
+        if (s.length > MAX_RESULT_BYTES) {
+          return {value: {__type: "truncated", preview: s.slice(0, 1024)}, truncated: true};
+        }
+        return {value: JSON.parse(s), truncated: false};
+      } catch (e) {
+        return {value: {__type: "unserializable", preview: String(v).slice(0, 512)}, truncated: false};
+      }
+    }
+
+    function replyOk(cmdId, value) {
+      var s = safeValue(value);
+      var frame = {type: "result", cmdId: cmdId, ok: true, value: s.value};
+      if (s.truncated) frame.truncated = true;
+      try { socket && socket.send(JSON.stringify(frame)); } catch (e) {}
+    }
+
+    function replyErr(cmdId, name, message) {
+      var frame = {type: "result", cmdId: cmdId, ok: false, error: {name: name, message: String(message), engine: engineName()}};
+      try { socket && socket.send(JSON.stringify(frame)); } catch (e) {}
+    }
+
+    // Execute one authorized command in the SW (or route to a tab). chrome.*
+    // promise APIs are used; callback-only APIs are wrapped.
+    function executeCommand(cmd) {
+      var op = cmd.op, target = cmd.target || {}, args = cmd.args || {};
+      var ctx = target.context || "background";
+      var chrome = g.chrome;
+      var cmdId = cmd.cmdId;
+      try {
+        if (!chrome) { replyErr(cmdId, "Unsupported", "chrome.* not available in this context"); return; }
+        if (op === "eval") {
+          if (ctx === "background") {
+            Promise.resolve().then(function () { return (0, eval)(args.expression); })
+              .then(function (r) { replyOk(cmdId, r); }, function (e) {
+                var msg = (e && e.message) || String(e);
+                // MV3 forbids eval of strings in the SW/extension pages; Chrome
+                // rejects 'unsafe-eval' in MV3 extension_pages, so this can't be
+                // relaxed. Surface it honestly with a usable alternative.
+                if (/Content Security Policy|unsafe-eval/i.test(msg)) {
+                  replyErr(cmdId, "Unsupported", "eval is blocked in the MV3 service worker by CSP. Use --context page --tab <id> (eval runs in the page's MAIN world), or run on an MV2/Firefox build. Engine: " + engineName());
+                } else {
+                  replyErr(cmdId, (e && e.name) || "EvalError", msg);
+                }
+              });
+          } else if ((ctx === "content" || ctx === "page") && target.tabId && chrome.scripting) {
+            chrome.scripting.executeScript({
+              target: {tabId: target.tabId},
+              world: ctx === "page" ? "MAIN" : "ISOLATED",
+              func: function (src) { return eval(src); },
+              args: [String(args.expression)]
+            }).then(function (res) { replyOk(cmdId, res && res[0] ? res[0].result : undefined); },
+                    function (e) { replyErr(cmdId, "EvalError", e); });
+          } else {
+            replyErr(cmdId, "Unsupported", "eval in context " + ctx + " requires a tabId");
+          }
+          return;
+        }
+        if (op === "storage.get") {
+          chrome.storage[args.area || "local"].get(args.key != null ? args.key : null)
+            .then(function (r) { replyOk(cmdId, r); }, function (e) { replyErr(cmdId, "StorageError", e); });
+          return;
+        }
+        if (op === "storage.set") {
+          chrome.storage[args.area || "local"].set(args.items || {})
+            .then(function () { replyOk(cmdId, {set: Object.keys(args.items || {})}); }, function (e) { replyErr(cmdId, "StorageError", e); });
+          return;
+        }
+        if (op === "reload") {
+          if (ctx === "background") {
+            replyOk(cmdId, {reloading: true});
+            setTimeout(function () { try { chrome.runtime.reload(); } catch (e) {} }, 50);
+          } else if (target.tabId) {
+            chrome.tabs.reload(target.tabId).then(function () { replyOk(cmdId, {reloaded: target.tabId}); }, function (e) { replyErr(cmdId, "ReloadError", e); });
+          } else {
+            replyErr(cmdId, "Unsupported", "reload needs background or a tabId");
+          }
+          return;
+        }
+        if (op === "open") {
+          var surface = args.surface || ctx;
+          // getPopup is promise-style on Gecko and (MV3) Chromium; fall back to
+          // callback-style for older Chromium. Always resolves to a string.
+          var getActionPopup = function (cb) {
+            try {
+              var r = chrome.action && chrome.action.getPopup && chrome.action.getPopup({});
+              if (r && typeof r.then === "function") {
+                r.then(function (p) { cb(p || ""); }, function () { cb(""); });
+                return;
+              }
+            } catch (e) {}
+            try { chrome.action.getPopup({}, function (p) { cb(p || ""); }); }
+            catch (e) { cb(""); }
+          };
+          // Resolve the tab a replayed event should carry: an explicit args.tabId,
+          // else the active tab of the focused window.
+          var resolveActiveTab = function (a, cb) {
+            if (a && typeof a.tabId === "number") {
+              try { chrome.tabs.get(a.tabId, function (t) { cb(t || {id: a.tabId}); }); return; }
+              catch (e) {}
+            }
+            try { chrome.tabs.query({active: true, lastFocusedWindow: true}, function (tabs) { cb((tabs && tabs[0]) || undefined); }); }
+            catch (e) { cb(undefined); }
+          };
+          // Replaying a listener carries no user gesture, so activeTab is never
+          // granted. Warn when the manifest declares it (handler will diverge
+          // from a real click).
+          var activeTabWarning = function () {
+            try {
+              var m = chrome.runtime.getManifest();
+              var perms = (m && m.permissions) || [];
+              if (perms.indexOf("activeTab") !== -1) {
+                return "replayed without a user gesture: activeTab is NOT granted, so APIs that depend on it (scripting on the active tab, captureVisibleTab) behave differently than a real click";
+              }
+            } catch (e) {}
+            return null;
+          };
+          if (surface === "popup") {
+            if (chrome.action && chrome.action.openPopup) {
+              chrome.action.openPopup().then(function () { replyOk(cmdId, {opened: "popup"}); }, function (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); });
+            } else { replyErr(cmdId, "Unsupported", "action.openPopup not available"); }
+          } else if (surface === "options") {
+            try { chrome.runtime.openOptionsPage(function () { replyOk(cmdId, {opened: "options"}); }); }
+            catch (e) { replyErr(cmdId, "Unsupported", "openOptionsPage: " + e); }
+          } else if (surface === "sidebar") {
+            if (chrome.sidePanel && chrome.sidePanel.open && chrome.windows) {
+              chrome.windows.getCurrent(function (w) {
+                chrome.sidePanel.open({windowId: w.id}).then(function () { replyOk(cmdId, {opened: "sidebar"}); }, function (e) { replyErr(cmdId, "Unsupported", "sidePanel.open: " + e); });
+              });
+            } else { replyErr(cmdId, "Unsupported", "sidePanel not available (engine: " + engineName() + ")"); }
+          } else if (surface === "action") {
+            // Trigger the toolbar action. With a default_popup, clicking the icon
+            // opens it (reuse openPopup). Without a popup, clicking fires
+            // chrome.action.onClicked — we replay the listeners captured at install.
+            if (chrome.action) {
+              getActionPopup(function (popup) {
+                if (popup) {
+                  try {
+                    chrome.action.openPopup().then(function () { replyOk(cmdId, {triggered: "popup"}); }, function (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); });
+                  } catch (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); }
+                } else if (actionClickedListeners.length) {
+                  resolveActiveTab(args, function (tab) {
+                    var fired = 0;
+                    for (var i = 0; i < actionClickedListeners.length; i++) {
+                      try { actionClickedListeners[i](tab); fired++; } catch (e) {}
+                    }
+                    var reply = {triggered: "onClicked", listeners: fired, gesture: false};
+                    var warning = activeTabWarning();
+                    if (warning) reply.warning = warning;
+                    replyOk(cmdId, reply);
+                  });
+                } else {
+                  replyErr(cmdId, "Unsupported", "action has no popup and no onClicked listener registered");
+                }
+              });
+            } else { replyErr(cmdId, "Unsupported", "chrome.action not available (engine: " + engineName() + ")"); }
+          } else if (surface === "command") {
+            // Replay a captured chrome.commands.onCommand listener (keyboard
+            // shortcut). Same no-gesture caveat as onClicked.
+            var commandName = (args && args.name) || undefined;
+            if (!commandListeners.length) {
+              replyErr(cmdId, "Unsupported", "no chrome.commands.onCommand listener registered");
+            } else {
+              resolveActiveTab(args, function (tab) {
+                var fired = 0;
+                for (var i = 0; i < commandListeners.length; i++) {
+                  try { commandListeners[i](commandName, tab); fired++; } catch (e) {}
+                }
+                replyOk(cmdId, {triggered: "command", command: commandName || null, listeners: fired, gesture: false});
+              });
+            }
+          } else { replyErr(cmdId, "BadRequest", "unknown surface: " + surface); }
+          return;
+        }
+        if (op === "tabs.query") {
+          chrome.tabs.query(args || {}).then(function (tabs) {
+            replyOk(cmdId, (tabs || []).map(function (t) { return {id: t.id, url: t.url, title: t.title, active: t.active, windowId: t.windowId}; }));
+          }, function (e) { replyErr(cmdId, "TabsError", e); });
+          return;
+        }
+        if (op === "inspect") {
+          // Slice 3 sidecar/default path: extract a DOM snapshot from the target
+          // page via chrome.scripting (CDP-free). Closed shadow roots need the
+          // --deep-dom CDP escape hatch (separate tool); here we read open ones.
+          if ((ctx === "content" || ctx === "page") && target.tabId && chrome.scripting) {
+            var maxBytes = (args && args.maxBytes) || 262144;
+            var includeHtml = !args || !args.include || args.include.indexOf("html") !== -1;
+            chrome.scripting.executeScript({
+              target: {tabId: target.tabId},
+              world: ctx === "page" ? "MAIN" : "ISOLATED",
+              func: function (wantHtml, cap) {
+                function countShadow(root) {
+                  var n = 0, els = root.querySelectorAll("*");
+                  for (var i = 0; i < els.length; i++) { if (els[i].shadowRoot) { n++; n += countShadow(els[i].shadowRoot); } }
+                  return n;
+                }
+                var doc = document;
+                var roots = doc.querySelectorAll('#extension-root,[data-extension-root]');
+                var out = {
+                  url: location.href,
+                  title: doc.title,
+                  summary: {
+                    htmlLength: doc.documentElement.outerHTML.length,
+                    scriptCount: doc.querySelectorAll("script").length,
+                    styleCount: doc.querySelectorAll("style,link[rel=stylesheet]").length,
+                    extensionRootCount: roots.length,
+                    openShadowRoots: countShadow(doc),
+                    bodyChildCount: doc.body ? doc.body.children.length : 0
+                  }
+                };
+                if (wantHtml) {
+                  var html = doc.documentElement.outerHTML;
+                  if (cap > 0 && html.length > cap) { out.html = html.slice(0, cap); out.htmlTruncated = true; }
+                  else { out.html = html; }
+                }
+                return out;
+              },
+              args: [includeHtml, maxBytes]
+            }).then(function (res) { replyOk(cmdId, res && res[0] ? res[0].result : undefined); },
+                    function (e) { replyErr(cmdId, "InspectError", e); });
+          } else if (ctx === "popup" || ctx === "options" || ctx === "sidebar" || ctx === "devtools") {
+            // The SW can't read a surface page's DOM; ask the surface's own
+            // in-bundle relay (only the open, matching-context page responds).
+            chrome.runtime.sendMessage(
+              {__extjsInspectRequest: true, target: target, args: args},
+              function (resp) {
+                if (chrome.runtime.lastError || !resp) {
+                  replyErr(cmdId, "Unsupported", "surface '" + ctx + "' is not open (open it first: extension open " + ctx + ")");
+                } else if (resp.ok) {
+                  replyOk(cmdId, resp.value);
+                } else {
+                  replyErr(cmdId, (resp.error && resp.error.name) || "InspectError", (resp.error && resp.error.message) || "inspect failed");
+                }
+              }
+            );
+          } else if (ctx === "background") {
+            replyErr(cmdId, "Unsupported", "the service worker has no DOM; inspect a content/page (with --tab) or an open surface");
+          } else {
+            replyErr(cmdId, "Unsupported", "inspect of " + ctx + " requires a tabId (content/page) or an open surface");
+          }
+          return;
+        }
+        replyErr(cmdId, "BadRequest", "unknown op: " + op);
+      } catch (e) {
+        replyErr(cmdId, "ExecutorError", e);
+      }
+    }
+
+    function noopLastError() { try { void g.chrome.runtime.lastError; } catch (e) {} }
+
+    // Only http(s)/file/ftp tabs can run a content script; skip chrome://, the
+    // extension's own pages, about:blank, etc.
+    function isInjectableUrl(url) {
+      return typeof url === "string" && /^(https?|file|ftp):/i.test(url);
+    }
+
+    // Re-inject a single declared content-script entry's fresh files into every
+    // open tab it matches, in place. The wrapper's reinject runtime tears down
+    // the previous mount (matched by data-extjs-reinject-owner + build hash) and
+    // mounts the new one — so this is the controller-less equivalent of the CDP
+    // controller's reinjection, just driven from inside the extension.
+    //
+    // exclude_matches MUST be honored: the browser's own static injection never
+    // touches excluded pages, and extensions can rely on that (e.g. a script
+    // whose message handler opens the very page it excludes — injecting there
+    // anyway creates an open-a-tab → inject → open-a-tab runaway loop). Chrome's
+    // tabs.query has no exclude support, so query the exclude patterns
+    // separately and subtract — the browser stays the single pattern matcher.
+    function reinjectContentScriptEntry(entry) {
+      var chrome = g.chrome;
+      var matches = (entry && entry.matches) || [];
+      if (!Array.isArray(matches) || !matches.length) return;
+      var excludeMatches = (entry && entry.exclude_matches) || [];
+      var jsFiles = ((entry && entry.js) || []).filter(function (f) { return typeof f === "string"; });
+      var cssFiles = ((entry && entry.css) || []).filter(function (f) { return typeof f === "string"; });
+      if (!jsFiles.length && !cssFiles.length) return;
+      var world = entry.world === "MAIN" ? "MAIN" : "ISOLATED";
+      var allFrames = !!entry.all_frames;
+      function injectInto(excludedTabIds) {
+        try {
+          chrome.tabs.query({url: matches}, function (tabs) {
+            var err = null;
+            try { err = chrome.runtime.lastError; } catch (e) {}
+            if (err || !tabs) return;
+            for (var i = 0; i < tabs.length; i++) {
+              (function (tab) {
+                if (!tab || tab.id == null || !isInjectableUrl(tab.url)) return;
+                if (excludedTabIds[tab.id]) return;
+                var target = {tabId: tab.id, allFrames: allFrames};
+                if (cssFiles.length && chrome.scripting.insertCSS) {
+                  try { chrome.scripting.insertCSS({target: target, files: cssFiles}, noopLastError); } catch (e) {}
+                }
+                if (jsFiles.length && chrome.scripting.executeScript) {
+                  try {
+                    chrome.scripting.executeScript(
+                      {target: target, files: jsFiles, world: world, injectImmediately: true},
+                      noopLastError
+                    );
+                  } catch (e) {}
+                }
+              })(tabs[i]);
+            }
+          });
+        } catch (e) {}
+      }
+      if (Array.isArray(excludeMatches) && excludeMatches.length) {
+        try {
+          chrome.tabs.query({url: excludeMatches}, function (excludedTabs) {
+            try { void chrome.runtime.lastError; } catch (e) {}
+            var excluded = {};
+            if (excludedTabs) {
+              for (var i = 0; i < excludedTabs.length; i++) {
+                if (excludedTabs[i] && excludedTabs[i].id != null) excluded[excludedTabs[i].id] = true;
+              }
+            }
+            injectInto(excluded);
+          });
+          return;
+        } catch (e) {}
+      }
+      injectInto({});
+    }
+
+    // Re-inject all content scripts into their open tabs. Reads the manifest
+    // FROM DISK (not chrome.runtime.getManifest(), which is frozen at extension-
+    // registration time) because dev content-script filenames are content-hashed
+    // and change on every edit — disk has the new js/css paths.
+    function reinjectContentScripts(onDone) {
+      var chrome = g.chrome;
+      try {
+        if (typeof g.fetch !== "function" || !chrome.scripting) return false;
+        g.fetch(chrome.runtime.getURL("manifest.json"), {cache: "no-store"})
+          .then(function (r) { return r.json(); })
+          .then(function (manifest) {
+            var entries = (manifest && manifest.content_scripts) || [];
+            for (var i = 0; i < entries.length; i++) reinjectContentScriptEntry(entries[i]);
+            reregisterForFutureNavigations(entries);
+            if (onDone) { try { onDone(); } catch (e) {} }
+          })
+          .catch(function () {});
+        return true;
+      } catch (e) { return false; }
+    }
+
+    function mapRunAt(runAt) {
+      if (runAt === "document_start") return "document_start";
+      if (runAt === "document_end") return "document_end";
+      return "document_idle";
+    }
+
+    // Re-register the content scripts dynamically (chrome.scripting) pointing at
+    // the fresh files, so tabs opened AFTER an edit also get the new build. The
+    // static manifest registration still points at the old content-hashed file
+    // (it only updates on an extension reload) and keeps firing on new
+    // navigations; the dynamic registration injects the new file alongside it,
+    // and the wrapper's reinject runtime converges the mount to the newest build.
+    // Idempotent: update an existing id, else register it.
+    function reregisterForFutureNavigations(entries) {
+      var chrome = g.chrome;
+      if (
+        !chrome.scripting ||
+        !chrome.scripting.registerContentScripts ||
+        !chrome.scripting.getRegisteredContentScripts
+      ) return;
+
+      var scripts = [];
+      for (var i = 0; i < entries.length; i++) {
+        var e = entries[i] || {};
+        if (!Array.isArray(e.matches) || !e.matches.length) continue;
+        var js = (e.js || []).filter(function (f) { return typeof f === "string"; });
+        var css = (e.css || []).filter(function (f) { return typeof f === "string"; });
+        if (!js.length && !css.length) continue;
+        var s = {
+          id: "extjs-dev-cs-" + i,
+          matches: e.matches,
+          runAt: mapRunAt(e.run_at),
+          allFrames: !!e.all_frames,
+          world: e.world === "MAIN" ? "MAIN" : "ISOLATED"
+        };
+        // Dev registration must not be BROADER than the static one: dropping
+        // exclude_matches injects into pages the browser itself would skip.
+        if (Array.isArray(e.exclude_matches) && e.exclude_matches.length) {
+          s.excludeMatches = e.exclude_matches;
+        }
+        if (js.length) s.js = js;
+        if (css.length) s.css = css;
+        scripts.push(s);
+      }
+      if (!scripts.length) return;
+
+      try {
+        chrome.scripting.getRegisteredContentScripts(function (existing) {
+          try { void chrome.runtime.lastError; } catch (e) {}
+          var have = {};
+          if (existing) for (var k = 0; k < existing.length; k++) have[existing[k].id] = true;
+          var toRegister = [], toUpdate = [];
+          for (var j = 0; j < scripts.length; j++) {
+            (have[scripts[j].id] ? toUpdate : toRegister).push(scripts[j]);
+          }
+          if (toRegister.length) {
+            try { chrome.scripting.registerContentScripts(toRegister, noopLastError); } catch (e) {}
+          }
+          if (toUpdate.length) {
+            try { chrome.scripting.updateContentScripts(toUpdate, noopLastError); } catch (e) {}
+          }
+        });
+      } catch (e) {}
+    }
+
+    // Perform a dev-loop reload without the CDP controller:
+    //   - content-scripts: re-inject the fresh script into open matching tabs in
+    //     place (no extension restart), the controller-less equivalent of CDP
+    //     reinjection. Needs the scripting permission + host access to the tab —
+    //     both injected in dev by ApplyDevDefaults. Falls back to a full reload
+    //     if scripting is unavailable.
+    //   - service-worker / full / manifest: restart the whole extension so it
+    //     re-registers from the fresh manifest.
+    function performDevReload(type, onDone) {
+      var chrome = g.chrome;
+      if (!chrome) return;
+
+      var fullReload = function () {
+        // Leave a pending-reinject flag for the NEXT producer generation:
+        // Chrome never re-runs content scripts in tabs that were already open
+        // when the extension reloads, and runtime.reload() does NOT fire
+        // onInstalled (verified Chromium 146), so the boot-time heal below is
+        // the only thing that converges open tabs after a SW/full reload —
+        // without it a shared SW+content module edit restarts the SW while
+        // every open tab keeps the stale content world (family F).
+        try {
+          if (chrome.storage && chrome.storage.local) {
+            chrome.storage.local.set({__extjsDevPendingReinject: Date.now()}, noopLastError);
+          }
+        } catch (e) {}
+        // Deferred so any in-flight result/log frame — and the "Reloading…"
+        // console announcement dispatched into tabs — flushes before the SW
+        // dies. runtime.reload() restarts the whole extension; the devtools
+        // companion confirms completion via chrome.management events, so no
+        // onDone here.
+        try { setTimeout(function () { try { chrome.runtime.reload(); } catch (e) {} }, 150); } catch (e) {}
+      };
+
+      if (type === "content-scripts" && chrome.scripting && chrome.tabs && chrome.tabs.query) {
+        if (reinjectContentScripts(onDone)) return;
+      }
+
+      fullReload();
+    }
+
+    // ---- Dev-reload announcement surfaces --------------------------------
+    // One server-built label travels the ReloadFrame; the producer echoes it
+    // 1:1 into (a) the page's devtools console and (b) the bundled
+    // extension-js-devtools companion (the bottom-left pill). Both fire HERE,
+    // next to the actual reload action, so a surface can only say
+    // "Reloading…" when a reload is actually being performed.
+
+    // Stable IDs of the bundled extension-js-devtools companion: Chromium pins
+    // via the manifest "key"; Firefox via browser_specific_settings.gecko.id.
+    // Absent companion (e.g. --no-browser in the user's own browser) is fine —
+    // sendMessage just reports no receiver and we swallow it.
+    var DEVTOOLS_COMPANION_ID_CHROMIUM = "kgdaecdpfkikjncaalnmmnjjfpofkcbl";
+    var DEVTOOLS_COMPANION_ID_FIREFOX = "devtools@extension.js";
+
+    function notifyDevtoolsCompanion(phase, label, kind) {
+      try {
+        var chrome = g.chrome;
+        if (!chrome || !chrome.runtime || typeof chrome.runtime.sendMessage !== "function") return;
+        var id = engineName() === "firefox" ? DEVTOOLS_COMPANION_ID_FIREFOX : DEVTOOLS_COMPANION_ID_CHROMIUM;
+        chrome.runtime.sendMessage(
+          id,
+          {type: "extjs-dev-reload-state", phase: phase, label: label || "", kind: kind || "", instanceId: INSTANCE_ID},
+          function () { noopLastError(); }
+        );
+      } catch (e) {}
+    }
+
+    // console.log the reload line into every open injectable tab. Runs in the
+    // user extension's ISOLATED world, where the bridge relay patched console —
+    // so the same line also lands in the centralized dev-server log stream.
+    function announceReloadInTabs(text) {
+      var chrome = g.chrome;
+      if (!chrome || !chrome.tabs || !chrome.tabs.query) return;
+      try {
+        chrome.tabs.query({}, function (tabs) {
+          noopLastError();
+          if (!tabs) return;
+          for (var i = 0; i < tabs.length; i++) {
+            (function (tab) {
+              if (!tab || tab.id == null || !isInjectableUrl(tab.url)) return;
+              if (chrome.scripting && chrome.scripting.executeScript) {
+                try {
+                  chrome.scripting.executeScript(
+                    {target: {tabId: tab.id}, func: function (t) { console.log(t); }, args: [text]},
+                    noopLastError
+                  );
+                  return;
+                } catch (e) {}
+              }
+              // MV2 fallback (Firefox without the scripting API).
+              if (chrome.tabs.executeScript) {
+                try {
+                  chrome.tabs.executeScript(tab.id, {code: "console.log(" + JSON.stringify(text) + ");"}, noopLastError);
+                } catch (e) {}
+              }
+            })(tabs[i]);
+          }
+        });
+      } catch (e) {}
+    }
+
+    function handleDevReloadFrame(frame) {
+      var kind = frame.reloadType || "full";
+      var label = typeof frame.label === "string" ? frame.label : "";
+      // The server always builds the label; the kind-derived fallback only
+      // covers a malformed frame so the announcement stays truthful.
+      var fallback = kind === "content-scripts" ? "content_script"
+        : kind === "service-worker" ? "service_worker"
+        : "extension";
+      var announced = "[extension.js] Reloading " + (label || fallback) + "…";
+
+      notifyDevtoolsCompanion("reloading", label, kind);
+
+      if (kind === "page") {
+        // Notify-only: rspack-dev-server's livereload refreshes the open
+        // surface; reloading the extension here would race it. No tab console
+        // line either — the reloading page clears its own console anyway.
+        return;
+      }
+
+      // Delivery ack for the broker: proves this SW's message pump actually
+      // processed the frame — a successful socket WRITE proves nothing when
+      // the worker is wedged-but-connected (bug 27). The broker latches a
+      // content-scripts reload until this ack and replays it to the next
+      // producer hello, so an edit that landed on a dead pump still converges.
+      // Sent on receipt (not after reinjection): the scripting-unavailable
+      // fallback restarts the whole extension, and an unacked latch would
+      // replay into the fresh SW and restart it a second time.
+      send({type: "reload-ack", reloadType: kind, label: label});
+
+      announceReloadInTabs(announced);
+      performDevReload(kind, function () {
+        // Only the content-scripts path confirms from here (reinjection ran to
+        // completion in this same SW). Full/SW reloads are confirmed by the
+        // devtools companion's chrome.management listeners.
+        notifyDevtoolsCompanion("reloaded", label, kind);
+      });
+    }
+
+    function sanitize(args) {
+      var out = [];
+      for (var i = 0; i < args.length; i++) {
+        var p = args[i];
+        try {
+          if (typeof p === "string") out.push(p.length > 2048 ? p.slice(0, 2048) + "..." : p);
+          else if (p instanceof Error) out.push(p.name + ": " + p.message);
+          else out.push(JSON.stringify(p));
+        } catch (e) {
+          out.push(String(p));
+        }
+        if (out.join(" ").length > 8192) break;
+      }
+      return out;
+    }
+
+    function flush() {
+      while (queue.length && open && socket) {
+        var f = queue.shift();
+        try { socket.send(JSON.stringify(f)); } catch (e) { break; }
+      }
+    }
+
+    function send(frame) {
+      if (open && socket) {
+        try { socket.send(JSON.stringify(frame)); return; } catch (e) {}
+      }
+      if (queue.length < MAX_QUEUE) queue.push(frame);
+    }
+
+    function schedule() {
+      var delay = backoff;
+      backoff = Math.min(backoff * 2, MAX_BACKOFF);
+      try { setTimeout(connect, delay); } catch (e) {}
+    }
+
+    function connect() {
+      try {
+        socket = new WS("ws://" + HOST + ":" + PORT + "/extjs-control");
+      } catch (e) {
+        schedule();
+        return;
+      }
+      socket.onopen = function () {
+        open = true;
+        backoff = 250;
+        try {
+          socket.send(JSON.stringify({type: "hello", v: 1, role: "producer", instanceId: INSTANCE_ID}));
+        } catch (e) {}
+        flush();
+      };
+      socket.onmessage = function (ev) {
+        // Slice 2: the broker routes authorized command frames to this SW.
+        var frame;
+        try { frame = JSON.parse(typeof ev.data === "string" ? ev.data : ""); } catch (e) { return; }
+        if (frame && frame.type === "command") {
+          try { executeCommand(frame); } catch (e) { replyErr(frame.cmdId, "ExecutorError", e); }
+        } else if (frame && frame.type === "reload") {
+          // Dev-loop reload broadcast (see broker.broadcastReload).
+          // Fire-and-forget: no result frame is expected.
+          try { handleDevReloadFrame(frame); } catch (e) {}
+        } else if (frame && frame.type === "ping") {
+          // Server keepalive: merely RECEIVING this message resets the MV3
+          // service worker's ~30s idle timer (Chrome 116+), keeping this SW
+          // reachable for reload broadcasts. Nothing to do.
+        }
+      };
+      socket.onclose = function () {
+        open = false;
+        socket = null;
+        schedule();
+      };
+      socket.onerror = function () {
+        try { socket && socket.close(); } catch (e) {}
+      };
+    }
+
+    LEVELS.forEach(function (level) {
+      var orig = typeof consoleRef[level] === "function"
+        ? consoleRef[level].bind(consoleRef)
+        : function () {};
+      consoleRef[level] = function () {
+        try {
+          send({
+            type: "log",
+            event: {
+              v: 1,
+              id: nowId(),
+              timestamp: Date.now(),
+              level: level,
+              context: CONTEXT,
+              messageParts: sanitize([].slice.call(arguments)),
+              runId: INSTANCE_ID
+            }
+          });
+        } catch (e) {}
+        return orig.apply(consoleRef, arguments);
+      };
+    });
+
+    // Multi-context console forwarding: other contexts (content scripts, surface
+    // pages) can't reliably open ws://127.0.0.1 (page CSP / connect-src), so they
+    // relay console to this SW, which owns the WS. The relay travels a NAMED
+    // runtime.Port — never runtime.sendMessage — because port traffic is
+    // invisible to the extension's own onMessage listeners. With sendMessage, an
+    // extension whose SW echoes every message back to its tabs (wild newtube:
+    // onMessage → tabs.sendMessage(msg) to all tabs) turned each relayed log
+    // into a new tab message, whose subject-side console.log became another
+    // relayed envelope — a self-sustaining dev-only message storm (25k rows/10min
+    // observed) that starved the extension system and wedged Chromium's DevTools
+    // endpoint (family B). We enrich with the real tabId/url from the port sender.
+    function shipRelayedLog(ev, sender) {
+      try {
+        send({
+          type: "log",
+          event: {
+            v: 1,
+            id: nowId(),
+            timestamp: Date.now(),
+            level: ev.level || "log",
+            context: ev.context || "content",
+            messageParts: Array.isArray(ev.messageParts) ? ev.messageParts : [],
+            url: ev.url || (sender ? sender.url : undefined),
+            tabId: sender && sender.tab ? sender.tab.id : undefined,
+            frameId: sender ? sender.frameId : undefined,
+            runId: INSTANCE_ID
+          }
+        });
+      } catch (e) {}
+    }
+    try {
+      var rtPort = g.chrome;
+      if (rtPort && rtPort.runtime && rtPort.runtime.onConnect) {
+        rtPort.runtime.onConnect.addListener(function (port) {
+          if (!port || port.name !== "__extjs-bridge-log__") return;
+          try {
+            port.onMessage.addListener(function (msg) {
+              if (!msg || !msg.__extjsBridgeLog) return;
+              shipRelayedLog(msg.__extjsBridgeLog, port.sender);
+            });
+          } catch (e) {}
+        });
+      }
+    } catch (e) {}
+    // Legacy sendMessage path: kept for any surface still relaying the old way
+    // (harmless one-predicate listener; new relays never use it).
+    try {
+      var rt = g.chrome;
+      if (rt && rt.runtime && rt.runtime.onMessage) {
+        rt.runtime.onMessage.addListener(function (msg, sender) {
+          if (!msg || !msg.__extjsBridgeLog) return;
+          shipRelayedLog(msg.__extjsBridgeLog, sender);
+          // No async response.
+        });
+      }
+    } catch (e) {}
+
+    // Chrome never injects manifest content scripts into tabs that were
+    // already open when the extension (re)loads, so after a dev full reload
+    // (manifest edit, SW edit, chrome.runtime.reload) every open tab keeps the
+    // PREVIOUS build's content-script DOM as a zombie: the nodes still render
+    // but their listeners died with the old world, and nothing heals the tab
+    // until the next recompile happens to reinject. Fire one producer-driven
+    // reinject when this SW generation is a fresh install/reload so open tabs
+    // converge to the new build immediately. onInstalled is the gate: it fires
+    // for install/update/reload (fresh worlds) but NOT for idle-stop SW wakes,
+    // where reinjecting would churn mounted UI for no reason.
+    try {
+      var rtBoot = g.chrome;
+      if (rtBoot && rtBoot.runtime && rtBoot.runtime.onInstalled) {
+        rtBoot.runtime.onInstalled.addListener(function () {
+          try {
+            setTimeout(function () {
+              try { reinjectContentScripts(); } catch (e) {}
+            }, 250);
+          } catch (e) {}
+        });
+      }
+    } catch (e) {}
+
+    // runtime.reload() does NOT fire onInstalled (verified Chromium 146), so
+    // a dev-driven SW/full reload leaves the listener above silent and every
+    // open tab keeps the previous build's content world. fullReload() stamps
+    // __extjsDevPendingReinject into storage.local right before reloading;
+    // consume it here (fresh flags only — a stale one from a crashed session
+    // is dropped) and heal open tabs from the on-disk manifest. Idle-stop SW
+    // wakes never see the flag, so this cannot churn mounted UI.
+    try {
+      var stBoot = g.chrome;
+      if (stBoot && stBoot.storage && stBoot.storage.local) {
+        stBoot.storage.local.get("__extjsDevPendingReinject", function (res) {
+          noopLastError();
+          var ts = res && res.__extjsDevPendingReinject;
+          if (ts == null) return;
+          try { stBoot.storage.local.remove("__extjsDevPendingReinject", noopLastError); } catch (e) {}
+          if (typeof ts !== "number" || Date.now() - ts > 30000) return;
+          setTimeout(function () {
+            try { reinjectContentScripts(); } catch (e) {}
+          }, 250);
+        });
+      }
+    } catch (e) {}
+
+    connect();
+  } catch (e) {}
+})();
+`;
+const BRIDGE_RELAY_SOURCE = `;(function () {
+  try {
+    var g = (typeof globalThis === "object" && globalThis) ? globalThis : this;
+    if (!g || g.__extjsBridgeRelayInstalled) return;
+
+    var CONTEXT = "__EXTJS_CONTEXT__";
+    var chrome = g.chrome;
+    if (!chrome || !chrome.runtime) return;
+    var canRelay = typeof chrome.runtime.connect === "function";
+
+    g.__extjsBridgeRelayInstalled = true;
+    var consoleRef = g.console || {};
+    var LEVELS = ["log", "info", "warn", "error", "debug", "trace"];
+
+    function sanitize(args) {
+      var out = [];
+      for (var i = 0; i < args.length; i++) {
+        var p = args[i];
+        try {
+          if (typeof p === "string") out.push(p.length > 2048 ? p.slice(0, 2048) + "..." : p);
+          else if (p instanceof Error) out.push(p.name + ": " + p.message);
+          else out.push(JSON.stringify(p));
+        } catch (e) { out.push(String(p)); }
+        if (out.join(" ").length > 8192) break;
+      }
+      return out;
+    }
+
+    function here() { try { return g.location ? g.location.href : undefined; } catch (e) { return undefined; } }
+
+    // Lazy named port to the SW producer. Connecting wakes an idle SW like
+    // sendMessage does, but port frames never reach the extension's own
+    // onMessage listeners (see the loop note above). Reconnect on demand: the
+    // SW idling out (or reloading) disconnects the port; the next log redials.
+    var logPort = null;
+    function getLogPort() {
+      if (!canRelay) return null;
+      if (logPort) return logPort;
+      try {
+        logPort = chrome.runtime.connect({name: "__extjs-bridge-log__"});
+        logPort.onDisconnect.addListener(function () {
+          try { void chrome.runtime.lastError; } catch (e) {}
+          logPort = null;
+        });
+      } catch (e) { logPort = null; }
+      return logPort;
+    }
+
+    LEVELS.forEach(function (level) {
+      var orig = typeof consoleRef[level] === "function" ? consoleRef[level].bind(consoleRef) : function () {};
+      consoleRef[level] = function () {
+        try {
+          var p = getLogPort();
+          if (p) {
+            try {
+              p.postMessage({__extjsBridgeLog: {level: level, context: CONTEXT, messageParts: sanitize([].slice.call(arguments)), url: here()}});
+            } catch (e) {
+              // stale port (SW restarted): drop it and redial once
+              logPort = null;
+              var p2 = getLogPort();
+              if (p2) { try { p2.postMessage({__extjsBridgeLog: {level: level, context: CONTEXT, messageParts: sanitize([].slice.call(arguments)), url: here()}}); } catch (e2) {} }
+            }
+          }
+        } catch (e) {}
+        return orig.apply(consoleRef, arguments);
+      };
     });
+
+    // Surface DOM inspection: the SW executor can't reach popup/options/sidebar
+    // DOM (separate extension pages), and the sidecar can't either (cross-extension
+    // isolation). So THIS page — the user extension's own surface — answers an
+    // inspect request for its own context. The SW broadcasts the request; only the
+    // matching-context surface responds with its DOM snapshot.
+    try {
+      if (chrome.runtime && chrome.runtime.onMessage) {
+        chrome.runtime.onMessage.addListener(function (msg, _sender, sendResponse) {
+          if (!msg || !msg.__extjsInspectRequest) return;
+          if (!msg.target || msg.target.context !== CONTEXT) return; // not for me
+          try {
+            var args = msg.args || {};
+            var wantHtml = !args.include || args.include.indexOf("html") !== -1;
+            var cap = args.maxBytes || 262144;
+            function countShadow(root) {
+              var n = 0, els = root.querySelectorAll("*");
+              for (var i = 0; i < els.length; i++) { if (els[i].shadowRoot) { n++; n += countShadow(els[i].shadowRoot); } }
+              return n;
+            }
+            var doc = g.document;
+            var roots = doc.querySelectorAll('#extension-root,[data-extension-root]');
+            var snap = {
+              context: CONTEXT,
+              url: here(),
+              title: doc.title,
+              summary: {
+                htmlLength: doc.documentElement.outerHTML.length,
+                scriptCount: doc.querySelectorAll("script").length,
+                styleCount: doc.querySelectorAll("style,link[rel=stylesheet]").length,
+                extensionRootCount: roots.length,
+                openShadowRoots: countShadow(doc),
+                bodyChildCount: doc.body ? doc.body.children.length : 0
+              }
+            };
+            if (wantHtml) {
+              var html = doc.documentElement.outerHTML;
+              if (cap > 0 && html.length > cap) { snap.html = html.slice(0, cap); snap.htmlTruncated = true; }
+              else { snap.html = html; }
+            }
+            sendResponse({ok: true, value: snap});
+          } catch (e) {
+            sendResponse({ok: false, error: {name: "InspectError", message: String(e)}});
+          }
+          return true; // responded
+        });
+      }
+    } catch (e) {}
+  } catch (e) {}
+})();
+`;
+function buildBridgeRelaySource(opts) {
+    return BRIDGE_RELAY_SOURCE.replace(/__EXTJS_CONTEXT__/g, String(opts.context || 'content'));
 }
-function formatReloadingLine(label) {
-    return `Reloading ${pintor.brightBlue(label)}…`;
+function buildBridgeProducerSource(opts) {
+    if (!opts.controlPort || opts.controlPort < 1) return '';
+    return BRIDGE_PRODUCER_SOURCE.replace(/__EXTJS_CONTROL_PORT__/g, String(opts.controlPort)).replace(/__EXTJS_INSTANCE_ID__/g, String(opts.instanceId)).replace(/__EXTJS_CONTEXT__/g, String(opts.context || 'background')).replace(/__EXTJS_CONTROL_HOST__/g, String(opts.host || '127.0.0.1'));
 }
-async function dispatchReload(instruction, executor) {
-    if (!instruction) return;
-    if ('true' === process.env.EXTENSION_NO_RELOAD) return;
-    if (executor.broker) {
-        const notified = viaBroker(executor.broker, instruction);
-        if (notified > 0 && instruction.label) console.log(formatReloadingLine(instruction.label));
+const inject_bridge_producer_BACKGROUND_ASSET = /(^|\/)background\/(?:service_worker|scripts?)\.js$/i;
+class InjectBridgeProducer {
+    apply(compiler) {
+        const controlPort = parseInt(String(process.env.EXTENSION_CONTROL_PORT || ''), 10);
+        const instanceId = String(process.env.EXTENSION_INSTANCE_ID || '');
+        const host = String(process.env.EXTENSION_DEV_SERVER_CONNECTABLE_HOST || '').trim() || '127.0.0.1';
+        const source = buildBridgeProducerSource({
+            controlPort: Number.isFinite(controlPort) ? controlPort : null,
+            instanceId,
+            context: 'background',
+            host
+        });
+        if (!source) return;
+        compiler.hooks.thisCompilation.tap(InjectBridgeProducer.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: InjectBridgeProducer.name,
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 101
+            }, ()=>{
+                for (const asset of compilation.getAssets()){
+                    if (!inject_bridge_producer_BACKGROUND_ASSET.test(asset.name)) continue;
+                    const original = asset.source.source().toString();
+                    if (-1 !== original.indexOf('__extjsBridgeProducerInstalled')) continue;
+                    const next = source + '\n' + original;
+                    compilation.updateAsset(asset.name, new core_sources.RawSource(next));
+                }
+            });
+        });
     }
 }
-function createChangedSourcesTracker(compiler) {
-    let forcedFull = false;
-    let changedSources = [];
-    compiler.hooks.watchRun.tap('extjs-reload-changed-sources', ()=>{
-        forcedFull = false;
-        changedSources = [];
-        const modifiedFiles = compiler.modifiedFiles;
-        if (!modifiedFiles || 0 === modifiedFiles.size) return;
-        const contextDir = compiler.options.context || '';
-        for (const file of modifiedFiles){
-            const normalized = __rspack_external_path.relative(contextDir, file).replace(/\\/g, '/');
-            if (normalized) {
-                changedSources.push(normalized);
-                if (normalized.includes('manifest.json') || normalized.includes('_locales/')) forcedFull = true;
-            }
-        }
-    });
-    return {
-        snapshot: ()=>({
-                forcedFull,
-                changedSources
-            })
-    };
+const RELAY_TARGETS = [
+    {
+        re: /(^|\/)content_scripts\/.+\.js$/i,
+        context: 'content'
+    },
+    {
+        re: /(^|\/)action\/index\.js$/i,
+        context: 'popup'
+    },
+    {
+        re: /(^|\/)options\/index\.js$/i,
+        context: 'options'
+    },
+    {
+        re: /(^|\/)sidebar\/index\.js$/i,
+        context: 'sidebar'
+    },
+    {
+        re: /(^|\/)devtools\/index\.js$/i,
+        context: 'devtools'
+    }
+];
+class InjectBridgeRelay {
+    apply(compiler) {
+        const controlPort = parseInt(String(process.env.EXTENSION_CONTROL_PORT || ''), 10);
+        if (!Number.isFinite(controlPort) || controlPort < 1) return;
+        const sourceFor = new Map();
+        for (const t of RELAY_TARGETS)if (!sourceFor.has(t.context)) sourceFor.set(t.context, buildBridgeRelaySource({
+            context: t.context
+        }));
+        compiler.hooks.thisCompilation.tap(InjectBridgeRelay.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: InjectBridgeRelay.name,
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 101
+            }, ()=>{
+                for (const asset of compilation.getAssets()){
+                    const target = RELAY_TARGETS.find((t)=>t.re.test(asset.name));
+                    if (!target) continue;
+                    const original = asset.source.source().toString();
+                    if (-1 !== original.indexOf('__extjsBridgeRelayInstalled')) continue;
+                    const next = sourceFor.get(target.context) + '\n' + original;
+                    compilation.updateAsset(asset.name, new core_sources.RawSource(next));
+                }
+            });
+        });
+    }
+}
+const HOT_DIR = 'hot';
+class PruneStaleHotUpdates {
+    static name = 'plugin-reload:prune-stale-hot-updates';
+    previousGeneration = new Set();
+    apply(compiler) {
+        if (!compiler?.hooks?.done?.tap) return;
+        compiler.hooks.done.tap(PruneStaleHotUpdates.name, (stats)=>{
+            try {
+                const outputPath = compiler.options.output?.path;
+                if (!outputPath) return;
+                const hotDir = __rspack_external_path.join(outputPath, HOT_DIR);
+                if (!__rspack_external_fs.existsSync(hotDir)) return;
+                const emitted = new Set();
+                for (const asset of stats.compilation.getAssets()){
+                    const name = String(asset.name || '').replace(/\\/g, '/');
+                    if (name.startsWith(`${HOT_DIR}/`)) emitted.add(name.slice(HOT_DIR.length + 1));
+                }
+                const keep = new Set([
+                    ...emitted,
+                    ...this.previousGeneration
+                ]);
+                const pruneDir = (dir, relPrefix)=>{
+                    for (const entry of __rspack_external_fs.readdirSync(dir, {
+                        withFileTypes: true
+                    })){
+                        const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+                        const absolute = __rspack_external_path.join(dir, entry.name);
+                        if (entry.isDirectory()) {
+                            pruneDir(absolute, rel);
+                            try {
+                                if (0 === __rspack_external_fs.readdirSync(absolute).length) __rspack_external_fs.rmdirSync(absolute);
+                            } catch  {}
+                            continue;
+                        }
+                        if (!keep.has(rel)) try {
+                            __rspack_external_fs.rmSync(absolute, {
+                                force: true
+                            });
+                        } catch  {}
+                    }
+                };
+                pruneDir(hotDir, '');
+                this.previousGeneration = emitted;
+            } catch  {}
+        });
+    }
 }
 function formatReloadContextLabel(context, files) {
     if (!files.length) return context;
@@ -1523,6 +4554,91 @@ function classifyReloadFromSources(opts) {
         label: formatReloadContextLabel(pageContextFromSources(changedSources), changedSources)
     };
 }
+function readContentScriptCount(compilation, outputPath) {
+    try {
+        const asset = compilation.getAsset?.('manifest.json');
+        if (asset?.source) {
+            const manifest = JSON.parse(String(asset.source.source()));
+            const list = manifest?.content_scripts;
+            if (Array.isArray(list)) return list.length;
+        }
+    } catch  {}
+    try {
+        const manifestPath = __rspack_external_path.join(outputPath, 'manifest.json');
+        if (__rspack_external_fs.existsSync(manifestPath)) {
+            const manifest = JSON.parse(stripBom(__rspack_external_fs.readFileSync(manifestPath, 'utf8')));
+            const list = manifest?.content_scripts;
+            if (Array.isArray(list)) return list.length;
+        }
+    } catch  {}
+    return 0;
+}
+function viaBroker(broker, instruction) {
+    return broker.broadcastReload({
+        type: instruction.type,
+        changedContentScriptEntries: instruction.changedContentScriptEntries,
+        label: instruction.label,
+        changedFiles: instruction.changedAssets
+    });
+}
+function formatReloadingLine(label) {
+    return `Reloading ${pintor.brightBlue(label)}…`;
+}
+async function dispatchReload(instruction, executor) {
+    if (!instruction) return;
+    if ('true' === process.env.EXTENSION_NO_RELOAD) return;
+    if (executor.broker) {
+        const notified = viaBroker(executor.broker, instruction);
+        if (notified > 0 && instruction.label) console.log(formatReloadingLine(instruction.label));
+    }
+}
+function createChangedSourcesTracker(compiler) {
+    let forcedFull = false;
+    let changedSources = [];
+    compiler.hooks.watchRun.tap('extjs-reload-changed-sources', ()=>{
+        forcedFull = false;
+        changedSources = [];
+        const modifiedFiles = compiler.modifiedFiles;
+        if (!modifiedFiles || 0 === modifiedFiles.size) return;
+        const contextDir = compiler.options.context || '';
+        for (const file of modifiedFiles){
+            const normalized = __rspack_external_path.relative(contextDir, file).replace(/\\/g, '/');
+            if (normalized) {
+                changedSources.push(normalized);
+                if (normalized.includes('manifest.json') || normalized.includes('_locales/')) forcedFull = true;
+            }
+        }
+    });
+    return {
+        snapshot: ()=>({
+                forcedFull,
+                changedSources
+            })
+    };
+}
+class ReloadPlugin {
+    static name = 'plugin-reload';
+    manifestPath;
+    browser;
+    constructor(options){
+        this.manifestPath = options.manifestPath;
+        this.browser = options.browser || 'chrome';
+    }
+    apply(compiler) {
+        if ('production' === compiler.options.mode || 'true' === process.env.EXTENSION_NO_RELOAD) return;
+        const hasValidManifest = !!this.manifestPath && __rspack_external_fs.existsSync(this.manifestPath) && __rspack_external_fs.lstatSync(this.manifestPath).isFile();
+        if (!hasValidManifest) return;
+        new StripContentScriptDevServerRuntime().apply(compiler);
+        new SetupReloadStrategy({
+            manifestPath: this.manifestPath,
+            browser: this.browser
+        }).apply(compiler);
+        new InjectScriptsReplayShim().apply(compiler);
+        new InjectBridgeProducer().apply(compiler);
+        new InjectBridgeRelay().apply(compiler);
+        new PruneStaleHotUpdates().apply(compiler);
+    }
+}
 class BuildEmitter extends EventEmitter {
     constructor(){
         super();
@@ -1603,25 +4719,6 @@ class BrowsersPlugin {
         });
     }
 }
-function readContentScriptCount(compilation, outputPath) {
-    try {
-        const asset = compilation.getAsset?.('manifest.json');
-        if (asset?.source) {
-            const manifest = JSON.parse(String(asset.source.source()));
-            const list = manifest?.content_scripts;
-            if (Array.isArray(list)) return list.length;
-        }
-    } catch  {}
-    try {
-        const manifestPath = __rspack_external_path.join(outputPath, 'manifest.json');
-        if (__rspack_external_fs.existsSync(manifestPath)) {
-            const manifest = JSON.parse(stripBom(__rspack_external_fs.readFileSync(manifestPath, 'utf8')));
-            const list = manifest?.content_scripts;
-            if (Array.isArray(list)) return list.length;
-        }
-    } catch  {}
-    return 0;
-}
 class SafariDevPlugin {
     packager;
     static name = 'safari-dev';
@@ -1781,4 +4878,4 @@ async function extensionDev(pathOrRemoteUrl, devOptions) {
         process.exit(1);
     }
 }
-export { BuildEmitter, buildSourceFeatureIndex, classifyReloadFromSources, createChangedSourcesTracker, dispatchReload, ensureOptionalContractModuleLoaded, ensureTypeScriptConfig, extensionBuild, extensionDev, getUserTypeScriptConfigFile, hasDependency, isUsingCustomLoader, isUsingIntegration, isUsingTypeScript, jsFrameworksConfigsDetected, jsFrameworksHmrSummary, jsFrameworksIntegrationsEnabled, loadOptionalContractModuleWithoutInstall, optional_deps_resolver_ensureOptionalContractPackageResolved, readContentScriptCount, resolveDevelopDistFile, resolveDevelopInstallRoot, resolveOptionalContractPackageWithoutInstall };
+export { BuildEmitter, ReloadPlugin, buildCanonicalManifest, buildSourceFeatureIndex, classifyReloadFromSources, collectRootAbsoluteRefs, createChangedSourcesTracker, dispatchReload, ensureOptionalContractModuleLoaded, ensureTypeScriptConfig, extensionBuild, extensionDev, filterKeysForThisBrowser, getCurrentManifestContent, getManifestContent, getManifestOverrides, getUserTypeScriptConfigFile, hasDependency, isFromFilepathList, isUsingCustomLoader, isUsingIntegration, isUsingTypeScript, jsFrameworksConfigsDetected, jsFrameworksHmrSummary, jsFrameworksIntegrationsEnabled, loadOptionalContractModuleWithoutInstall, normalizeManifestOutputPath, optional_deps_resolver_ensureOptionalContractPackageResolved, readContentScriptCount, reportToCompilation, resolveDevelopDistFile, resolveDevelopInstallRoot, resolveOptionalContractPackageWithoutInstall, resolveRootAbsoluteRef, setCurrentManifestContent, setOriginalManifestContent, unixify };