extension-develop 4.0.19 → 4.0.20

package/dist/0~rspack-config.mjs

@@ -2,25 +2,25 @@ import { createRequire as __extjsCreateRequire } from "node:module"; const requi
 import { __webpack_require__ } from "./0~rslib-runtime.mjs";
 import { createRequire } from "node:module";
 import pintor from "pintor";
-import core, { Compilation, DefinePlugin, ProvidePlugin, WebpackError, rspack, sources as core_sources } from "@rspack/core";
+import core, { Compilation as core_Compilation, DefinePlugin, ProvidePlugin, WebpackError as core_WebpackError, rspack, sources as core_sources } from "@rspack/core";
 import case_sensitive_paths_webpack_plugin from "case-sensitive-paths-webpack-plugin";
 import adm_zip from "adm-zip";
 import ignore from "ignore";
 import tiny_glob from "tiny-glob";
 import { pathToFileURL } from "node:url";
-import { filterKeysForThisBrowser, getManifestFieldsData } from "browser-extension-manifest-fields";
+import { filterKeysForThisBrowser as external_browser_extension_manifest_fields_filterKeysForThisBrowser, getManifestFieldsData } from "browser-extension-manifest-fields";
 import content_security_policy_parser from "content-security-policy-parser";
 import node_fs from "node:fs";
 import node_path from "node:path";
+import { debugExtensionsToLoad, package_namespaceObject, getDirs, asAbsolute, browserRunnerDisabled, treeWithDistFilesBrowser, packagingDistributionFiles, toPosixPath, resolveCompanionExtensionDirs, debugContextPath, PlaywrightPlugin, isGeckoBasedBrowser, spacerLine, messages_ready, CHROMIUM_FAMILY_ALIASES, treeWithSourceAndDistFiles, computeExtensionsToLoad, noCompanionExtensionsResolved, treeWithSourceFiles, bundlerFatalError, bundlerRecompiling, noEntrypointsDetected, GECKO_FAMILY_ALIASES, packagingSourceFiles, debugBrowser, debugOutputPath, manifestInvalidJson, isChromiumBasedBrowser, getSpecialFoldersDataForCompiler } from "./101.mjs";
+import { stripBom, parseJsonSafe } from "./23.mjs";
 import { isResourceUnderDirs, canonicalizeDir, toResourceKey } from "./93.mjs";
 import { prefix as messaging_prefix, isDebug } from "./349.mjs";
-import { debugExtensionsToLoad, package_namespaceObject, getDirs, asAbsolute, browserRunnerDisabled, treeWithDistFilesBrowser, packagingDistributionFiles, toPosixPath, PlaywrightPlugin, debugContextPath, resolveCompanionExtensionDirs, isGeckoBasedBrowser, spacerLine, messages_ready, CHROMIUM_FAMILY_ALIASES, treeWithSourceAndDistFiles, computeExtensionsToLoad, noCompanionExtensionsResolved, treeWithSourceFiles, bundlerFatalError, bundlerRecompiling, noEntrypointsDetected, GECKO_FAMILY_ALIASES, packagingSourceFiles, debugBrowser, debugOutputPath, manifestInvalidJson, isChromiumBasedBrowser, getSpecialFoldersDataForCompiler } from "./101.mjs";
-import { unixify as paths_unixify, getManifestOverrides, isUsingTypeScript, resolvePackageManager, jsFrameworksIntegrationsEnabled, resolveRootAbsoluteRef, isStaticThemeSource, buildCanonicalManifest, getCurrentManifestContent, ensureTypeScriptConfig, resolveDevelopInstallRoot, filterKeysForThisBrowser as manifest_utils_filterKeysForThisBrowser, isUsingCustomLoader, getUserTypeScriptConfigFile, isUsingIntegration as messages_isUsingIntegration, reportToCompilation, normalizeManifestOutputPath, jsFrameworksHmrSummary, ReloadPlugin, humanLine, jsFrameworksConfigsDetected, collectRootAbsoluteRefs, getManifestContent, resolveDevelopDistFile, hasDependency, setOriginalManifestContent, isFromFilepathList, setCurrentManifestContent } from "./839.mjs";
+import { jsFrameworksHmrSummary, isUsingTypeScript, resolvePackageManager, humanLine, jsFrameworksIntegrationsEnabled, jsFrameworksConfigsDetected, ensureTypeScriptConfig, hasDependency, resolveDevelopInstallRoot, resolveDevelopDistFile, isUsingCustomLoader, getUserTypeScriptConfigFile, isUsingIntegration as messages_isUsingIntegration } from "./839.mjs";
 import { scrubBrand, makeSanitizedConsole } from "./0~branding.mjs";
-import { stripBom, parseJsonSafe } from "./23.mjs";
+import { getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, EXTENSIONJS_CONTENT_SCRIPT_LAYER, isCanonicalContentScriptAsset, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName } from "./291.mjs";
 import { hasProjectDependency, findNearestProjectManifestSync, PROJECT_MANIFEST_FILENAMES, readProjectDependencies } from "./80.mjs";
 import { cssIntegrationsEnabled, cssConfigsDetected, deadCssUrlRef, missingSassDependency, isUsingIntegration, postCssPluginNotResolved } from "./845.mjs";
-import { getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, getCanonicalContentScriptJsAssetName, isCanonicalContentScriptAsset, EXTENSIONJS_CONTENT_SCRIPT_LAYER } from "./291.mjs";
 import { injectedFileDependencyMissing, importScriptsDependencyMissing, getURLDependencyMissing, staticImportDependencyMissing, fetchedFileDependencyMissing, runtimeSetSurfaceDependencyMissing } from "./266.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
@@ -37,6 +37,85 @@ __webpack_require__.r(rspack_config_namespaceObject);
 __webpack_require__.d(rspack_config_namespaceObject, {
     default: ()=>webpackConfig
 });
+function filterKeysForThisBrowser(manifest, browser) {
+    const isSafariTarget = 'safari' === browser || 'webkit-based' === browser || String(browser).includes('webkit');
+    const isChromiumTarget = isChromiumBasedBrowser(String(browser)) || isSafariTarget;
+    const isGeckoTarget = 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 THEME_DISQUALIFYING_KEYS = [
+    'background',
+    "content_scripts",
+    'action',
+    'browser_action',
+    'page_action',
+    'sidebar_action',
+    'side_panel',
+    'options_page',
+    'options_ui',
+    'devtools_page',
+    'chrome_url_overrides',
+    'sandbox',
+    "user_scripts",
+    'declarative_net_request',
+    'web_accessible_resources'
+];
+function isStaticTheme(manifest) {
+    if (!manifest || 'object' != typeof manifest) return false;
+    const theme = manifest.theme;
+    if (!theme || 'object' != typeof theme) return false;
+    return !THEME_DISQUALIFYING_KEYS.some((key)=>{
+        const value = manifest[key];
+        return null != value;
+    });
+}
+function isStaticThemeSource(manifestPath, browser) {
+    if (!manifestPath) return false;
+    try {
+        const parsed = parseJsonSafe(__rspack_external_node_fs_5ea92f0c.readFileSync(manifestPath, 'utf-8'));
+        return isStaticTheme(filterKeysForThisBrowser(parsed, browser));
+    } catch  {
+        return false;
+    }
+}
 function normalizePath(filePath) {
     return filePath.replace(/\\/g, '/');
 }
@@ -436,6 +515,642 @@ function countFilesRecursively(dir) {
         return 0;
     }
 }
+function isFromFilepathList(filePath, filepathList) {
+    return Object.values(filepathList || {}).some((value)=>value === filePath);
+}
+function getFilename(feature, filePath) {
+    const entryExt = __rspack_external_node_path_c5b9b54f.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_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(publicRoot, trimmed))) return;
+    const candidate = __rspack_external_node_path_c5b9b54f.resolve(projectRoot, trimmed);
+    const rel = __rspack_external_node_path_c5b9b54f.relative(projectRoot, candidate);
+    if (rel.startsWith('..') || __rspack_external_node_path_c5b9b54f.isAbsolute(rel)) return;
+    if (!__rspack_external_node_fs_5ea92f0c.existsSync(candidate) || !__rspack_external_node_fs_5ea92f0c.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 backgroundPage(manifest) {
+    return manifest.background?.page && {
+        background: {
+            page: (()=>{
+                const raw = String(manifest.background.page);
+                return getFilename('background/index.html', raw);
+            })()
+        }
+    };
+}
+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_node_path_c5b9b54f.dirname(manifestPath);
+            const inPublic = __rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(manifestDir, 'public', rest));
+            const inRoot = __rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.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 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 commands_commands(manifest) {
+    return manifest.commands && {
+        commands: manifest.commands
+    };
+}
+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 contentSecurityPolicy(manifest) {
+    return manifest.content_security_policy && {
+        content_security_policy: manifest.content_security_policy
+    };
+}
+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_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)
+            ];
+        }))
+    };
+}
+const getBasename = (filepath)=>__rspack_external_node_path_c5b9b54f.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/${getBasename(omnibox.default_icon)}`, omnibox.default_icon) : Object.fromEntries(Object.entries(omnibox.default_icon).map(([size, icon])=>[
+                        size,
+                        getFilename(`icons/${getBasename(icon)}`, icon)
+                    ]))
+            }
+        }
+    };
+}
+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 permissions(manifest) {
+    return manifest.permissions && {
+        permissions: manifest.permissions
+    };
+}
+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_node_path_c5b9b54f.basename(filepath);
+const rewriteThemeImage = (value)=>getFilename(`theme/images/${theme_getBasename(value)}`, value);
+function theme_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 manifestCommon(manifest, manifestPath) {
+    return {
+        ...backgroundPage(manifest),
+        ...chromeUrlOverrides(manifest, manifestPath),
+        ...content_scripts_contentScripts(manifest, manifestPath),
+        ...devtoolsPage(manifest, manifestPath),
+        ...icons_icons(manifest),
+        ...commands_commands(manifest),
+        ...permissions(manifest),
+        ...optionsPage(manifest, manifestPath),
+        ...optionsUi(manifest, manifestPath),
+        ...sandbox(manifest),
+        ...storage(manifest),
+        ...theme_theme(manifest),
+        ...userScripts(manifest),
+        ...webAccessibleResources(manifest),
+        ...contentSecurityPolicy(manifest),
+        ...omnibox_omnibox(manifest)
+    };
+}
+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)
+                    ];
+                }))
+            }
+        }
+    };
+}
+function background_background(manifest) {
+    return manifest.background?.scripts && {
+        background: {
+            scripts: [
+                ...new Set(manifest.background.scripts.map((script)=>getFilename("background/scripts.js", String(script))))
+            ]
+        }
+    };
+}
+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_node_path_c5b9b54f.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_node_path_c5b9b54f.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))
+            }
+        }
+    };
+}
+const theme_experiment_getBasename = (filepath)=>__rspack_external_node_path_c5b9b54f.basename(filepath);
+function themeExperiment(manifest) {
+    const te = manifest.theme_experiment;
+    return te && {
+        theme_experiment: {
+            ...te,
+            ...'string' == typeof te.stylesheet && {
+                stylesheet: getFilename(`theme_experiment/${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_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?.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_action(manifest),
+        ...backgroundServiceWorker(manifest),
+        ...declarativeNetRequest(manifest),
+        ...hostPermissions(manifest),
+        ...sidePanel(manifest)
+    };
+}
+function getManifestOverrides(manifestPath, manifest) {
+    const manifestContent = manifest || JSON.parse(stripBom(__rspack_external_node_fs_5ea92f0c.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);
+}
+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_node_fs_5ea92f0c.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 resolveProcessShim() {
     const candidate = __rspack_external_node_path_c5b9b54f.join(__rspack_import_meta_dirname__, '..', 'runtime', 'process-shim.cjs');
     try {
@@ -511,7 +1226,7 @@ class EnvPlugin {
                 unmatchedEnvFiles = __rspack_external_node_fs_5ea92f0c.readdirSync(projectPath).filter((file)=>file.startsWith('.env') && '.env.defaults' !== file && '.env.example' !== file).sort();
             } catch  {}
             if (unmatchedEnvFiles.length > 0) compiler.hooks.thisCompilation.tap('env:warn-unmatched', (compilation)=>{
-                const warn = new WebpackError(envNoMatchingFile(String(this.browser), String(mode), unmatchedEnvFiles, envFiles));
+                const warn = new core_WebpackError(envNoMatchingFile(String(this.browser), String(mode), unmatchedEnvFiles, envFiles));
                 warn.name = 'EnvNoMatchingFile';
                 compilation.warnings.push(warn);
             });
@@ -559,7 +1274,7 @@ class EnvPlugin {
         compiler.hooks.thisCompilation.tap('manifest:update-manifest', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'env:module',
-                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
             }, (assets)=>{
                 const files = Object.keys(compilation.assets || assets);
                 files.forEach((filename)=>{
@@ -1992,34 +2707,6 @@ async function cssInHtmlLoader(projectPath, mode, manifestPath, usage = {}) {
         issuer: (issuer)=>!isContentScriptEntry(issuer, manifestPath, projectPath)
     });
 }
-function injectCssLink(headNode, feature, firstLinkAttrs, hrefOverride) {
-    const linkTag = __rspack_external_parse5_utilities_78b19c6a.createNode('link');
-    linkTag.attrs = [
-        {
-            name: 'rel',
-            value: 'stylesheet'
-        },
-        {
-            name: 'href',
-            value: hrefOverride || `/${feature}.css`
-        }
-    ];
-    const propagateLinkAttrs = new Set([
-        'media',
-        'crossorigin',
-        'integrity',
-        'referrerpolicy',
-        'type',
-        'disabled'
-    ]);
-    if (firstLinkAttrs) {
-        for (const attr of firstLinkAttrs)if (propagateLinkAttrs.has(attr.name) && !linkTag.attrs.find((a)=>a.name === attr.name)) linkTag.attrs.push({
-            name: attr.name,
-            value: attr.value
-        });
-    }
-    __rspack_external_parse5_utilities_78b19c6a.append(headNode, linkTag);
-}
 class CssPlugin {
     static name = 'plugin-css';
     manifestPath;
@@ -2107,7 +2794,7 @@ class CssPlugin {
                 const key = `${issuer}|${req}`;
                 if (!warned.has(key) && compilation?.warnings) {
                     warned.add(key);
-                    const warning = new WebpackError(deadCssUrlRef(__rspack_external_node_path_c5b9b54f.relative(manifestDir, issuer) || issuer, raw));
+                    const warning = new core_WebpackError(deadCssUrlRef(__rspack_external_node_path_c5b9b54f.relative(manifestDir, issuer) || issuer, raw));
                     warning.file = __rspack_external_node_path_c5b9b54f.relative(manifestDir, issuer);
                     compilation?.warnings.push(warning);
                 }
@@ -2145,7 +2832,7 @@ function findBrowserslistSource(projectPath) {
         if (__rspack_external_node_fs_5ea92f0c.existsSync(p)) return p;
     }
 }
-function isUrl(src) {
+function parse_html_isUrl(src) {
     try {
         new URL(src);
         return true;
@@ -2158,7 +2845,7 @@ function parseHtml(node, onResourceFound) {
     if ("script" === node.nodeName) {
         const src = node.attrs?.find((attr)=>'src' === attr.name)?.value;
         if (!src) return;
-        if (isUrl(src)) return;
+        if (parse_html_isUrl(src)) return;
         onResourceFound({
             filePath: src,
             childNode: node,
@@ -2172,14 +2859,14 @@ function parseHtml(node, onResourceFound) {
             const url = candidate.trim().split(/\s+/)[0];
             if (!url) continue;
             const { cleanPath } = cleanAssetUrl(url);
-            if (cleanPath && !isUrl(cleanPath)) onResourceFound({
+            if (cleanPath && !parse_html_isUrl(cleanPath)) onResourceFound({
                 filePath: cleanPath,
                 childNode: node,
                 assetType: 'staticHref'
             });
         }
         if (!href) return;
-        if (isUrl(href)) return;
+        if (parse_html_isUrl(href)) return;
         const nonStylesheetRelTokens = [
             'dns-prefetch',
             'icon',
@@ -2206,7 +2893,7 @@ function parseHtml(node, onResourceFound) {
     } else if ('audio' === node.nodeName || 'embed' === node.nodeName || 'iframe' === node.nodeName || 'img' === node.nodeName || 'input' === node.nodeName || 'source' === node.nodeName || 'track' === node.nodeName || 'video' === node.nodeName) {
         const src = node.attrs?.find((attr)=>'src' === attr.name)?.value;
         if (!src) return;
-        if (isUrl(src)) return;
+        if (parse_html_isUrl(src)) return;
         onResourceFound({
             filePath: src,
             childNode: node,
@@ -2220,7 +2907,7 @@ function parseHtml(node, onResourceFound) {
                 const url = parts[0];
                 if (!url) continue;
                 const { cleanPath } = cleanAssetUrl(url);
-                if (cleanPath && !isUrl(cleanPath)) onResourceFound({
+                if (cleanPath && !parse_html_isUrl(cleanPath)) onResourceFound({
                     filePath: cleanPath,
                     childNode: node,
                     assetType: 'staticSrc'
@@ -2229,7 +2916,7 @@ function parseHtml(node, onResourceFound) {
         }
         if ('video' === node.nodeName) {
             const poster = node.attrs?.find((attr)=>'poster' === attr.name)?.value;
-            if (poster && !isUrl(poster)) {
+            if (poster && !parse_html_isUrl(poster)) {
                 const { cleanPath } = cleanAssetUrl(poster);
                 if (cleanPath) onResourceFound({
                     filePath: cleanPath,
@@ -2851,7 +3538,7 @@ class JsFrameworksPlugin {
         }
         const platformModulePaths = new Set();
         try {
-            const browserManifest = filterKeysForThisBrowser(manifest, this.browser);
+            const browserManifest = external_browser_extension_manifest_fields_filterKeysForThisBrowser(manifest, this.browser);
             const background = browserManifest?.background;
             if (background?.type === 'module' && 'string' == typeof background?.service_worker) platformModulePaths.add(toResourceKey(__rspack_external_node_path_c5b9b54f.resolve(manifestDir, background.service_worker)));
             const htmlPages = {
@@ -3092,119 +3779,2869 @@ class JsFrameworksPlugin {
         await configuring;
     }
 }
-const PAGE_DIRS = [
-    'pages',
-    'sidebar',
-    'popup',
-    'options',
-    'options_ui',
-    'devtools',
-    'newtab',
-    'sandbox',
-    'action',
-    'browser_action',
-    'page_action'
-];
-const isCodeAsset = (name)=>/\.(js|css|wasm)$/i.test(name);
-const categorize_isSourceMap = (name)=>/\.map$/i.test(name);
-const isHotUpdate = (name)=>/(^|\/)hot\//.test(name);
-function categorizeAsset(rawName) {
-    const name = String(rawName || '').replace(/\\/g, '/');
-    if (!name) return 'ignored';
-    if (!isCodeAsset(name)) return 'ignored';
-    if (categorize_isSourceMap(name)) return 'ignored';
-    if (isHotUpdate(name)) return 'ignored';
-    if (/(^|\/)content_scripts\//.test(name)) return "content-script";
-    if (/(^|\/)background\//.test(name) || /(^|\/)service[-_]?worker\.(js|css|wasm)$/i.test(name)) return 'service-worker';
-    for (const dir of PAGE_DIRS)if (new RegExp(`(^|\\/)${dir}\\/`).test(name)) return 'page';
-    return 'ignored';
+const PAGE_DIRS = [
+    'pages',
+    'sidebar',
+    'popup',
+    'options',
+    'options_ui',
+    'devtools',
+    'newtab',
+    'sandbox',
+    'action',
+    'browser_action',
+    'page_action'
+];
+const isCodeAsset = (name)=>/\.(js|css|wasm)$/i.test(name);
+const categorize_isSourceMap = (name)=>/\.map$/i.test(name);
+const isHotUpdate = (name)=>/(^|\/)hot\//.test(name);
+function categorizeAsset(rawName) {
+    const name = String(rawName || '').replace(/\\/g, '/');
+    if (!name) return 'ignored';
+    if (!isCodeAsset(name)) return 'ignored';
+    if (categorize_isSourceMap(name)) return 'ignored';
+    if (isHotUpdate(name)) return 'ignored';
+    if (/(^|\/)content_scripts\//.test(name)) return "content-script";
+    if (/(^|\/)background\//.test(name) || /(^|\/)service[-_]?worker\.(js|css|wasm)$/i.test(name)) return 'service-worker';
+    for (const dir of PAGE_DIRS)if (new RegExp(`(^|\\/)${dir}\\/`).test(name)) return 'page';
+    return 'ignored';
+}
+const BUDGET_BYTES = {
+    "content-script": 524288,
+    'service-worker': 524288,
+    page: 1048576,
+    ignored: 1 / 0
+};
+function fmtKiB(bytes) {
+    const kib = bytes / 1024;
+    if (kib >= 1024) return `${(kib / 1024).toFixed(2)} MiB`;
+    return `${kib.toFixed(1)} KiB`;
+}
+function perfBudgetWarning(assets) {
+    const header = `${1 === assets.length ? 'asset exceeds' : 'assets exceed'} the extension performance budget. Browser extensions inject content scripts on every navigation and wake service workers from cold, so we apply tighter budgets than the rspack default.`;
+    const lines = assets.map((a)=>{
+        const over = (a.size / a.budget * 100 - 100).toFixed(0);
+        return `  ${a.name}\n    size:   ${fmtKiB(a.size)}\n    budget: ${fmtKiB(a.budget)}  (over by ${over}%)\n    role:   ${categoryRole(a.category)}`;
+    });
+    const remediation = "Lazy-load with dynamic import(), code-split per route, or replace large SDKs with thin fetch wrappers.\nSee https://rspack.rs/guide/optimization/code-splitting";
+    return `${header}\n\n${lines.join('\n')}\n\n${remediation}`;
+}
+function categoryRole(c) {
+    switch(c){
+        case "content-script":
+            return "content script, injected on every page navigation";
+        case 'service-worker':
+            return 'service worker / background, wakes from cold each session';
+        case 'page':
+            return 'UI page, opened on demand';
+        default:
+            return 'asset';
+    }
+}
+class PerfBudgetsPlugin {
+    static name = 'plugin-perf-budgets';
+    options;
+    constructor(options = {}){
+        this.options = options;
+    }
+    apply(compiler) {
+        const enabled = 'boolean' == typeof this.options.enabled ? this.options.enabled : 'production' === compiler.options.mode;
+        if (!enabled) return;
+        const budgets = {
+            ...BUDGET_BYTES,
+            ...this.options.budgets || {}
+        };
+        const report = (compilation)=>{
+            if (compilation.errors?.length) return;
+            const oversized = [];
+            const assets = compilation.assets || {};
+            for (const [name, source] of Object.entries(assets)){
+                const size = source?.size?.() ?? 0;
+                if (!size) continue;
+                const category = categorizeAsset(name);
+                if ('ignored' === category) continue;
+                const budget = budgets[category];
+                if (Number.isFinite(budget)) {
+                    if (!(size <= budget)) oversized.push({
+                        name,
+                        size,
+                        budget,
+                        category
+                    });
+                }
+            }
+            if (0 === oversized.length) return;
+            oversized.sort((a, b)=>b.size - a.size);
+            const ErrorConstructor = compiler?.rspack?.WebpackError || Error;
+            const warning = new ErrorConstructor(perfBudgetWarning(oversized));
+            warning.name = 'PerfBudgetWarning';
+            if (!compilation.warnings) compilation.warnings = [];
+            compilation.warnings.push(warning);
+        };
+        const REPORT_STAGE = compiler?.rspack?.Compilation?.PROCESS_ASSETS_STAGE_REPORT ?? 5000;
+        compiler.hooks.thisCompilation.tap(PerfBudgetsPlugin.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: PerfBudgetsPlugin.name,
+                stage: REPORT_STAGE
+            }, ()=>report(compilation));
+        });
+    }
+}
+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: these wraps run
+    // BEFORE user code, and no platform API exists to dispatch these events.
+    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"; }
+    }
+
+    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) {
+        // Ignore
+      }
+    }
+
+    function replyErr(cmdId, name, message, code) {
+      var frame = {type: "result", cmdId: cmdId, ok: false, error: {name: name, message: String(message), engine: engineName()}};
+      if (code) frame.error.code = code;
+      try { socket && socket.send(JSON.stringify(frame)); } catch (e) {
+        // Ignore
+      }
+    }
+
+    // Name the refusal the browser wrote as prose, so a consumer branches on
+    // error.code instead of matching the engine's sentence.
+    function openRefusalCode(message) {
+      var m = String(message == null ? "" : message);
+      if (/user gesture|user input|user interaction|user action/i.test(m)) return "needs_user_gesture";
+      if (/browser window|active window/i.test(m)) return "needs_headed_window";
+      return undefined;
+    }
+
+    // Resolve a numeric tab id when the caller did not pass one: match
+    // target.url against open tabs, else default to the active tab. (#51)
+    function resolveTargetTab(target, cb) {
+      var chrome = g.chrome;
+      if (!chrome || !chrome.tabs) { cb(null, "chrome.tabs is not available"); return; }
+      var url = target && target.url;
+      if (url) {
+        var substringMatch = function () {
+          try {
+            chrome.tabs.query({}, function (all) {
+              var hit = (all || []).filter(function (t) { return t.url && String(t.url).indexOf(url) !== -1; })[0];
+              if (hit && typeof hit.id === "number") { cb(hit.id, null); return; }
+              cb(null, "no open tab matches url: " + url);
+            });
+          } catch (e2) { cb(null, "tab query failed"); }
+        };
+        try {
+          // chrome.tabs.query accepts URL match patterns; a bare url/glob may
+          // not be a valid pattern, so fall back to a substring scan.
+          chrome.tabs.query({url: url}, function (tabs) {
+            if (chrome.runtime && chrome.runtime.lastError) { substringMatch(); return; }
+            if (tabs && tabs.length && typeof tabs[0].id === "number") { cb(tabs[0].id, null); return; }
+            substringMatch();
+          });
+        } catch (e) { substringMatch(); }
+        return;
+      }
+      try {
+        chrome.tabs.query({active: true, lastFocusedWindow: true}, function (tabs) {
+          var t = tabs && tabs[0];
+          if (t && typeof t.id === "number") { cb(t.id, null); return; }
+          cb(null, "no active tab to target");
+        });
+      } catch (e3) { cb(null, "tab query failed"); }
+    }
+
+    // chrome.* async APIs are callback-only on Gecko. Prefer promisified
+    // browser.* when present, else the chrome.* callback form. cb(err, result).
+    function nsCall(nsName, method, callArgs, cb) {
+      var chromeG = g.chrome;
+      var done = false;
+      var once = function (err, r) { if (!done) { done = true; cb(err, r); } };
+      var viaPromise = function (ns) {
+        try {
+          var ret = ns[method].apply(ns, callArgs);
+          if (ret && typeof ret.then === "function") {
+            ret.then(function (r) { once(null, r); }, function (e) { once(e); });
+            return true;
+          }
+        } catch (e) { once(e); return true; }
+        return false;
+      };
+      var bNS = g.browser && g.browser[nsName];
+      if (bNS && typeof bNS[method] === "function" && viaPromise(bNS)) return;
+      var cNS = chromeG && chromeG[nsName];
+      if (!cNS || typeof cNS[method] !== "function") {
+        once(new Error("chrome." + nsName + "." + method + " is not available (engine: " + engineName() + ")"));
+        return;
+      }
+      try {
+        var ret2 = cNS[method].apply(cNS, callArgs.concat([function (r) {
+          var le = chromeG.runtime && chromeG.runtime.lastError;
+          if (le) once(le); else once(null, r);
+        }]));
+        // A promise-only implementation ignores the trailing callback and
+        // returns a thenable instead; resolve through it (once() dedupes).
+        if (ret2 && typeof ret2.then === "function") {
+          ret2.then(function (r) { once(null, r); }, function (e) { once(e); });
+        }
+      } catch (e2) {
+        if (!viaPromise(cNS)) once(e2);
+      }
+    }
+
+    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;
+      // content/page eval & inspect need a numeric tab id: resolve --url (or
+      // nothing) to a tab and re-dispatch with target.tabId filled in. (#51)
+      if ((op === "eval" || op === "inspect") && (ctx === "content" || ctx === "page") && target.tabId == null) {
+        resolveTargetTab(target, function (tabId, err) {
+          if (tabId == null) {
+            replyErr(cmdId, "Unsupported", err || ("eval/inspect in context " + ctx + " needs a --tab id, a --url to match, or an active tab"));
+            return;
+          }
+          var next = {};
+          for (var k in cmd) { if (Object.prototype.hasOwnProperty.call(cmd, k)) next[k] = cmd[k]; }
+          next.target = {};
+          for (var tk in target) { if (Object.prototype.hasOwnProperty.call(target, tk)) next.target[tk] = target[tk]; }
+          next.target.tabId = tabId;
+          executeCommand(next);
+        });
+        return;
+      }
+      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 and
+                // rejects 'unsafe-eval'. Surface it honestly with an 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) {
+            // Wrap the eval so a throw INSIDE the tab comes back as data:
+            // Chrome swallows an injected function's exception (null result).
+            nsCall("scripting", "executeScript", [{
+              target: {tabId: target.tabId},
+              world: ctx === "page" ? "MAIN" : "ISOLATED",
+              func: function (src) {
+                try { return {__extjsEval: 1, ok: true, value: eval(src)}; }
+                catch (e) { return {__extjsEval: 1, ok: false, name: (e && e.name) || "EvalError", message: (e && e.message) || String(e)}; }
+              },
+              args: [String(args.expression)]
+            }], function (err, res) {
+              if (err) { replyErr(cmdId, "TargetNotFound", (err && err.message) || err); return; }
+              var frame = res && res[0] ? res[0].result : undefined;
+              if (!frame || frame.__extjsEval !== 1) {
+                replyErr(cmdId, "TargetNotFound", "the expression never executed in tab " + target.tabId + ": no injectable frame returned a result (restricted page, or outside host_permissions)");
+                return;
+              }
+              if (frame.ok) { replyOk(cmdId, frame.value); return; }
+              if (ctx === "content" && /Content Security Policy|unsafe-eval|EvalError/i.test(String(frame.name) + " " + String(frame.message))) {
+                replyErr(cmdId, "Unsupported", "eval of a string is blocked in the ISOLATED (content) world by the extension CSP. Use --context page (runs in the page's MAIN world). Original: " + frame.message);
+                return;
+              }
+              replyErr(cmdId, frame.name || "EvalError", frame.message);
+            });
+          } else if (ctx === "popup" || ctx === "options" || ctx === "sidebar" || ctx === "devtools" || ctx === "newtab" || ctx === "history" || ctx === "bookmarks") {
+            // The SW can't eval in another extension page; ask the surface's
+            // own in-bundle relay (only the open, matching-context page responds).
+            chrome.runtime.sendMessage(
+              {__extjsEvalRequest: true, target: target, args: {expression: String(args.expression)}},
+              function (resp) {
+                if ((chrome.runtime && chrome.runtime.lastError) || !resp) {
+                  replyErr(cmdId, "Unsupported", "surface '" + ctx + "' is not open (open it first: extension open " + ctx + ")", "surface_not_open");
+                } else if (resp.ok) {
+                  replyOk(cmdId, resp.value);
+                } else {
+                  replyErr(cmdId, (resp.error && resp.error.name) || "EvalError", (resp.error && resp.error.message) || "eval failed");
+                }
+              }
+            );
+          } else if (ctx === "content" || ctx === "page") {
+            replyErr(cmdId, "Unsupported", target.tabId
+              ? "chrome.scripting is not available on this engine (MV2 has no scripting API); use --context background"
+              : "eval in context " + ctx + " requires a tabId");
+          } else {
+            replyErr(cmdId, "BadRequest", "unknown eval context: " + ctx);
+          }
+          return;
+        }
+        if (op === "storage.get" || op === "storage.set") {
+          // chrome.* storage is callback-only on Gecko and older Chromium.
+          // Prefer promisified browser.*, then fall back to the callback shape.
+          var storageNS = (g.browser && g.browser.storage) ? g.browser.storage : chrome.storage;
+          var storageArea = storageNS && storageNS[args.area || "local"];
+          if (!storageArea) { replyErr(cmdId, "StorageError", "storage." + (args.area || "local") + " unavailable"); return; }
+          var isSet = op === "storage.set";
+          var callArgs = isSet ? [args.items || {}] : [args.key != null ? args.key : null];
+          var onStorageOk = function (r) { replyOk(cmdId, isSet ? {set: Object.keys(args.items || {})} : r); };
+          var onStorageErr = function (e) { replyErr(cmdId, "StorageError", (e && e.message) || String(e)); };
+          var storageFn = isSet ? storageArea.set : storageArea.get;
+          try {
+            var storageRet = storageFn.apply(storageArea, callArgs);
+            if (storageRet && typeof storageRet.then === "function") {
+              storageRet.then(onStorageOk, onStorageErr);
+              return;
+            }
+          } catch (e) { /* not thenable / threw synchronously: fall back to callback */ }
+          try {
+            storageFn.apply(storageArea, callArgs.concat([function (r) {
+              var le = chrome.runtime && chrome.runtime.lastError;
+              if (le) onStorageErr(le); else onStorageOk(r);
+            }]));
+          } catch (e) { onStorageErr(e); }
+          return;
+        }
+        if (op === "reload") {
+          if (ctx === "background") {
+            replyOk(cmdId, {reloading: true});
+            setTimeout(function () { try { chrome.runtime.reload(); } catch (e) {
+              // Ignore
+            } }, 50);
+          } else if (target.tabId) {
+            nsCall("tabs", "reload", [target.tabId], function (err) {
+              if (err) replyErr(cmdId, "ReloadError", (err && err.message) || err);
+              else replyOk(cmdId, {reloaded: target.tabId});
+            });
+          } 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) {
+              // Ignore
+            }
+            try { chrome.action.getPopup({}, function (p) { cb(p || ""); }); }
+            catch (e) { cb(""); }
+          };
+          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) {
+                // Ignore
+              }
+            }
+            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.
+          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) {
+              // Ignore
+            }
+            return null;
+          };
+          if (surface === "popup") {
+            if (chrome.action && chrome.action.openPopup) {
+              nsCall("action", "openPopup", [], function (err) {
+                if (err) {
+                  var openMsg = (err && err.message) || err;
+                  replyErr(cmdId, "Unsupported", "openPopup: " + openMsg, openRefusalCode(openMsg));
+                } else replyOk(cmdId, {opened: "popup"});
+              });
+            } else { replyErr(cmdId, "Unsupported", "action.openPopup not available", "api_unavailable"); }
+          } 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) {
+                nsCall("sidePanel", "open", [{windowId: w.id}], function (err) {
+                  if (err) {
+                    var sideMsg = (err && err.message) || err;
+                    replyErr(cmdId, "Unsupported", "sidePanel.open: " + sideMsg, openRefusalCode(sideMsg));
+                  } else replyOk(cmdId, {opened: "sidebar"});
+                });
+              });
+            } else { replyErr(cmdId, "Unsupported", "sidePanel not available (engine: " + engineName() + ")", "api_unavailable"); }
+          } else if (surface === "action") {
+            // With a default_popup the click opens it; without one, replay the
+            // onClicked listeners captured at install time.
+            if (chrome.action) {
+              getActionPopup(function (popup) {
+                if (popup) {
+                  nsCall("action", "openPopup", [], function (err) {
+                    if (err) {
+                      var actMsg = (err && err.message) || err;
+                      replyErr(cmdId, "Unsupported", "openPopup: " + actMsg, openRefusalCode(actMsg));
+                    } else replyOk(cmdId, {triggered: "popup"});
+                  });
+                } 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) {
+                        // Ignore
+                      }
+                    }
+                    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() + ")", "api_unavailable"); }
+          } else if (surface === "command") {
+            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) {
+                    // Ignore
+                  }
+                }
+                replyOk(cmdId, {triggered: "command", command: commandName || null, listeners: fired, gesture: false});
+              });
+            }
+          } else { replyErr(cmdId, "BadRequest", "unknown surface: " + surface); }
+          return;
+        }
+        if (op === "tabs.query") {
+          nsCall("tabs", "query", [args || {}], function (err, tabs) {
+            if (err) { replyErr(cmdId, "TabsError", (err && err.message) || err); return; }
+            replyOk(cmdId, (tabs || []).map(function (t) { return {id: t.id, url: t.url, title: t.title, active: t.active, windowId: t.windowId}; }));
+          });
+          return;
+        }
+        if (op === "inspect") {
+          // Extract a DOM snapshot from the target page via chrome.scripting
+          // (CDP-free). Closed shadow roots need CDP; 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;
+            nsCall("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]
+            }], function (err, res) {
+              if (err) { replyErr(cmdId, "TargetNotFound", (err && err.message) || err); return; }
+              var snap = res && res[0] ? res[0].result : undefined;
+              if (snap == null) { replyErr(cmdId, "TargetNotFound", "no injectable frame returned a snapshot for tab " + target.tabId + " (restricted page, or outside host_permissions)"); return; }
+              replyOk(cmdId, snap);
+            });
+          } else if (ctx === "popup" || ctx === "options" || ctx === "sidebar" || ctx === "devtools" || ctx === "newtab" || ctx === "history" || ctx === "bookmarks") {
+            // 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 + ")", "surface_not_open");
+                } 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) {
+      // Ignore
+    } }
+
+    // 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 one declared entry's fresh files into every matching open tab.
+    // exclude_matches MUST be honored: query the excludes and subtract them.
+    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) {
+              // Ignore
+            }
+            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) {
+                    // Ignore
+                  }
+                }
+                if (jsFiles.length && chrome.scripting.executeScript) {
+                  try {
+                    chrome.scripting.executeScript(
+                      {target: target, files: jsFiles, world: world, injectImmediately: true},
+                      noopLastError
+                    );
+                  } catch (e) {
+                    // Ignore
+                  }
+                }
+              })(tabs[i]);
+            }
+          });
+        } catch (e) {
+          // Ignore
+        }
+      }
+      if (Array.isArray(excludeMatches) && excludeMatches.length) {
+        try {
+          chrome.tabs.query({url: excludeMatches}, function (excludedTabs) {
+            try { void chrome.runtime.lastError; } catch (e) {
+              // Ignore
+            }
+            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) {
+          // Ignore
+        }
+      }
+      injectInto({});
+    }
+
+    // Re-inject all content scripts into their open tabs. Reads the manifest
+    // FROM DISK: getManifest() is frozen and dev filenames are content-hashed.
+    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) {
+              // Ignore
+            } }
+          })
+          .catch(function () {
+            // Ignore
+          });
+        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 content scripts dynamically at the fresh files, so tabs
+    // opened AFTER an edit also get the new build. Idempotent per entry id.
+    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) {
+            // Ignore
+          }
+          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) {
+              // Ignore
+            }
+          }
+          if (toUpdate.length) {
+            try { chrome.scripting.updateContentScripts(toUpdate, noopLastError); } catch (e) {
+              // Ignore
+            }
+          }
+        });
+      } catch (e) {
+        // Ignore
+      }
+    }
+
+    // Dev-loop reload without the CDP controller: content-scripts re-inject in
+    // place into open tabs; service-worker/full/manifest restart the extension.
+    function performDevReload(type, onDone) {
+      var chrome = g.chrome;
+      if (!chrome) return;
+
+      var fullReload = function () {
+        // Flag a pending reinject for the NEXT producer generation: the
+        // boot-time heal is what converges open tabs after a SW/full reload.
+        try {
+          if (chrome.storage && chrome.storage.local) {
+            chrome.storage.local.set({__extjsDevPendingReinject: Date.now()}, noopLastError);
+          }
+        } catch (e) {
+          // Ignore
+        }
+        // Deferred so in-flight frames and the tab console announcement flush
+        // before the SW dies; the devtools companion confirms completion.
+        try { setTimeout(function () { try { chrome.runtime.reload(); } catch (e) {
+          // Ignore
+        } }, 150); } catch (e) {}
+      };
+
+      if (type === "content-scripts" && chrome.scripting && chrome.tabs && chrome.tabs.query) {
+        if (reinjectContentScripts(onDone)) return;
+      }
+
+      fullReload();
+    }
+
+    // One server-built label travels the ReloadFrame; both announcement
+    // surfaces fire HERE, next to the actual reload action, so they stay true.
+
+    // Stable IDs of the bundled extension-js-devtools companion: Chromium pins
+    // via the manifest "key"; Firefox via browser_specific_settings.gecko.id.
+    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) {
+        // Ignore
+      }
+    }
+
+    // console.log the reload line into every open injectable tab; the patched
+    // ISOLATED-world console also lands it in the 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) {
+                  // Ignore
+                }
+              }
+              // 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) {
+                  // Ignore
+                }
+              }
+            })(tabs[i]);
+          }
+        });
+      } catch (e) {
+        // Ignore
+      }
+    }
+
+    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.
+        return;
+      }
+
+      // Delivery ack for the broker: proves this SW's message pump processed
+      // the frame (a socket write proves nothing). Sent on receipt, by design.
+      send({type: "reload-ack", reloadType: kind, label: label});
+
+      announceReloadInTabs(announced);
+      performDevReload(kind, function () {
+        // Only the content-scripts path confirms from here; 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) {
+          // Ignore
+        }
+      }
+      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) {
+        // Ignore
+      }
+    }
+
+    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) {
+          // Ignore
+        }
+        flush();
+      };
+      socket.onmessage = function (ev) {
+        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) {
+            // Ignore
+          }
+        } else if (frame && frame.type === "ping") {
+          // Server keepalive: merely RECEIVING this resets the MV3 SW's ~30s
+          // idle timer (Chrome 116+), keeping it reachable. Nothing to do.
+        }
+      };
+      socket.onclose = function () {
+        open = false;
+        socket = null;
+        schedule();
+      };
+      socket.onerror = function () {
+        try { socket && socket.close(); } catch (e) {
+          // Ignore
+        }
+      };
+    }
+
+    // Uncaught errors don't route through the patched console; the handlers
+    // below forward them, using these signatures to skip already-logged throws.
+    var recentErrorSigs = [];
+    function errorSig(message, stack) {
+      return String(message == null ? "" : message) + "::" + String(stack == null ? "" : stack).slice(0, 200);
+    }
+    function noteErrorSig(sig) {
+      recentErrorSigs.push({sig: sig, t: Date.now()});
+      if (recentErrorSigs.length > 50) recentErrorSigs.shift();
+    }
+    function errorSigSeenRecently(sig) {
+      var now = Date.now();
+      for (var i = recentErrorSigs.length - 1; i >= 0; i--) {
+        if (now - recentErrorSigs[i].t > 3000) { recentErrorSigs.splice(i, 1); continue; }
+        if (recentErrorSigs[i].sig === sig) return true;
+      }
+      return false;
+    }
+
+    LEVELS.forEach(function (level) {
+      var orig = typeof consoleRef[level] === "function"
+        ? consoleRef[level].bind(consoleRef)
+        : function () {};
+      consoleRef[level] = function () {
+        try {
+          if (level === "error") {
+            for (var ai = 0; ai < arguments.length; ai++) {
+              if (arguments[ai] instanceof Error) noteErrorSig(errorSig(arguments[ai].message, arguments[ai].stack));
+            }
+          }
+          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) {
+          // Ignore
+        }
+        return orig.apply(consoleRef, arguments);
+      };
+    });
+
+    // Forward uncaught throws / unhandled rejections as level:"error", deduped
+    // so a logged-then-rethrown Error emits once.
+    function shipUncaughtError(message, stack, url) {
+      try {
+        var sig = errorSig(message, stack);
+        if (errorSigSeenRecently(sig)) return;
+        noteErrorSig(sig);
+        send({
+          type: "log",
+          event: {
+            v: 1,
+            id: nowId(),
+            timestamp: Date.now(),
+            level: "error",
+            context: CONTEXT,
+            messageParts: sanitize([String(message) + (stack ? "\\n" + stack : "")]),
+            url: url,
+            runId: INSTANCE_ID
+          }
+        });
+      } catch (e) {
+        // Ignore
+      }
+    }
+    try {
+      if (typeof g.addEventListener === "function") {
+        g.addEventListener("error", function (ev) {
+          var err = ev && ev.error;
+          var message = (err && err.message) || (ev && ev.message) || "Uncaught error";
+          shipUncaughtError(message, err && err.stack, ev && ev.filename);
+        });
+        g.addEventListener("unhandledrejection", function (ev) {
+          var reason = ev && ev.reason;
+          var message = (reason && reason.message) || (reason != null ? String(reason) : "Unhandled rejection");
+          shipUncaughtError("Unhandled promise rejection: " + message, reason && reason.stack, undefined);
+        });
+      }
+    } catch (e) {
+      // Ignore
+    }
+
+    // Other contexts relay console logs to this SW over a NAMED runtime.Port:
+    // they can't open the WS under page CSP, and sendMessage can echo-loop.
+    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) {
+        // Ignore
+      }
+    }
+    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) {
+            // Ignore
+          }
+        });
+      }
+    } catch (e) {
+      // Ignore
+    }
+    // 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);
+        });
+      }
+    } catch (e) {
+      // Ignore
+    }
+
+    // Chrome never injects manifest content scripts into already-open tabs, so
+    // fire one reinject on onInstalled (which skips idle-stop SW wakes).
+    try {
+      var rtBoot = g.chrome;
+      if (rtBoot && rtBoot.runtime && rtBoot.runtime.onInstalled) {
+        rtBoot.runtime.onInstalled.addListener(function () {
+          try {
+            setTimeout(function () {
+              try { reinjectContentScripts(); } catch (e) {
+                // Ignore
+              }
+            }, 250);
+          } catch (e) {
+            // Ignore
+          }
+        });
+      }
+    } catch (e) {
+      // Ignore
+    }
+
+    // runtime.reload() does NOT fire onInstalled (verified Chromium 146), so
+    // consume the pre-reload storage flag here (fresh only) to heal open tabs.
+    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) {
+            // Ignore
+          }
+          if (typeof ts !== "number" || Date.now() - ts > 30000) return;
+          setTimeout(function () {
+            try { reinjectContentScripts(); } catch (e) {
+              // Ignore
+            }
+          }, 250);
+        });
+      }
+    } catch (e) {
+      // Ignore
+    }
+
+    connect();
+  } catch (e) {
+    // Ignore
+  }
+})();
+`;
+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, but
+    // port frames never reach the extension's own onMessage listeners.
+    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) {
+            // Ignore
+          }
+          logPort = null;
+        });
+      } catch (e) { logPort = null; }
+      return logPort;
+    }
+
+    // Relay one log payload to the SW producer over the named port, redialing
+    // once if the port went stale (SW restarted).
+    function postLog(payload) {
+      var p = getLogPort();
+      if (!p) return;
+      try {
+        p.postMessage({__extjsBridgeLog: payload});
+      } catch (e) {
+        logPort = null;
+        var p2 = getLogPort();
+        if (p2) { try { p2.postMessage({__extjsBridgeLog: payload}); } catch (e2) {
+          // Ignore
+        } }
+      }
+    }
+
+    // Uncaught throws / unhandled rejections never route through the patched
+    // console; forward them, deduped against console.error Error signatures.
+    var recentErrorSigs = [];
+    function errorSig(message, stack) {
+      return String(message == null ? "" : message) + "::" + String(stack == null ? "" : stack).slice(0, 200);
+    }
+    function noteErrorSig(sig) {
+      recentErrorSigs.push({sig: sig, t: Date.now()});
+      if (recentErrorSigs.length > 50) recentErrorSigs.shift();
+    }
+    function errorSigSeenRecently(sig) {
+      var now = Date.now();
+      for (var i = recentErrorSigs.length - 1; i >= 0; i--) {
+        if (now - recentErrorSigs[i].t > 3000) { recentErrorSigs.splice(i, 1); continue; }
+        if (recentErrorSigs[i].sig === sig) return true;
+      }
+      return false;
+    }
+
+    LEVELS.forEach(function (level) {
+      var orig = typeof consoleRef[level] === "function" ? consoleRef[level].bind(consoleRef) : function () {};
+      consoleRef[level] = function () {
+        try {
+          if (level === "error") {
+            for (var ai = 0; ai < arguments.length; ai++) {
+              if (arguments[ai] instanceof Error) noteErrorSig(errorSig(arguments[ai].message, arguments[ai].stack));
+            }
+          }
+          postLog({level: level, context: CONTEXT, messageParts: sanitize([].slice.call(arguments)), url: here()});
+        } catch (e) {
+          // Ignore
+        }
+        return orig.apply(consoleRef, arguments);
+      };
+    });
+
+    function shipUncaughtError(message, stack, url) {
+      try {
+        var sig = errorSig(message, stack);
+        if (errorSigSeenRecently(sig)) return;
+        noteErrorSig(sig);
+        postLog({level: "error", context: CONTEXT, messageParts: sanitize([String(message) + (stack ? "\\n" + stack : "")]), url: url || here()});
+      } catch (e) {
+        // Ignore
+      }
+    }
+    try {
+      if (typeof g.addEventListener === "function") {
+        g.addEventListener("error", function (ev) {
+          var err = ev && ev.error;
+          var message = (err && err.message) || (ev && ev.message) || "Uncaught error";
+          shipUncaughtError(message, err && err.stack, (ev && ev.filename) || undefined);
+        });
+        g.addEventListener("unhandledrejection", function (ev) {
+          var reason = ev && ev.reason;
+          var message = (reason && reason.message) || (reason != null ? String(reason) : "Unhandled rejection");
+          shipUncaughtError("Unhandled promise rejection: " + message, reason && reason.stack, undefined);
+        });
+      }
+    } catch (e) {
+      // Ignore
+    }
+
+    // The SW executor can't reach another extension page's DOM or eval there,
+    // so THIS surface answers inspect/eval requests for its own context.
+    try {
+      if (chrome.runtime && chrome.runtime.onMessage) {
+        chrome.runtime.onMessage.addListener(function (msg, _sender, sendResponse) {
+          if (!msg || !msg.__extjsEvalRequest) return;
+          if (!msg.target || msg.target.context !== CONTEXT) return; // not for me
+          try {
+            var value = (0, eval)(String((msg.args && msg.args.expression) || ""));
+            try { sendResponse({ok: true, value: value}); }
+            catch (eSend) { sendResponse({ok: true, value: String(value)}); }
+          } catch (e) {
+            var emsg = (e && e.message) || String(e);
+            if (/Content Security Policy|unsafe-eval|call to eval/i.test(emsg)) {
+              sendResponse({ok: false, error: {name: "Unsupported", message: "eval of a string is blocked in the " + CONTEXT + " page by the MV3 extension CSP. Use extension inspect " + CONTEXT + " to read its DOM, or --context background on an MV2/Firefox build. Original: " + emsg}});
+            } else {
+              sendResponse({ok: false, error: {name: (e && e.name) || "EvalError", message: emsg}});
+            }
+          }
+          return true; // responded
+        });
+      }
+    } catch (e) {
+      // Ignore
+    }
+
+    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) {
+      // Ignore
+    }
+  } catch (e) {
+    // Ignore
+  }
+})();
+`;
+function buildBridgeRelaySource(opts) {
+    return BRIDGE_RELAY_SOURCE.replace(/__EXTJS_CONTEXT__/g, String(opts.context || 'content'));
+}
+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'));
+}
+const 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 (!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));
+                }
+            });
+        });
+    }
+}
+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'
+    },
+    {
+        re: /(^|\/)chrome_url_overrides\/newtab\.js$/i,
+        context: 'newtab'
+    },
+    {
+        re: /(^|\/)chrome_url_overrides\/history\.js$/i,
+        context: 'history'
+    },
+    {
+        re: /(^|\/)chrome_url_overrides\/bookmarks\.js$/i,
+        context: 'bookmarks'
+    }
+];
+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 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 inject_scripts_replay_shim_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 (!inject_scripts_replay_shim_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 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_node_path_c5b9b54f.join(outputPath, HOT_DIR);
+                if (!__rspack_external_node_fs_5ea92f0c.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_node_fs_5ea92f0c.readdirSync(dir, {
+                        withFileTypes: true
+                    })){
+                        const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+                        const absolute = __rspack_external_node_path_c5b9b54f.join(dir, entry.name);
+                        if (entry.isDirectory()) {
+                            pruneDir(absolute, rel);
+                            try {
+                                if (0 === __rspack_external_node_fs_5ea92f0c.readdirSync(absolute).length) __rspack_external_node_fs_5ea92f0c.rmdirSync(absolute);
+                            } catch  {}
+                            continue;
+                        }
+                        if (!keep.has(rel)) try {
+                            __rspack_external_node_fs_5ea92f0c.rmSync(absolute, {
+                                force: true
+                            });
+                        } catch  {}
+                    }
+                };
+                pruneDir(hotDir, '');
+                this.previousGeneration = emitted;
+            } catch  {}
+        });
+    }
+}
+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 existing = compilation[bucket];
+    const already = existing.some((e)=>(e?.file || '') === (issue.file || '') && String(e?.message) === String(issue.message));
+    if (already) return;
+    compilation[bucket].push(issue);
+}
+function backgroundIsRequiredMessageOnly(backgroundChunkName) {
+    return `Check the ${pintor.yellow(backgroundChunkName.replace('/', '.'))} field in your ${pintor.yellow('manifest.json')} file.`;
+}
+class SetupBackgroundEntry {
+    manifestPath;
+    browser;
+    constructor(options){
+        this.manifestPath = options.manifestPath;
+        this.browser = options.browser || 'chrome';
+    }
+    getMissingBackgroundError(bgFile) {
+        if (!__rspack_external_node_fs_5ea92f0c.existsSync(bgFile) && this.manifestPath) {
+            const manifest = JSON.parse(stripBom(__rspack_external_node_fs_5ea92f0c.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_node_fs_5ea92f0c.readFileSync(this.manifestPath, 'utf-8')));
+        const browser = this.browser;
+        const isGecko = isGeckoBasedBrowser(String(browser));
+        const minimumBgScript = resolveDevelopDistFile(isGecko ? 'minimum-firefox-file' : 'minimum-chromium-file');
+        const dirname = __rspack_external_node_path_c5b9b54f.dirname(this.manifestPath);
+        const filteredManifest = filterKeysForThisBrowser(manifest, browser) || manifest;
+        const manifestBg = filteredManifest?.background ?? manifest.background;
+        const manifestVersion = filteredManifest?.manifest_version ?? manifest.manifest_version;
+        if (isStaticTheme(filteredManifest)) return;
+        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_node_path_c5b9b54f.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_node_path_c5b9b54f.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_node_path_c5b9b54f.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_node_fs_5ea92f0c.existsSync(swPath)) this.addDefaultEntry(compiler, 'background/service_worker', swPath);
+            } else this.addDefaultEntry(compiler, 'background/service_worker', minimumBgScript);
+        }
+    }
+}
+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?.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 PublicPath_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 = PublicPath_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;
+                    if (name.startsWith('_locales/') || name.startsWith('_metadata/')) 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);
+        for (const c of x.chunks)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
+    ];
 }
-const BUDGET_BYTES = {
-    "content-script": 524288,
-    'service-worker': 524288,
-    page: 1048576,
-    ignored: 1 / 0
-};
-function fmtKiB(bytes) {
-    const kib = bytes / 1024;
-    if (kib >= 1024) return `${(kib / 1024).toFixed(2)} MiB`;
-    return `${kib.toFixed(1)} KiB`;
+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 perfBudgetWarning(assets) {
-    const header = `${1 === assets.length ? 'asset exceeds' : 'assets exceed'} the extension performance budget. Browser extensions inject content scripts on every navigation and wake service workers from cold, so we apply tighter budgets than the rspack default.`;
-    const lines = assets.map((a)=>{
-        const over = (a.size / a.budget * 100 - 100).toFixed(0);
-        return `  ${a.name}\n    size:   ${fmtKiB(a.size)}\n    budget: ${fmtKiB(a.budget)}  (over by ${over}%)\n    role:   ${categoryRole(a.category)}`;
-    });
-    const remediation = "Lazy-load with dynamic import(), code-split per route, or replace large SDKs with thin fetch wrappers.\nSee https://rspack.rs/guide/optimization/code-splitting";
-    return `${header}\n\n${lines.join('\n')}\n\n${remediation}`;
+function isJSFile(file) {
+    return file.endsWith('.js') || file.endsWith('.mjs');
 }
-function categoryRole(c) {
-    switch(c){
-        case "content-script":
-            return "content script, injected on every page navigation";
-        case 'service-worker':
-            return 'service worker / background, wakes from cold each session';
-        case 'page':
-            return 'UI page, opened on demand';
-        default:
-            return 'asset';
+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/);
     }
 }
-class PerfBudgetsPlugin {
-    static name = 'plugin-perf-budgets';
+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 enabled = 'boolean' == typeof this.options.enabled ? this.options.enabled : 'production' === compiler.options.mode;
-        if (!enabled) return;
-        const budgets = {
-            ...BUDGET_BYTES,
-            ...this.options.budgets || {}
+        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;
+class SetupReloadStrategy {
+    manifestPath;
+    browser;
+    constructor(options){
+        this.manifestPath = options.manifestPath;
+        this.browser = options.browser || 'chrome';
+    }
+    getEntryName(manifest) {
+        if (manifest.background) {
+            if (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
         };
-        const report = (compilation)=>{
-            if (compilation.errors?.length) return;
-            const oversized = [];
-            const assets = compilation.assets || {};
-            for (const [name, source] of Object.entries(assets)){
-                const size = source?.size?.() ?? 0;
-                if (!size) continue;
-                const category = categorizeAsset(name);
-                if ('ignored' === category) continue;
-                const budget = budgets[category];
-                if (Number.isFinite(budget)) {
-                    if (!(size <= budget)) oversized.push({
-                        name,
-                        size,
-                        budget,
-                        category
-                    });
-                }
+    }
+    apply(compiler) {
+        const manifest = JSON.parse(stripBom(__rspack_external_node_fs_5ea92f0c.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'
+                };
             }
-            if (0 === oversized.length) return;
-            oversized.sort((a, b)=>b.size - a.size);
-            const ErrorConstructor = compiler?.rspack?.WebpackError || Error;
-            const warning = new ErrorConstructor(perfBudgetWarning(oversized));
-            warning.name = 'PerfBudgetWarning';
-            if (!compilation.warnings) compilation.warnings = [];
-            compilation.warnings.push(warning);
-        };
-        const REPORT_STAGE = compiler?.rspack?.Compilation?.PROCESS_ASSETS_STAGE_REPORT ?? 5000;
-        compiler.hooks.thisCompilation.tap(PerfBudgetsPlugin.name, (compilation)=>{
+        } 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: PerfBudgetsPlugin.name,
-                stage: REPORT_STAGE
-            }, ()=>report(compilation));
+                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);
+                    }
+                }
+            });
         });
     }
 }
+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_node_fs_5ea92f0c.existsSync(this.manifestPath) && __rspack_external_node_fs_5ea92f0c.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);
+    }
+}
 function checkManifestInPublic(compilation, publicDir) {
     try {
         const manifestInPublic = __rspack_external_node_path_c5b9b54f.join(publicDir, 'manifest.json');
         if (__rspack_external_node_fs_5ea92f0c.existsSync(manifestInPublic)) {
-            const err = new WebpackError(`manifest.json must not be placed under public/: ${manifestInPublic}`);
+            const err = new core_WebpackError(`manifest.json must not be placed under public/: ${manifestInPublic}`);
             err.file = 'manifest.json';
             compilation.errors.push(err);
         }
@@ -3228,7 +6665,7 @@ class TraceRuntimeLoadedFiles {
         compiler.hooks.thisCompilation.tap(TraceRuntimeLoadedFiles.name, (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: TraceRuntimeLoadedFiles.name,
-                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
             }, ()=>{
                 this.traceWorkerImportScripts(compilation);
                 this.traceInjectedFilePayloads(compilation);
@@ -3252,7 +6689,7 @@ class TraceRuntimeLoadedFiles {
         const workerAsset = compilation.getAsset(EMITTED_WORKER_PATH);
         if (!workerAsset) return;
         const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(this.manifestPath);
-        const sourceWorkerPath = unixify(String(workerRef)).replace(/^\/+/, '');
+        const sourceWorkerPath = trace_runtime_loaded_files_unixify(String(workerRef)).replace(/^\/+/, '');
         let pending = [
             workerAsset.source.source().toString()
         ];
@@ -3310,7 +6747,7 @@ class TraceRuntimeLoadedFiles {
                     continue;
                 }
                 if (/\.[a-zA-Z0-9]{1,8}$/.test(distRel)) {
-                    const warn = new WebpackError(fetchedFileDependencyMissing(asset.name, literal, distRel));
+                    const warn = new core_WebpackError(fetchedFileDependencyMissing(asset.name, literal, distRel));
                     warn.name = 'RuntimeFetchedFileMissing';
                     warn.file = asset.name;
                     compilation.warnings ||= [];
@@ -3378,7 +6815,7 @@ class TraceRuntimeLoadedFiles {
                         continue;
                     }
                     if ('js' === item.kind && /\.[a-zA-Z0-9]{1,8}$/.test(distRel)) {
-                        const warn = new WebpackError(isStaticImport ? staticImportDependencyMissing(item.assetName, literal, distRel) : isRuntimeSurface ? runtimeSetSurfaceDependencyMissing(item.assetName, literal, distRel) : getURLDependencyMissing(item.assetName, literal, distRel));
+                        const warn = new core_WebpackError(isStaticImport ? staticImportDependencyMissing(item.assetName, literal, distRel) : isRuntimeSurface ? runtimeSetSurfaceDependencyMissing(item.assetName, literal, distRel) : getURLDependencyMissing(item.assetName, literal, distRel));
                         warn.name = isStaticImport ? 'RuntimeStaticImportFileMissing' : isRuntimeSurface ? 'RuntimeSetSurfaceFileMissing' : 'RuntimeGetURLFileMissing';
                         warn.file = item.assetName;
                         compilation.warnings ||= [];
@@ -3396,7 +6833,7 @@ class TraceRuntimeLoadedFiles {
         for (const asset of jsAssets){
             const content = asset.source.source().toString();
             if (!hasWebpackChunkLoadingRuntime(content)) continue;
-            const assetDirRel = __rspack_external_node_path_c5b9b54f.posix.dirname(unixify(asset.name));
+            const assetDirRel = __rspack_external_node_path_c5b9b54f.posix.dirname(trace_runtime_loaded_files_unixify(asset.name));
             const sourceDirs = new Set();
             const entryDir = entrySourceDirs.get(asset.name.replace(/\.js$/i, ''));
             if (entryDir) sourceDirs.add(entryDir);
@@ -3477,7 +6914,7 @@ function copyThroughOrWarn(compilation, opts) {
         return buffer.toString();
     }
     const sourceSibling = findSourceSibling(abs);
-    const warn = new WebpackError(opts.warning(opts.sourceRel, sourceSibling ? unixify(__rspack_external_node_path_c5b9b54f.relative(opts.manifestDir, sourceSibling)) : void 0));
+    const warn = new core_WebpackError(opts.warning(opts.sourceRel, sourceSibling ? trace_runtime_loaded_files_unixify(__rspack_external_node_path_c5b9b54f.relative(opts.manifestDir, sourceSibling)) : void 0));
     warn.name = opts.warningName;
     warn.file = opts.warningFile;
     compilation.warnings ||= [];
@@ -3489,7 +6926,7 @@ function findSourceSibling(abs) {
     const base = abs.slice(0, -3);
     return SOURCE_SIBLING_EXTENSIONS.map((ext)=>base + ext).find((candidate)=>__rspack_external_node_fs_5ea92f0c.existsSync(candidate));
 }
-function unixify(filePath) {
+function trace_runtime_loaded_files_unixify(filePath) {
     return filePath.replace(/\\/g, '/');
 }
 function resolveExtensionPath(literal, basePath) {
@@ -3498,7 +6935,7 @@ function resolveExtensionPath(literal, basePath) {
     if (/^[a-zA-Z][\w+.-]*:/.test(trimmed)) return null;
     if (trimmed.startsWith('//')) return null;
     try {
-        const base = new URL(`chrome-extension://extension-js/${unixify(basePath)}`);
+        const base = new URL(`chrome-extension://extension-js/${trace_runtime_loaded_files_unixify(basePath)}`);
         const resolved = new URL(trimmed, base);
         if ('extension-js' !== resolved.hostname) return null;
         const pathname = decodeURIComponent(resolved.pathname).replace(/^\/+/, '');
@@ -3511,7 +6948,7 @@ function manifestDeclaredSourcePaths(manifest) {
     const declared = new Set();
     if (!manifest) return declared;
     const add = (value)=>{
-        if ('string' == typeof value && value.trim()) declared.add(unixify(value.trim()).replace(/^\/+/, '').split(/[?#]/)[0]);
+        if ('string' == typeof value && value.trim()) declared.add(trace_runtime_loaded_files_unixify(value.trim()).replace(/^\/+/, '').split(/[?#]/)[0]);
     };
     add(manifest.background?.service_worker);
     add(manifest.background?.page);
@@ -3682,7 +7119,7 @@ function fetchLiteralToFsPath(literal) {
     if (/^[a-zA-Z][\w+.-]*:/.test(trimmed)) return null;
     if (trimmed.startsWith('//')) return null;
     const noQuery = trimmed.split(/[?#]/)[0];
-    return noQuery ? unixify(noQuery) : null;
+    return noQuery ? trace_runtime_loaded_files_unixify(noQuery) : null;
 }
 function blankComments(source) {
     let out = '';
@@ -3909,14 +7346,14 @@ class WarnUponFolderChanges {
         const typeOfAsset = 'pages' === folder ? 'HTML pages' : "script files";
         const errorMessage = serverRestartRequiredFromSpecialFolderMessageOnly(addingOrRemoving, folder, typeOfAsset);
         if (isAddition) {
-            const warn = new WebpackError(errorMessage);
+            const warn = new core_WebpackError(errorMessage);
             warn.name = 'SpecialFoldersChange';
             warn.file = filePath;
             warn.details = `Detected change in ${folder}/ affecting ${typeOfAsset}. Restart may be required for full effect.`;
             compilation.warnings?.push(warn);
             return;
         }
-        const err = new WebpackError(errorMessage);
+        const err = new core_WebpackError(errorMessage);
         err.name = 'SpecialFoldersRemoval';
         err.file = filePath;
         err.details = `Removing from ${folder}/ breaks current build. Restart the dev server to recompile.`;
@@ -4317,6 +7754,34 @@ function manifestFieldMessageOnly(manifestField) {
     const fieldLabel = isContentScripts ? `content_scripts (index ${contentIndex})` : manifestFieldName;
     return `Check the ${pintor.yellow(fieldLabel)} field in your ${pintor.yellow('manifest.json')} file.`;
 }
+function injectCssLink(headNode, feature, firstLinkAttrs, hrefOverride) {
+    const linkTag = __rspack_external_parse5_utilities_78b19c6a.createNode('link');
+    linkTag.attrs = [
+        {
+            name: 'rel',
+            value: 'stylesheet'
+        },
+        {
+            name: 'href',
+            value: hrefOverride || `/${feature}.css`
+        }
+    ];
+    const propagateLinkAttrs = new Set([
+        'media',
+        'crossorigin',
+        'integrity',
+        'referrerpolicy',
+        'type',
+        'disabled'
+    ]);
+    if (firstLinkAttrs) {
+        for (const attr of firstLinkAttrs)if (propagateLinkAttrs.has(attr.name) && !linkTag.attrs.find((a)=>a.name === attr.name)) linkTag.attrs.push({
+            name: attr.name,
+            value: attr.value
+        });
+    }
+    __rspack_external_parse5_utilities_78b19c6a.append(headNode, linkTag);
+}
 function resolveCssAsset(compilation, feature) {
     if (compilation.getAsset(`${feature}.css`)) return {
         found: true,
@@ -4383,7 +7848,7 @@ function warnIfPublicRootAssetMissing(compilation, htmlEntry, cleanPath) {
     const projectDir = __rspack_external_node_path_c5b9b54f.dirname(__rspack_external_node_path_c5b9b54f.dirname(htmlEntry));
     const publicCandidate = __rspack_external_node_path_c5b9b54f.join(projectDir, 'public', cleanPath.slice(1));
     if (__rspack_external_node_fs_5ea92f0c.existsSync(publicCandidate)) return;
-    const warn = new WebpackError(fileNotFound(htmlEntry, cleanPath));
+    const warn = new core_WebpackError(fileNotFound(htmlEntry, cleanPath));
     warn.name = 'HtmlPublicAssetMissing';
     warn.file = htmlEntry;
     const filtered = String(warn.message).split('\n').filter((line)=>!line.includes(String(cleanPath)));
@@ -4711,13 +8176,13 @@ class AddAssetsToCompilation {
             };
             if (processAssetsHook && 'function' == typeof processAssetsHook.tap) processAssetsHook.tap({
                 name: 'html:add-assets-to-compilation',
-                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>runner());
             else runner();
         });
     }
 }
-const WILDCARD_HOSTS = new Set([
+const connectable_host_WILDCARD_HOSTS = new Set([
     '0.0.0.0',
     '::',
     '[::]',
@@ -4727,7 +8192,7 @@ const WILDCARD_HOSTS = new Set([
     ''
 ]);
 function isWildcardHost(host) {
-    return WILDCARD_HOSTS.has(String(host ?? '').trim());
+    return connectable_host_WILDCARD_HOSTS.has(String(host ?? '').trim());
 }
 function resolveConnectableHost(bindHost, publicHost) {
     const override = String(publicHost ?? '').trim();
@@ -4900,7 +8365,7 @@ class AddToFileDependencies {
         compiler.hooks.thisCompilation.tap('html:add-to-file-dependencies', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'html:add-to-file-dependencies',
-                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>{
                 if (compilation.errors?.length) return;
                 const allEntries = this.includeList || {};
@@ -4964,7 +8429,7 @@ class EmitHtmlFile {
             };
             if (processAssetsHook && 'function' == typeof processAssetsHook.tap) processAssetsHook.tap({
                 name: 'AddAssetsToCompilationPlugin',
-                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
             }, ()=>runner());
             else runner();
         });
@@ -5045,7 +8510,7 @@ function handleCantResolveError(includesList, error, compilation, manifestDir) {
                 const errorMsg = fileNotFound(resource, overrideNotFoundPath || wrongFilename, {
                     publicRootHint: isPublicRoot
                 });
-                const warn = new WebpackError(errorMsg);
+                const warn = new core_WebpackError(errorMsg);
                 warn.name = 'HtmlEntrypointMissing';
                 warn.file = __rspack_external_node_path_c5b9b54f.relative(manifestDir, resource);
                 return warn;
@@ -5068,7 +8533,7 @@ class HandleCommonErrors {
             const hasProcessAssets = Boolean(compilation?.hooks?.processAssets?.tap);
             if (hasProcessAssets) return void compilation.hooks.processAssets.tap({
                 name: 'html:handle-common-errors',
-                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
             }, ()=>{
                 const errs = [
                     ...compilation.errors
@@ -5142,7 +8607,7 @@ class ThrowIfRecompileIsNeeded {
                 if (this.hasEntriesChanged(updatedCssEntries, css) || this.hasEntriesChanged(updatedJsEntries, js)) {
                     const projectRoot = __rspack_external_node_path_c5b9b54f.dirname(this.manifestPath);
                     const relToManifest = __rspack_external_node_path_c5b9b54f.relative(projectRoot, changedFile);
-                    const err = new WebpackError(serverRestartRequiredFromHtml(relToManifest, changedFile));
+                    const err = new core_WebpackError(serverRestartRequiredFromHtml(relToManifest, changedFile));
                     err.name = 'HtmlEntrypointChanged';
                     err.file = relToManifest;
                     compilation.errors.push(err);
@@ -5182,7 +8647,7 @@ class UpdateHtmlFile {
             const hasProcessAssets = Boolean(compilation?.hooks?.processAssets?.tap);
             if (hasProcessAssets) compilation.hooks.processAssets.tap({
                 name: 'html:update-html-file',
-                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
             }, ()=>run());
             else run();
         });
@@ -5282,6 +8747,16 @@ function iconsMissingFile(manifestField, filePath, opts) {
     lines.push(`${pintor.red('NOT FOUND')} ${pintor.underline(filePath)}`);
     return lines.join('\n');
 }
+function themeImageMissingFile(manifestField, filePath, opts) {
+    const lines = [];
+    lines.push(`Check the ${pintor.yellow(manifestField)} field in your ${pintor.yellow('manifest.json')} file.`);
+    lines.push("The theme image path must point to an existing file that will be packaged with the extension.");
+    lines.push(`Browsers reject the whole extension when this file is missing.\nThe build stops here to protect you.`);
+    if (opts?.publicRootHint) lines.push(`Paths starting with '/' are resolved from the extension output root (served from ${pintor.yellow('public/')}), not your source directory.`);
+    lines.push('');
+    lines.push(`${pintor.red('NOT FOUND')} ${pintor.underline(filePath)}`);
+    return lines.join('\n');
+}
 function themeImageIsEmpty(manifestField, filePath) {
     const lines = [];
     lines.push(`Check the ${pintor.yellow(manifestField)} field in your ${pintor.yellow('manifest.json')} file.`);
@@ -5345,7 +8820,7 @@ class add_to_file_dependencies_AddToFileDependencies {
         compiler.hooks.thisCompilation.tap('icons:add-to-file-dependencies', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'icons:add-to-file-dependencies',
-                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>{
                 if (compilation.errors?.length) return;
                 const iconFields = this.includeList || {};
@@ -5381,7 +8856,7 @@ class EmitFile {
         compiler.hooks.thisCompilation.tap('icons:emit-file', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'icons:emit-file',
-                stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
             }, ()=>{
                 if (compilation.errors.length > 0) return;
                 const iconFields = this.includeList || {};
@@ -5444,7 +8919,9 @@ class EmitFile {
                             const displayPath = !__rspack_external_node_path_c5b9b54f.isAbsolute(entry) && isPublicRoot ? __rspack_external_node_path_c5b9b54f.join(projectPath, 'public', entry.slice(1)) : __rspack_external_node_path_c5b9b54f.isAbsolute(entry) ? entry : __rspack_external_node_path_c5b9b54f.join(projectPath, entry);
                             const isFatal = 'icons' === group || isDefaultIconFamily || isThemeImage;
                             const severity = isFatal ? 'error' : 'warning';
-                            reportToCompilation(compilation, compiler, iconsMissingFile(feature, displayPath, {
+                            reportToCompilation(compilation, compiler, isThemeImage ? themeImageMissingFile(feature, displayPath, {
+                                publicRootHint: isPublicRoot
+                            }) : iconsMissingFile(feature, displayPath, {
                                 publicRootHint: isPublicRoot,
                                 fatal: isFatal
                             }), severity, 'manifest.json');
@@ -5564,7 +9041,7 @@ function validateJsonAsset(compilation, feature, filePath, buf) {
     try {
         parsed = JSON.parse(stripBom(buf.toString('utf-8')));
     } catch (e) {
-        const err = new WebpackError(invalidJsonSyntax(feature, filePath, String(e?.message || e)));
+        const err = new core_WebpackError(invalidJsonSyntax(feature, filePath, String(e?.message || e)));
         err.file = filePath;
         err.name = 'JSONInvalidSyntax';
         compilation.errors.push(err);
@@ -5572,7 +9049,7 @@ function validateJsonAsset(compilation, feature, filePath, buf) {
     }
     if (feature.startsWith('declarative_net_request')) {
         if (!Array.isArray(parsed)) {
-            const err = new WebpackError(invalidRulesetStructure(feature, filePath));
+            const err = new core_WebpackError(invalidRulesetStructure(feature, filePath));
             err.file = filePath;
             err.name = 'DNRInvalidRuleset';
             compilation.errors.push(err);
@@ -5580,7 +9057,7 @@ function validateJsonAsset(compilation, feature, filePath, buf) {
         }
     } else if ('storage.managed_schema' === feature) {
         if (null === parsed || Array.isArray(parsed) || 'object' != typeof parsed) {
-            const err = new WebpackError(invalidManagedSchemaStructure(feature, filePath));
+            const err = new core_WebpackError(invalidManagedSchemaStructure(feature, filePath));
             err.file = filePath;
             err.name = 'ManagedSchemaInvalid';
             compilation.errors.push(err);
@@ -5623,7 +9100,7 @@ function processJsonAssets(compilation, manifestPath, includeList) {
                 const outputRoot = compilation?.options?.output?.path || '';
                 const displayPath = isPublicRoot ? __rspack_external_node_path_c5b9b54f.join(outputRoot, rawRef.slice(1)) : abs;
                 const isFatal = isCriticalJsonFeature(feature);
-                const notFound = new WebpackError(jsonMissingFile(feature, displayPath, {
+                const notFound = new core_WebpackError(jsonMissingFile(feature, displayPath, {
                     publicRootHint: isPublicRoot,
                     fatal: isFatal
                 }));
@@ -5706,7 +9183,7 @@ class JsonPlugin {
         compiler.hooks.thisCompilation.tap('json:module', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'json:module',
-                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>{
                 processJsonAssets(compilation, this.manifestPath, this.includeList || {});
                 trackJsonDependencies(compilation, this.manifestPath, this.includeList || {});
@@ -5901,11 +9378,11 @@ function validateLocales(compiler, compilation, manifestPath) {
                 const dict = defaultLocaleMessages;
                 const collectMsgKeys = (value, acc)=>{
                     if ('string' == typeof value) {
-                        const regex = /__MSG_([a-zA-Z0-9_]+)__/g;
+                        const regex = /__MSG_([A-Za-z0-9_@]+?)__/g;
                         let matches;
                         while(null !== (matches = regex.exec(value))){
                             const key = matches[1];
-                            if (key) acc.add(key);
+                            if (key && !key.startsWith('@@')) acc.add(key);
                         }
                     } else if (Array.isArray(value)) for (const item of value)collectMsgKeys(item, acc);
                     else if (value && 'object' == typeof value) for (const v of Object.values(value))collectMsgKeys(v, acc);
@@ -5963,7 +9440,7 @@ class LocalesPlugin {
         compiler.hooks.thisCompilation.tap('locales:module', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'locales:module',
-                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>{
                 if (!__rspack_external_node_fs_5ea92f0c.existsSync(this.manifestPath)) {
                     const ErrorConstructor = compiler?.rspack?.WebpackError || Error;
@@ -6010,6 +9487,15 @@ function fatalManifestShapeFixed(field, detail) {
     lines.push(`${pintor.brightBlue('FIELD')} ${pintor.underline(field)}, ${detail}`);
     return lines.join('\n');
 }
+function invalidThemeValue(field, detail, value) {
+    const lines = [];
+    lines.push(`Check the ${pintor.yellow(field)} field in your ${pintor.yellow('manifest.json')} file.`);
+    lines.push(detail);
+    lines.push(`Chrome rejects the whole extension when this value is malformed.\nThe build stops here to protect you.`);
+    lines.push('');
+    lines.push(`${pintor.red('INVALID VALUE')} ${value}`);
+    return lines.join('\n');
+}
 function missingGeckoDataCollectionPermissions() {
     const lines = [];
     lines.push(`${messaging_prefix('warn')} addons.mozilla.org requires ${pintor.yellow('browser_specific_settings.gecko.data_collection_permissions')} for new add-ons.`);
@@ -6340,7 +9826,7 @@ class ApplyDevDefaults {
             if (!compilation?.hooks?.processAssets) return;
             compilation.hooks.processAssets.tap({
                 name: 'manifest:apply-dev-defaults',
-                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT + 100
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 100
             }, ()=>{
                 if (compilation.errors.length > 0) return;
                 if (!this.manifestPath) {
@@ -6423,7 +9909,7 @@ class EmitManifest {
         compiler.hooks.thisCompilation.tap('manifest:emit-manifest', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'manifest:emit-manifest',
-                stage: Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS
             }, ()=>{
                 let jsonContent;
                 try {
@@ -6461,7 +9947,7 @@ class ManifestLegacyWarnings {
         compiler.hooks.thisCompilation.tap(ManifestLegacyWarnings.name, (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: ManifestLegacyWarnings.name,
-                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT
             }, ()=>{
                 const asset = compilation.getAsset('manifest.json');
                 if (!asset) return;
@@ -6469,7 +9955,7 @@ class ManifestLegacyWarnings {
                 let count = 0;
                 legacy.forEach((needle)=>{
                     if (text.includes(needle)) {
-                        const warn = new WebpackError(legacyManifestPathWarning(needle));
+                        const warn = new core_WebpackError(legacyManifestPathWarning(needle));
                         warn.name = 'ManifestLegacyWarning';
                         warn.file = 'manifest.json';
                         compilation.warnings.push(warn);
@@ -6546,11 +10032,11 @@ function warPatchedSummary(v3Groups, v3ResourcesTotal, v2Resources) {
     return `${messaging_prefix('debug')} war      patched v3Groups=${String(v3Groups)} v3Resources=${String(v3ResourcesTotal)} v2Resources=${String(v2Resources)}`;
 }
 function isPublicRootLike(possiblePath) {
-    const normalizedPath = paths_unixify(possiblePath || '');
+    const normalizedPath = unixify(possiblePath || '');
     return normalizedPath.startsWith('/') || /^(?:\.\/)?public\//i.test(normalizedPath) || /^\/public\//i.test(normalizedPath);
 }
 function toPublicOutput(possiblePath) {
-    const normalizedPath = paths_unixify(possiblePath || '');
+    const normalizedPath = unixify(possiblePath || '');
     if (/^\/public\//i.test(normalizedPath)) return normalizedPath.replace(/^\/public\//i, '');
     if (/^(?:\.\/)?public\//i.test(normalizedPath)) return normalizedPath.replace(/^(?:\.\/)?public\//i, '');
     if (/^\//.test(normalizedPath)) return normalizedPath.replace(/^\//, '');
@@ -6573,7 +10059,7 @@ function emitDirectoryAsAssets(compilation, absDir, baseDir) {
                 continue;
             }
             if (!entry.isFile()) continue;
-            const outName = paths_unixify(__rspack_external_node_path_c5b9b54f.relative(baseDir, full));
+            const outName = unixify(__rspack_external_node_path_c5b9b54f.relative(baseDir, full));
             if (!compilation.getAsset(outName)) compilation.emitAsset(outName, new core_sources.RawSource(__rspack_external_node_fs_5ea92f0c.readFileSync(full)));
             compilation.fileDependencies.add(full);
         }
@@ -6592,7 +10078,7 @@ function emitFileAsAsset(compilation, absPath) {
     }
     if (!compilation.getAsset(outName)) compilation.emitAsset(outName, new core_sources.RawSource(content));
     compilation.fileDependencies.add(absPath);
-    return paths_unixify(outName);
+    return unixify(outName);
 }
 function resolve_war_findSourceSibling(absOutputPath) {
     const candidatesByExt = {
@@ -6641,7 +10127,7 @@ function validateMatchesOrReport(compilation, matches, browser) {
     compilation.errors ||= [];
     for (const m of matches)if (!isValidChromeMatchPattern(m)) {
         const msg = warInvalidMatchPattern(m);
-        const err = new WebpackError(msg);
+        const err = new core_WebpackError(msg);
         err.file = 'manifest.json';
         err.name = 'WARInvalidMatchPattern';
         compilation.errors.push(err);
@@ -6709,7 +10195,7 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
                     publicRootHint: true,
                     relativeRef: res
                 });
-                const err = new WebpackError(msg);
+                const err = new core_WebpackError(msg);
                 err.file = 'manifest.json';
                 compilation.warnings.push(err);
             }
@@ -6733,7 +10219,7 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
                 relativeRef: res,
                 sourceSibling: sourceSibling ? __rspack_external_node_path_c5b9b54f.relative(manifestDir, sourceSibling) : void 0
             });
-            const warn = new WebpackError(msg);
+            const warn = new core_WebpackError(msg);
             warn.file = 'manifest.json';
             warn.name = 'WARRelativeAssetMissing';
             compilation.warnings.push(warn);
@@ -6741,11 +10227,11 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
         }
         if (__rspack_external_node_fs_5ea92f0c.statSync(abs).isDirectory()) {
             emitDirectoryAsAssets(compilation, abs, manifestDir);
-            const dirResource = `${paths_unixify(res).replace(/\/+$/, '')}/*`;
+            const dirResource = `${unixify(res).replace(/\/+$/, '')}/*`;
             pushResource(matches, dirResource, extra);
             return;
         }
-        const relOut = paths_unixify(__rspack_external_node_path_c5b9b54f.relative(manifestDir, abs));
+        const relOut = unixify(__rspack_external_node_path_c5b9b54f.relative(manifestDir, abs));
         if (!relOut.startsWith('..')) {
             if (!compilation.getAsset(relOut)) compilation.emitAsset(relOut, new core_sources.RawSource(__rspack_external_node_fs_5ea92f0c.readFileSync(abs)));
             compilation.fileDependencies.add(abs);
@@ -6759,7 +10245,7 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
         if ('string' == typeof entry) {
             if (isMv2) return void handleOne(void 0, entry);
             const msg = warStringEntryInMv3(entry);
-            const err = new WebpackError(msg);
+            const err = new core_WebpackError(msg);
             err.file = 'manifest.json';
             err.name = 'WARStringEntryInMv3';
             compilation.errors = compilation.errors || [];
@@ -6998,7 +10484,7 @@ class PatchWAR {
         compiler.hooks.thisCompilation.tap('manifest:patch-war', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'manifest:patch-war',
-                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT
             }, ()=>{
                 if (compilation.errors.length > 0) return;
                 if (isStaticThemeSource(this.manifestPath, this.browser)) return;
@@ -7075,7 +10561,7 @@ class PersistManifestToDisk {
         compiler.hooks.thisCompilation.tap('manifest:persist-manifest:capture', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'manifest:persist-manifest:capture',
-                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT + 1000
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 1000
             }, ()=>{
                 pendingHadErrors = compilation.errors.length > 0;
                 pendingOutputPath = compilation.outputOptions.path || compiler.options.output?.path;
@@ -7426,7 +10912,7 @@ class UpdateManifest {
         compiler.hooks.thisCompilation.tap('manifest:update-manifest', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'manifest:update-manifest',
-                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE + 1
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE + 1
             }, ()=>{
                 if (compilation.errors.length > 0) return;
                 const manifest = getManifestContent(compilation, this.manifestPath);
@@ -7452,13 +10938,13 @@ class UpdateManifest {
                 const sanitized = sanitizeFatalManifestShapes(patchedManifest, __rspack_external_node_path_c5b9b54f.dirname(this.manifestPath));
                 patchedManifest = sanitized.manifest;
                 for (const fix of sanitized.fixes){
-                    const warn = new WebpackError(fatalManifestShapeFixed(fix.field, fix.detail));
+                    const warn = new core_WebpackError(fatalManifestShapeFixed(fix.field, fix.detail));
                     warn.name = 'ManifestFatalShapeWarning';
                     warn.file = 'manifest.json';
                     compilation.warnings.push(warn);
                 }
                 if ('production' === compiler.options.mode && isGeckoBasedBrowser(String(this.browser)) && gecko_data_collection_missingGeckoDataCollectionPermissions(patchedManifest)) {
-                    const warn = new WebpackError(missingGeckoDataCollectionPermissions());
+                    const warn = new core_WebpackError(missingGeckoDataCollectionPermissions());
                     warn.name = 'AmoDataCollectionWarning';
                     warn.file = 'manifest.json';
                     compilation.warnings.push(warn);
@@ -7472,6 +10958,68 @@ class UpdateManifest {
         });
     }
 }
+const isChannel = (entry)=>'number' == typeof entry && Number.isInteger(entry) && entry >= 0 && entry <= 255;
+const isFiniteNumber = (entry)=>'number' == typeof entry && Number.isFinite(entry);
+function colorValueDetail(value) {
+    if (!Array.isArray(value) || 3 !== value.length && 4 !== value.length) return 'Chrome only accepts an [R, G, B] or [R, G, B, A] array here.';
+    for (const entry of value.slice(0, 3))if (!isChannel(entry)) return 'Chrome only accepts integer color channels from 0 to 255 here.';
+    if (4 === value.length && !isFiniteNumber(value[3])) return 'Chrome only accepts a numeric alpha channel here.';
+}
+function tintValueDetail(value) {
+    if (!Array.isArray(value) || 3 !== value.length || !value.every(isFiniteNumber)) return 'Chrome only accepts a [hue, saturation, lightness] array of 3 numbers here.';
+}
+function collectThemeValueIssues(manifest) {
+    const issues = [];
+    const theme = manifest?.theme;
+    if (!theme || 'object' != typeof theme) return issues;
+    const groups = [
+        [
+            'colors',
+            theme.colors,
+            colorValueDetail
+        ],
+        [
+            'tints',
+            theme.tints,
+            tintValueDetail
+        ]
+    ];
+    for (const [group, container, detailFor] of groups)if (!(!container || 'object' != typeof container || Array.isArray(container))) for (const [key, value] of Object.entries(container)){
+        const detail = detailFor(value);
+        if (detail) issues.push({
+            field: `theme.${group}.${key}`,
+            detail,
+            value: JSON.stringify(value)
+        });
+    }
+    return issues;
+}
+class ValidateThemeValues {
+    static name = 'manifest:validate-theme-values';
+    manifestPath;
+    browser;
+    constructor(options){
+        this.manifestPath = options.manifestPath;
+        this.browser = options.browser || 'chrome';
+    }
+    apply(compiler) {
+        if (!isChromiumBasedBrowser(String(this.browser))) return;
+        compiler.hooks.thisCompilation.tap(ValidateThemeValues.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: ValidateThemeValues.name,
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            }, ()=>{
+                let manifest;
+                try {
+                    manifest = filterKeysForThisBrowser(parseJsonSafe(__rspack_external_node_fs_5ea92f0c.readFileSync(this.manifestPath, 'utf8')), this.browser);
+                } catch  {
+                    return;
+                }
+                for (const issue of collectThemeValueIssues(manifest))reportToCompilation(compilation, compiler, invalidThemeValue(issue.field, issue.detail, issue.value), 'error', 'manifest.json');
+            });
+        });
+    }
+}
 class ManifestPlugin {
     manifestPath;
     browser;
@@ -7487,6 +11035,10 @@ class ManifestPlugin {
             manifestPath: this.manifestPath,
             browser: this.browser
         }).apply(compiler);
+        new ValidateThemeValues({
+            manifestPath: this.manifestPath,
+            browser: this.browser
+        }).apply(compiler);
         new UpdateManifest({
             manifestPath: this.manifestPath,
             browser: this.browser
@@ -7540,7 +11092,7 @@ function getMainWorldBridgeScripts(manifestPath, browser = 'chrome') {
     const bridgeScripts = {};
     try {
         const raw = JSON.parse(stripBom(node_fs.readFileSync(manifestPath, 'utf-8')));
-        const resolved = manifest_utils_filterKeysForThisBrowser(raw, browser);
+        const resolved = filterKeysForThisBrowser(raw, browser);
         const contentScripts = Array.isArray(resolved?.content_scripts) ? resolved.content_scripts : [];
         const originalCount = contentScripts.length;
         const bridgeSource = resolveMainWorldBridgeSourcePath();
@@ -7857,7 +11409,7 @@ class ValidateContentScriptSyntax {
         compiler.hooks.thisCompilation.tap("scripts:validate-content-script-syntax", (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: "scripts:validate-content-script-syntax",
-                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT
             }, ()=>{
                 const assets = 'function' == typeof compilation.getAssets ? compilation.getAssets() : [];
                 for (const asset of assets){
@@ -7875,7 +11427,7 @@ class ValidateContentScriptSyntax {
                     } catch (caught) {
                         const error = caught;
                         if (error?.name !== 'SyntaxError') continue;
-                        const err = new WebpackError([
+                        const err = new core_WebpackError([
                             `${name} is not valid JavaScript: ${error.message}.`,
                             "The browser will silently skip an unparsable content script:",
                             'it never injects and reports no error anywhere. Fix the syntax',
@@ -8009,7 +11561,7 @@ function collectContentScriptEntryImports(compilation, includeList) {
         const name = entryImportsEntries[i][0];
         const files = entryImportsEntries[i][1];
         const normalizedFiles = [];
-        for(let j = 0; j < files.length; j++)normalizedFiles.push(paths_unixify(files[j]));
+        for(let j = 0; j < files.length; j++)normalizedFiles.push(unixify(files[j]));
         entryImports[name] = normalizedFiles;
     }
     return entryImports;
@@ -8023,7 +11575,7 @@ class CollectContentEntryImports {
         compiler.hooks.thisCompilation.tap('plugin-extension:feature-web-resources:collect-entry-imports', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'plugin-extension:feature-web-resources:collect-entry-imports',
-                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
             }, ()=>{
                 const entryImports = collectContentScriptEntryImports(compilation, this.includeList);
                 const shared = getSharedFor(compilation);
@@ -8160,7 +11712,7 @@ class ManifestFieldsChangeDetector {
         compiler.hooks.thisCompilation.tap('manifest:fields-change-detector', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'manifest:fields-change-detector',
-                stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY
             }, ()=>{
                 this.emitErrors(compilation);
                 this.pending = {};
@@ -8171,21 +11723,21 @@ class ManifestFieldsChangeDetector {
         if (this.pending.scripts) {
             const p = this.pending.scripts;
             const msg = serverRestartRequiredFromManifestError(p.pathAfter || '', p.pathBefore || '');
-            const err = new WebpackError(msg);
+            const err = new core_WebpackError(msg);
             err.file = 'manifest.json';
             compilation.errors.push(err);
         }
         if (this.pending.html) {
             const p = this.pending.html;
             const msg = manifestHtmlEntrypointChange(p.manifestField, p.pathAfter, p.pathBefore);
-            const err = new WebpackError(msg);
+            const err = new core_WebpackError(msg);
             err.file = 'manifest.json';
             compilation.errors.push(err);
         }
         if (this.pending.icons) {
             const p = this.pending.icons;
             const msg = manifestIconsEntrypointChange(p.manifestField, p.pathAfter, p.pathBefore);
-            const err = new WebpackError(msg);
+            const err = new core_WebpackError(msg);
             err.file = 'manifest.json';
             compilation.errors.push(err);
         }
@@ -8197,13 +11749,13 @@ class ManifestFieldsChangeDetector {
             lines.push('');
             if (p.pathBefore) lines.push(`PATH BEFORE ${p.pathBefore}`);
             if (p.pathAfter) lines.push(`PATH AFTER ${p.pathAfter}`);
-            const err = new WebpackError(lines.join('\n'));
+            const err = new core_WebpackError(lines.join('\n'));
             err.file = 'manifest.json';
             compilation.errors.push(err);
         }
     }
 }
-class WebExtensionPlugin {
+class plugin_web_extension_WebExtensionPlugin {
     static name = 'plugin-extension';
     manifestPath;
     browser;
@@ -8282,7 +11834,7 @@ function webpackConfig(projectStructure, devOptions) {
     } catch (error) {
         throw new Error(manifestInvalidJson(manifestPath, error));
     }
-    const manifest = manifest_utils_filterKeysForThisBrowser(rawManifest, devOptions.browser);
+    const manifest = filterKeysForThisBrowser(rawManifest, devOptions.browser);
     const primaryExtensionOutputDir = asAbsolute(__rspack_external_node_path_c5b9b54f.isAbsolute(devOptions.output.path) ? devOptions.output.path : __rspack_external_node_path_c5b9b54f.resolve(packageJsonDir, devOptions.output.path));
     const companionUnpackedExtensionDirs = resolveCompanionExtensionDirs({
         projectRoot: packageJsonDir,
@@ -8337,7 +11889,7 @@ function webpackConfig(projectStructure, devOptions) {
             browser: devOptions.browser,
             polyfill: devOptions.polyfill
         }),
-        new WebExtensionPlugin({
+        new plugin_web_extension_WebExtensionPlugin({
             manifestPath,
             browser: devOptions.browser
         }),
@@ -8383,7 +11935,8 @@ function webpackConfig(projectStructure, devOptions) {
             apply (compiler) {
                 const target = String(devOptions.browser);
                 const isChromiumTarget = isChromiumBasedBrowser(target);
-                if (manifest?.manifest_version !== 2 || !isChromiumTarget) return;
+                const isThemeManifest = Boolean(manifest?.theme && 'object' == typeof manifest.theme);
+                if (manifest?.manifest_version !== 2 || !isChromiumTarget || isThemeManifest) return;
                 compiler.hooks.thisCompilation.tap('warn-mv2-on-chromium', (compilation)=>{
                     const ErrorCtor = compiler.rspack?.WebpackError || Error;
                     const usesBlockingWebRequest = Array.isArray(manifest.permissions) && manifest.permissions.includes('webRequestBlocking');
@@ -8415,7 +11968,8 @@ function webpackConfig(projectStructure, devOptions) {
         instanceId: devOptions.instanceId,
         controlPort: devOptions.controlPort,
         controlPath: devOptions.controlPath,
-        logsPath: devOptions.logsPath
+        logsPath: devOptions.logsPath,
+        managedExtensionDirs: unpackedExtensionDirsToLoad.filter((dir)=>__rspack_external_node_path_c5b9b54f.resolve(dir) !== __rspack_external_node_path_c5b9b54f.resolve(primaryExtensionOutputDir))
     }));
     if (devOptions.browsersPlugin) {
         const browsersPlugin = devOptions.browsersPlugin;