extension-develop 4.0.11 → 4.0.12

package/dist/0~rspack-config.mjs

@@ -1,26 +1,26 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
 import { __webpack_require__ } from "./0~rslib-runtime.mjs";
 import { createRequire } from "module";
-import core, { Compilation as core_Compilation, DefinePlugin, ProvidePlugin, WebpackError as core_WebpackError, rspack, sources as core_sources } from "@rspack/core";
+import core, { Compilation, DefinePlugin, ProvidePlugin, WebpackError, rspack, sources as core_sources } from "@rspack/core";
 import pintor from "pintor";
 import case_sensitive_paths_webpack_plugin from "case-sensitive-paths-webpack-plugin";
 import adm_zip from "adm-zip";
 import tiny_glob from "tiny-glob";
 import ignore from "ignore";
 import { pathToFileURL } from "url";
-import { filterKeysForThisBrowser as external_browser_extension_manifest_fields_filterKeysForThisBrowser, getManifestFieldsData } from "browser-extension-manifest-fields";
+import { filterKeysForThisBrowser, getManifestFieldsData } from "browser-extension-manifest-fields";
 import content_security_policy_parser from "content-security-policy-parser";
 import path_0 from "path";
 import fs from "fs";
-import { debugExtensionsToLoad, treeWithSourceFiles, getDirs, bundlerFatalError, bundlerRecompiling, asAbsolute, browserRunnerDisabled, packagingDistributionFiles, PlaywrightPlugin, toPosixPath, constants_isGeckoBasedBrowser, debugContextPath, resolveCompanionExtensionDirs, noEntrypointsDetected, GECKO_FAMILY_ALIASES, packagingSourceFiles, debugBrowser, debugOutputPath, messages_ready, manifestInvalidJson, spacerLine, isChromiumBasedBrowser, CHROMIUM_FAMILY_ALIASES, treeWithSourceAndDistFiles, treeWithDistFilesbrowser, getSpecialFoldersDataForCompiler, computeExtensionsToLoad, noCompanionExtensionsResolved } from "./101.mjs";
 import { isResourceUnderDirs, canonicalizeDir, toResourceKey } from "./93.mjs";
-import { injectedFileDependencyMissing, importScriptsDependencyMissing, getURLDependencyMissing, staticImportDependencyMissing, fetchedFileDependencyMissing, backgroundIsRequiredMessageOnly, runtimeSetSurfaceDependencyMissing } from "./266.mjs";
-import { getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, EXTENSIONJS_CONTENT_SCRIPT_LAYER, isCanonicalContentScriptAsset, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName } from "./291.mjs";
+import { injectedFileDependencyMissing, importScriptsDependencyMissing, getURLDependencyMissing, staticImportDependencyMissing, fetchedFileDependencyMissing, runtimeSetSurfaceDependencyMissing } from "./266.mjs";
+import { setCurrentManifestContent, jsFrameworksIntegrationsEnabled, ensureTypeScriptConfig, ensureOptionalContractModuleLoaded, resolveDevelopInstallRoot, filterKeysForThisBrowser as manifest_utils_filterKeysForThisBrowser, isUsingCustomLoader, getUserTypeScriptConfigFile, normalizeManifestOutputPath, ReloadPlugin, jsFrameworksHmrSummary, getManifestContent, hasDependency, isFromFilepathList, setOriginalManifestContent, optional_deps_resolver_ensureOptionalContractPackageResolved, getManifestOverrides, isUsingTypeScript, resolveRootAbsoluteRef, buildCanonicalManifest, getCurrentManifestContent, loadOptionalContractModuleWithoutInstall, isUsingIntegration as messages_isUsingIntegration, resolveOptionalContractPackageWithoutInstall, reportToCompilation, collectRootAbsoluteRefs, jsFrameworksConfigsDetected, resolveDevelopDistFile, unixify as paths_unixify } from "./839.mjs";
+import { debugExtensionsToLoad, treeWithSourceFiles, getDirs, bundlerFatalError, bundlerRecompiling, asAbsolute, browserRunnerDisabled, packagingDistributionFiles, PlaywrightPlugin, toPosixPath, constants_isGeckoBasedBrowser, debugContextPath, resolveCompanionExtensionDirs, noEntrypointsDetected, GECKO_FAMILY_ALIASES, packagingSourceFiles, debugBrowser, debugOutputPath, messages_ready, manifestInvalidJson, spacerLine, isChromiumBasedBrowser, CHROMIUM_FAMILY_ALIASES, treeWithSourceAndDistFiles, treeWithDistFilesbrowser, getSpecialFoldersDataForCompiler, computeExtensionsToLoad, noCompanionExtensionsResolved } from "./101.mjs";
 import { stripBom, parseJsonSafe } from "./23.mjs";
 import { scrubBrand, makeSanitizedConsole } from "./0~branding.mjs";
 import { cssIntegrationsEnabled, cssConfigsDetected, deadCssUrlRef, missingSassDependency, isUsingIntegration, postCssPluginNotResolved } from "./845.mjs";
-import { isUsingTypeScript, jsFrameworksIntegrationsEnabled, ensureTypeScriptConfig, ensureOptionalContractModuleLoaded, resolveDevelopInstallRoot, getUserTypeScriptConfigFile, isUsingCustomLoader, isUsingIntegration as messages_isUsingIntegration, loadOptionalContractModuleWithoutInstall, resolveOptionalContractPackageWithoutInstall, jsFrameworksHmrSummary, jsFrameworksConfigsDetected, hasDependency, resolveDevelopDistFile, optional_deps_resolver_ensureOptionalContractPackageResolved } from "./839.mjs";
 import { PROJECT_MANIFEST_FILENAMES, findNearestProjectManifestSync, readProjectDependencies } from "./80.mjs";
+import { getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, getCanonicalContentScriptJsAssetName, isCanonicalContentScriptAsset, EXTENSIONJS_CONTENT_SCRIPT_LAYER } from "./291.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
@@ -34,50 +34,6 @@ __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 = constants_isGeckoBasedBrowser(String(browser));
-    const chromiumPrefixes = new Set([
-        'chromium',
-        'chrome',
-        'edge'
-    ]);
-    const geckoPrefixes = new Set([
-        'gecko',
-        'firefox'
-    ]);
-    const webkitPrefixes = new Set([
-        'safari',
-        'webkit'
-    ]);
-    const isFamilyPrefix = (prefix)=>isChromiumTarget && chromiumPrefixes.has(prefix) || isGeckoTarget && geckoPrefixes.has(prefix);
-    const isSpecificPrefix = (prefix)=>prefix === browser || isSafariTarget && webkitPrefixes.has(prefix);
-    const resolve = (node)=>{
-        if (Array.isArray(node)) return node.map((item)=>resolve(item));
-        if (node && 'object' == typeof node) {
-            const result = {};
-            const familyMatches = {};
-            const specificMatches = {};
-            for (const [key, value] of Object.entries(node)){
-                const indexOfColon = key.indexOf(':');
-                if (-1 === indexOfColon) {
-                    result[key] = resolve(value);
-                    continue;
-                }
-                const prefix = key.substring(0, indexOfColon);
-                const strippedKey = key.substring(indexOfColon + 1);
-                if (isSpecificPrefix(prefix)) specificMatches[strippedKey] = resolve(value);
-                else if (isFamilyPrefix(prefix)) familyMatches[strippedKey] = resolve(value);
-            }
-            for (const [strippedKey, value] of Object.entries(familyMatches))result[strippedKey] = value;
-            for (const [strippedKey, value] of Object.entries(specificMatches))result[strippedKey] = value;
-            return result;
-        }
-        return node;
-    };
-    return resolve(manifest);
-}
 function normalizePath(filePath) {
     return filePath.replace(/\\/g, '/');
 }
@@ -223,14 +179,14 @@ class WarnUponFolderChanges {
         const typeOfAsset = 'pages' === folder ? 'HTML pages' : "script files";
         const errorMessage = serverRestartRequiredFromSpecialFolderMessageOnly(addingOrRemoving, folder, typeOfAsset);
         if (isAddition) {
-            const warn = new core_WebpackError(errorMessage);
+            const warn = new 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 core_WebpackError(errorMessage);
+        const err = new WebpackError(errorMessage);
         err.name = 'SpecialFoldersRemoval';
         err.file = filePath;
         err.details = `Removing from ${folder}/ breaks current build. Restart the dev server to recompile.`;
@@ -297,64 +253,12 @@ function checkManifestInPublic(compilation, publicDir) {
     try {
         const manifestInPublic = __rspack_external_path.join(publicDir, 'manifest.json');
         if (__rspack_external_fs.existsSync(manifestInPublic)) {
-            const err = new core_WebpackError(`manifest.json must not be placed under public/: ${manifestInPublic}`);
+            const err = new WebpackError(`manifest.json must not be placed under public/: ${manifestInPublic}`);
             err.file = 'manifest.json';
             compilation.errors.push(err);
         }
     } catch  {}
 }
-function isFromFilepathList(filePath, filepathList) {
-    return Object.values(filepathList || {}).some((value)=>value === filePath);
-}
-function getFilename(feature, filePath) {
-    const entryExt = __rspack_external_path.extname(filePath);
-    let fileOutputpath = feature;
-    if ([
-        '.js',
-        '.jsx',
-        '.tsx',
-        '.ts',
-        '.vue',
-        '.svelte'
-    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.js');
-    if ([
-        '.html',
-        '.njk',
-        '.nunjucks'
-    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.html');
-    if ([
-        '.css',
-        '.scss',
-        '.sass',
-        '.less'
-    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.css');
-    return unixify(fileOutputpath || '');
-}
-function unixify(filePath) {
-    return filePath.replace(/\\/g, '/');
-}
-function resolveRootAbsoluteRef(ref, projectRoot, publicRoot) {
-    if (!ref || !ref.startsWith('/')) return;
-    if (projectRoot && ref.startsWith(projectRoot)) return;
-    if (ref.startsWith('//')) return;
-    const trimmed = ref.replace(/^\/+/, '');
-    if (!trimmed) return;
-    if (publicRoot && __rspack_external_fs.existsSync(__rspack_external_path.join(publicRoot, trimmed))) return;
-    const candidate = __rspack_external_path.resolve(projectRoot, trimmed);
-    const rel = __rspack_external_path.relative(projectRoot, candidate);
-    if (rel.startsWith('..') || __rspack_external_path.isAbsolute(rel)) return;
-    if (!__rspack_external_fs.existsSync(candidate) || !__rspack_external_fs.statSync(candidate).isFile()) return;
-    return candidate;
-}
-function collectRootAbsoluteRefs(source) {
-    const refs = new Set();
-    const attrRe = /(?:src|href)\s*=\s*["'](\/[^"'#?]*)["']/gi;
-    const urlRe = /url\(\s*["']?(\/[^"')#?]+)["']?\s*\)/gi;
-    let m;
-    while(m = attrRe.exec(source))refs.add(m[1]);
-    while(m = urlRe.exec(source))refs.add(m[1]);
-    return refs;
-}
 const EMITTED_WORKER_PATH = 'background/service_worker.js';
 const MAX_TRACE_DEPTH = 8;
 const SOURCE_SIBLING_EXTENSIONS = [
@@ -373,7 +277,7 @@ class TraceRuntimeLoadedFiles {
         compiler.hooks.thisCompilation.tap(TraceRuntimeLoadedFiles.name, (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: TraceRuntimeLoadedFiles.name,
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
             }, ()=>{
                 this.traceWorkerImportScripts(compilation);
                 this.traceInjectedFilePayloads(compilation);
@@ -397,7 +301,7 @@ class TraceRuntimeLoadedFiles {
         const workerAsset = compilation.getAsset(EMITTED_WORKER_PATH);
         if (!workerAsset) return;
         const manifestDir = __rspack_external_path.dirname(this.manifestPath);
-        const sourceWorkerPath = trace_runtime_loaded_files_unixify(String(workerRef)).replace(/^\/+/, '');
+        const sourceWorkerPath = unixify(String(workerRef)).replace(/^\/+/, '');
         let pending = [
             workerAsset.source.source().toString()
         ];
@@ -455,7 +359,7 @@ class TraceRuntimeLoadedFiles {
                     continue;
                 }
                 if (/\.[a-zA-Z0-9]{1,8}$/.test(distRel)) {
-                    const warn = new core_WebpackError(fetchedFileDependencyMissing(asset.name, literal, distRel));
+                    const warn = new WebpackError(fetchedFileDependencyMissing(asset.name, literal, distRel));
                     warn.name = 'RuntimeFetchedFileMissing';
                     warn.file = asset.name;
                     compilation.warnings ||= [];
@@ -523,7 +427,7 @@ class TraceRuntimeLoadedFiles {
                         continue;
                     }
                     if ('js' === item.kind && /\.[a-zA-Z0-9]{1,8}$/.test(distRel)) {
-                        const warn = new core_WebpackError(isStaticImport ? staticImportDependencyMissing(item.assetName, literal, distRel) : isRuntimeSurface ? runtimeSetSurfaceDependencyMissing(item.assetName, literal, distRel) : getURLDependencyMissing(item.assetName, literal, distRel));
+                        const warn = new 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 ||= [];
@@ -541,7 +445,7 @@ class TraceRuntimeLoadedFiles {
         for (const asset of jsAssets){
             const content = asset.source.source().toString();
             if (!hasWebpackChunkLoadingRuntime(content)) continue;
-            const assetDirRel = __rspack_external_path.posix.dirname(trace_runtime_loaded_files_unixify(asset.name));
+            const assetDirRel = __rspack_external_path.posix.dirname(unixify(asset.name));
             const sourceDirs = new Set();
             const entryDir = entrySourceDirs.get(asset.name.replace(/\.js$/i, ''));
             if (entryDir) sourceDirs.add(entryDir);
@@ -622,7 +526,7 @@ function copyThroughOrWarn(compilation, opts) {
         return buffer.toString();
     }
     const sourceSibling = findSourceSibling(abs);
-    const warn = new core_WebpackError(opts.warning(opts.sourceRel, sourceSibling ? trace_runtime_loaded_files_unixify(__rspack_external_path.relative(opts.manifestDir, sourceSibling)) : void 0));
+    const warn = new WebpackError(opts.warning(opts.sourceRel, sourceSibling ? unixify(__rspack_external_path.relative(opts.manifestDir, sourceSibling)) : void 0));
     warn.name = opts.warningName;
     warn.file = opts.warningFile;
     compilation.warnings ||= [];
@@ -634,7 +538,7 @@ function findSourceSibling(abs) {
     const base = abs.slice(0, -3);
     return SOURCE_SIBLING_EXTENSIONS.map((ext)=>base + ext).find((candidate)=>__rspack_external_fs.existsSync(candidate));
 }
-function trace_runtime_loaded_files_unixify(filePath) {
+function unixify(filePath) {
     return filePath.replace(/\\/g, '/');
 }
 function resolveExtensionPath(literal, basePath) {
@@ -643,7 +547,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/' + trace_runtime_loaded_files_unixify(basePath));
+        const base = new URL('chrome-extension://extension-js/' + unixify(basePath));
         const resolved = new URL(trimmed, base);
         if ('extension-js' !== resolved.hostname) return null;
         const pathname = decodeURIComponent(resolved.pathname).replace(/^\/+/, '');
@@ -656,7 +560,7 @@ function manifestDeclaredSourcePaths(manifest) {
     const declared = new Set();
     if (!manifest) return declared;
     const add = (value)=>{
-        if ('string' == typeof value && value.trim()) declared.add(trace_runtime_loaded_files_unixify(value.trim()).replace(/^\/+/, '').split(/[?#]/)[0]);
+        if ('string' == typeof value && value.trim()) declared.add(unixify(value.trim()).replace(/^\/+/, '').split(/[?#]/)[0]);
     };
     add(manifest.background?.service_worker);
     add(manifest.background?.page);
@@ -823,7 +727,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 ? trace_runtime_loaded_files_unixify(noQuery) : null;
+    return noQuery ? unixify(noQuery) : null;
 }
 function blankComments(source) {
     let out = '';
@@ -1079,590 +983,6 @@ function envInjectedPublicVars(count) {
 function envNoMatchingFile(browser, mode, presentFiles, expectedCandidates) {
     return `Found ${presentFiles.map((file)=>pintor.yellow(file)).join(', ')} but none match browser ${pintor.yellow(browser)} (mode ${pintor.yellow(mode)}), so EXTENSION_PUBLIC_* variables read from code will be ${pintor.yellow('undefined')} in this build.\nMatching names, in priority order: ${expectedCandidates.map((file)=>pintor.gray(file)).join(', ')}.\nFamily names apply to every family member — e.g. ${pintor.yellow('.env.chrome')} also matches ${pintor.yellow('chromium')} and ${pintor.yellow('edge')} targets.`;
 }
-function background_background(manifest) {
-    return manifest.background && manifest.background.scripts && {
-        background: {
-            scripts: [
-                ...new Set(manifest.background.scripts.map((script)=>getFilename("background/scripts.js", String(script))))
-            ]
-        }
-    };
-}
-function normalizeManifestOutputPath(originalPath) {
-    if (!originalPath) return originalPath;
-    const unixPath = originalPath.replace(/\\/g, '/');
-    if (/^\/public\//i.test(unixPath)) return unixPath.replace(/^\/public\//i, '');
-    if (/^(?:\.\/)?public\//i.test(unixPath)) return unixPath.replace(/^(?:\.\/)?public\//i, '');
-    if (/^\//.test(unixPath)) return unixPath.replace(/^\//, '');
-    return unixPath;
-}
-function manifestPageOutputTarget(raw, compiledTarget, manifestPath) {
-    const unixPath = raw.replace(/\\/g, '/');
-    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(unixPath)) return normalizeManifestOutputPath(unixPath);
-    if (/^\//.test(unixPath)) {
-        const rest = unixPath.replace(/^\/+/, '');
-        if (manifestPath && rest) {
-            const manifestDir = __rspack_external_path.dirname(manifestPath);
-            const inPublic = __rspack_external_fs.existsSync(__rspack_external_path.join(manifestDir, 'public', rest));
-            const inRoot = __rspack_external_fs.existsSync(__rspack_external_path.join(manifestDir, rest));
-            if (inRoot && !inPublic) return compiledTarget;
-        }
-        return normalizeManifestOutputPath(unixPath);
-    }
-    return compiledTarget;
-}
-function iconOutputPath(raw) {
-    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw)) return normalizeManifestOutputPath(raw);
-    const normalized = normalizeManifestOutputPath(raw).replace(/^\.\//, '');
-    const escapes = !normalized || normalized.split('/').includes('..') || /^[A-Za-z]:/.test(normalized);
-    return escapes ? `icons/${normalized.split('/').pop() || ''}` : normalized;
-}
-function browserAction(manifest) {
-    return manifest.browser_action && {
-        browser_action: {
-            ...manifest.browser_action,
-            ...manifest.browser_action.default_popup && {
-                default_popup: getFilename('action/index.html', manifest.browser_action.default_popup)
-            },
-            ...manifest.browser_action.default_icon && {
-                default_icon: 'string' == typeof manifest.browser_action.default_icon ? (()=>{
-                    const raw = String(manifest.browser_action.default_icon);
-                    return getFilename(iconOutputPath(raw), raw);
-                })() : Object.fromEntries(Object.entries(manifest.browser_action.default_icon).map(([size, icon])=>{
-                    const raw = String(icon);
-                    return [
-                        size,
-                        getFilename(iconOutputPath(raw), raw)
-                    ];
-                }))
-            },
-            ...manifest.browser_action.theme_icons && {
-                theme_icons: manifest.browser_action.theme_icons.map((themeIcon)=>({
-                        ...themeIcon,
-                        ...themeIcon.light && {
-                            light: (()=>{
-                                const raw = String(themeIcon.light);
-                                const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
-                                const target = isPublic ? normalizeManifestOutputPath(raw) : `browser_action/${__rspack_external_path.basename(raw)}`;
-                                return getFilename(target, raw);
-                            })()
-                        },
-                        ...themeIcon.dark && {
-                            dark: (()=>{
-                                const raw = String(themeIcon.dark);
-                                const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
-                                const target = isPublic ? normalizeManifestOutputPath(raw) : `browser_action/${__rspack_external_path.basename(raw)}`;
-                                return getFilename(target, raw);
-                            })()
-                        }
-                    }))
-            }
-        }
-    };
-}
-function chromeSettingsOverrides(manifest) {
-    return manifest.chrome_settings_overrides && {
-        chrome_settings_overrides: {
-            ...manifest.chrome_settings_overrides.homepage && {
-                homepage: manifest.chrome_settings_overrides.homepage
-            },
-            ...manifest.chrome_settings_overrides.search_provider && {
-                search_provider: {
-                    ...manifest.chrome_settings_overrides.search_provider,
-                    ...manifest.chrome_settings_overrides.search_provider.favicon_url && {
-                        favicon_url: (()=>{
-                            const fav = manifest.chrome_settings_overrides.search_provider.favicon_url;
-                            const isUrl = /^(?:[a-z]+:)?\/\//i.test(fav);
-                            return isUrl ? fav : getFilename(`chrome_settings_overrides/${fav.split('/').pop()}`, fav);
-                        })()
-                    }
-                }
-            },
-            ...manifest.chrome_settings_overrides.startup_pages && {
-                startup_pages: manifest.chrome_settings_overrides.startup_pages.map((page, index)=>getFilename(`chrome_settings_overrides/startup-${index}.html`, page))
-            }
-        }
-    };
-}
-function pageAction(manifest) {
-    return manifest.page_action && {
-        page_action: {
-            ...manifest.page_action,
-            ...manifest.page_action.default_popup && {
-                default_popup: getFilename('action/index.html', manifest.page_action.default_popup)
-            },
-            ...manifest.page_action.default_icon && {
-                default_icon: 'string' == typeof manifest.page_action.default_icon ? (()=>{
-                    const raw = String(manifest.page_action.default_icon);
-                    return getFilename(iconOutputPath(raw), raw);
-                })() : Object.fromEntries(Object.entries(manifest.page_action.default_icon).map(([size, icon])=>{
-                    const raw = String(icon);
-                    return [
-                        size,
-                        getFilename(iconOutputPath(raw), raw)
-                    ];
-                }))
-            }
-        }
-    };
-}
-function sidebarAction(manifest) {
-    return manifest.sidebar_action && {
-        sidebar_action: {
-            ...manifest.sidebar_action,
-            ...manifest.sidebar_action.default_panel && {
-                default_panel: getFilename("sidebar/index.html", manifest.sidebar_action.default_panel)
-            },
-            ...manifest.sidebar_action.default_icon && {
-                default_icon: 'string' == typeof manifest.sidebar_action.default_icon ? (()=>{
-                    const raw = String(manifest.sidebar_action.default_icon);
-                    return getFilename(iconOutputPath(raw), raw);
-                })() : Object.fromEntries(Object.entries(manifest.sidebar_action.default_icon).map(([size, icon])=>{
-                    const raw = String(icon);
-                    return [
-                        size,
-                        getFilename(iconOutputPath(raw), raw)
-                    ];
-                }))
-            }
-        }
-    };
-}
-const getBasename = (filepath)=>__rspack_external_path.basename(filepath);
-function themeExperiment(manifest) {
-    const te = manifest.theme_experiment;
-    return te && {
-        theme_experiment: {
-            ...te,
-            ...'string' == typeof te.stylesheet && {
-                stylesheet: getFilename(`theme_experiment/${getBasename(te.stylesheet)}`, te.stylesheet)
-            },
-            ...Array.isArray(te.stylesheets) && {
-                stylesheets: te.stylesheets.map((s, i)=>getFilename(`theme_experiment/stylesheet-${i}.css`, s))
-            }
-        }
-    };
-}
-function manifestV2(manifest) {
-    return {
-        ...background_background(manifest),
-        ...browserAction(manifest),
-        ...pageAction(manifest),
-        ...sidebarAction(manifest),
-        ...chromeSettingsOverrides(manifest),
-        ...themeExperiment(manifest)
-    };
-}
-function action_action(manifest) {
-    return manifest.action && {
-        action: {
-            ...manifest.action,
-            ...manifest.action.default_popup && {
-                default_popup: getFilename("action/index.html", manifest.action.default_popup)
-            },
-            ...manifest.action.default_icon && {
-                default_icon: 'string' == typeof manifest.action.default_icon ? (()=>{
-                    const raw = String(manifest.action.default_icon);
-                    return getFilename(iconOutputPath(raw), raw);
-                })() : Object.fromEntries(Object.entries(manifest.action.default_icon).map(([size, icon])=>{
-                    const raw = String(icon);
-                    return [
-                        size,
-                        getFilename(iconOutputPath(raw), raw)
-                    ];
-                }))
-            }
-        }
-    };
-}
-function backgroundServiceWorker(manifest) {
-    return manifest.background && manifest.background.service_worker && {
-        background: {
-            service_worker: (()=>{
-                const raw = String(manifest.background.service_worker);
-                return getFilename('background/service_worker.js', raw);
-            })()
-        }
-    };
-}
-function declarativeNetRequest(manifest) {
-    return manifest.declarative_net_request && {
-        declarative_net_request: {
-            ...manifest.declarative_net_request,
-            rule_resources: manifest.declarative_net_request.rule_resources.map((resourceObj)=>({
-                    ...resourceObj,
-                    path: resourceObj.path && getFilename(`declarative_net_request/${resourceObj.id}.json`, resourceObj.path)
-                }))
-        }
-    };
-}
-function hostPermissions(manifest) {
-    return manifest.host_permissions && {
-        host_permissions: manifest.host_permissions
-    };
-}
-function sidePanel(manifest) {
-    return manifest.side_panel && {
-        side_panel: {
-            ...manifest.side_panel,
-            ...manifest.side_panel.default_path && {
-                default_path: (()=>{
-                    const raw = String(manifest.side_panel.default_path);
-                    return getFilename('sidebar/index.html', raw);
-                })()
-            }
-        }
-    };
-}
-function manifestV3(manifest) {
-    return {
-        ...action_action(manifest),
-        ...backgroundServiceWorker(manifest),
-        ...declarativeNetRequest(manifest),
-        ...hostPermissions(manifest),
-        ...sidePanel(manifest)
-    };
-}
-function backgroundPage(manifest) {
-    return manifest.background && manifest.background.page && {
-        background: {
-            page: (()=>{
-                const raw = String(manifest.background.page);
-                return getFilename('background/index.html', raw);
-            })()
-        }
-    };
-}
-function chromeUrlOverrides(manifest, manifestPath) {
-    return manifest.chrome_url_overrides && {
-        chrome_url_overrides: {
-            ...manifest.chrome_url_overrides.bookmarks && {
-                bookmarks: (()=>{
-                    const raw = String(manifest.chrome_url_overrides.bookmarks);
-                    return getFilename(manifestPageOutputTarget(raw, 'chrome_url_overrides/bookmarks.html', manifestPath), raw);
-                })()
-            },
-            ...manifest.chrome_url_overrides.history && {
-                history: (()=>{
-                    const raw = String(manifest.chrome_url_overrides.history);
-                    return getFilename(manifestPageOutputTarget(raw, 'chrome_url_overrides/history.html', manifestPath), raw);
-                })()
-            },
-            ...manifest.chrome_url_overrides.newtab && {
-                newtab: (()=>{
-                    const raw = String(manifest.chrome_url_overrides.newtab);
-                    return getFilename(manifestPageOutputTarget(raw, 'chrome_url_overrides/newtab.html', manifestPath), raw);
-                })()
-            }
-        }
-    };
-}
-function isBundledContentPath(filePath, ext) {
-    const normalized = String(filePath || '').replace(/\\/g, '/');
-    const bundledAsset = parseCanonicalContentScriptAsset(normalized);
-    return bundledAsset?.extension === ext;
-}
-function isAlreadyBundledContentScripts(contentScripts) {
-    if (!Array.isArray(contentScripts) || 0 === contentScripts.length) return false;
-    return contentScripts.every((contentObj)=>{
-        const js = Array.isArray(contentObj?.js) ? contentObj.js : [];
-        const css = Array.isArray(contentObj?.css) ? contentObj.css : [];
-        return js.every((filePath)=>isBundledContentPath(filePath, 'js')) && css.every((filePath)=>isBundledContentPath(filePath, 'css'));
-    });
-}
-function content_scripts_contentScripts(manifest, manifestPath) {
-    if (!manifest.content_scripts) return;
-    const original = manifest.content_scripts;
-    if (isAlreadyBundledContentScripts(original)) return {
-        content_scripts: original
-    };
-    const originalCount = original.length;
-    const result = [];
-    let bridgeOrdinal = 0;
-    for(let index = 0; index < original.length; index++){
-        const contentObj = original[index] || {};
-        const contentJs = [
-            ...new Set(contentObj.js || [])
-        ];
-        const contentCss = [
-            ...new Set(contentObj.css || [])
-        ];
-        if ('MAIN' === contentObj.world) {
-            const bridgeIndex = originalCount + bridgeOrdinal++;
-            const { world: _ignoredWorld, js: _ignoredJs, css: _ignoredCss, ...rest } = contentObj;
-            result.push({
-                ...rest,
-                js: [
-                    getFilename(getCanonicalContentScriptJsAssetName(bridgeIndex), 'main-world-bridge.js')
-                ],
-                css: []
-            });
-        }
-        result.push({
-            ...original[index] || {},
-            js: [
-                ...new Set(contentJs.map((js)=>getFilename(getCanonicalContentScriptJsAssetName(index), js)))
-            ],
-            css: [
-                ...new Set(contentCss.map((css)=>getFilename(getCanonicalContentScriptCssAssetName(index), css)))
-            ]
-        });
-    }
-    return {
-        content_scripts: result
-    };
-}
-function devtoolsPage(manifest, manifestPath) {
-    return manifest.devtools_page && {
-        devtools_page: (()=>{
-            const raw = String(manifest.devtools_page);
-            return getFilename(manifestPageOutputTarget(raw, 'devtools/index.html', manifestPath), raw);
-        })()
-    };
-}
-function icons_icons(manifest) {
-    return manifest.icons && {
-        icons: Object.fromEntries(Object.entries(manifest.icons).map(([size, icon])=>{
-            const raw = String(icon);
-            return [
-                size,
-                getFilename(iconOutputPath(raw), raw)
-            ];
-        }))
-    };
-}
-function commands_commands(manifest) {
-    return manifest.commands && {
-        commands: manifest.commands
-    };
-}
-function permissions(manifest) {
-    return manifest.permissions && {
-        permissions: manifest.permissions
-    };
-}
-function optionsPage(manifest, manifestPath) {
-    return manifest.options_page && {
-        options_page: (()=>{
-            const raw = String(manifest.options_page);
-            return getFilename(manifestPageOutputTarget(raw, 'options/index.html', manifestPath), raw);
-        })()
-    };
-}
-function optionsUi(manifest, manifestPath) {
-    return manifest.options_ui && {
-        options_ui: {
-            ...manifest.options_ui,
-            ...manifest.options_ui.page && {
-                page: (()=>{
-                    const raw = String(manifest.options_ui.page);
-                    return getFilename(manifestPageOutputTarget(raw, 'options/index.html', manifestPath), raw);
-                })()
-            }
-        }
-    };
-}
-function sandbox(manifest) {
-    return manifest.sandbox && {
-        sandbox: {
-            ...manifest.sandbox,
-            ...manifest.sandbox.pages && {
-                pages: manifest.sandbox.pages.map((page, index)=>getFilename(`sandbox/page-${index}.html`, page))
-            }
-        }
-    };
-}
-function storage(manifest) {
-    return manifest.storage && {
-        storage: {
-            ...manifest.storage.managed_schema && {
-                managed_schema: getFilename('storage/managed_schema.json', manifest.storage.managed_schema)
-            }
-        }
-    };
-}
-const theme_getBasename = (filepath)=>__rspack_external_path.basename(filepath);
-const rewriteThemeImage = (value)=>getFilename(`theme/images/${theme_getBasename(value)}`, value);
-function theme(manifest) {
-    return manifest.theme && {
-        theme: {
-            ...manifest.theme,
-            ...manifest.theme.images && {
-                images: Object.fromEntries(Object.entries(manifest.theme.images).map(([key, value])=>[
-                        key,
-                        Array.isArray(value) ? value.map(rewriteThemeImage) : rewriteThemeImage(value)
-                    ]))
-            }
-        }
-    };
-}
-function userScripts(manifest) {
-    return manifest.user_scripts && {
-        user_scripts: {
-            ...manifest.user_scripts,
-            ...manifest.user_scripts.api_script && {
-                api_script: getFilename("user_scripts/api_script.js", manifest.user_scripts.api_script)
-            }
-        }
-    };
-}
-function normalizeOutputPath(originalPath) {
-    if (!originalPath) return originalPath;
-    const unix = originalPath.replace(/\\/g, '/');
-    if (/[*?\[\]{}]/.test(unix)) return unix;
-    if (/^\/public\//i.test(unix)) return unix.replace(/^\/public\//i, '');
-    if (/^(?:\.\/)?public\//i.test(unix)) return unix.replace(/^(?:\.\/)?public\//i, '');
-    if (/^\//.test(unix)) return unix.replace(/^\//, '');
-    return unix;
-}
-function webAccessibleResources(manifest) {
-    if (!manifest.web_accessible_resources || !manifest.web_accessible_resources.length) return;
-    const mapResource = (resource)=>getFilename(normalizeOutputPath(resource), resource);
-    const entries = manifest.web_accessible_resources.map((entry)=>{
-        if ('string' == typeof entry) return mapResource(entry);
-        if (!entry || !Array.isArray(entry.resources)) return;
-        return {
-            ...entry,
-            resources: entry.resources.map(mapResource)
-        };
-    }).filter((entry)=>void 0 !== entry);
-    if (0 === entries.length) return;
-    return {
-        web_accessible_resources: entries
-    };
-}
-function contentSecurityPolicy(manifest) {
-    return manifest.content_security_policy && {
-        content_security_policy: manifest.content_security_policy
-    };
-}
-const omnibox_getBasename = (filepath)=>__rspack_external_path.basename(filepath);
-function omnibox_omnibox(manifest) {
-    const omnibox = manifest.omnibox;
-    return omnibox && {
-        omnibox: {
-            ...omnibox,
-            ...omnibox.default_icon && {
-                default_icon: 'string' == typeof omnibox.default_icon ? getFilename(`icons/${omnibox_getBasename(omnibox.default_icon)}`, omnibox.default_icon) : Object.fromEntries(Object.entries(omnibox.default_icon).map(([size, icon])=>[
-                        size,
-                        getFilename(`icons/${omnibox_getBasename(icon)}`, icon)
-                    ]))
-            }
-        }
-    };
-}
-function manifestCommon(manifest, manifestPath) {
-    return {
-        ...backgroundPage(manifest),
-        ...chromeUrlOverrides(manifest, manifestPath),
-        ...content_scripts_contentScripts(manifest, manifestPath),
-        ...devtoolsPage(manifest, manifestPath),
-        ...icons_icons(manifest),
-        ...commands_commands(manifest),
-        ...permissions(manifest),
-        ...optionsPage(manifest, manifestPath),
-        ...optionsUi(manifest, manifestPath),
-        ...sandbox(manifest),
-        ...storage(manifest),
-        ...theme(manifest),
-        ...userScripts(manifest),
-        ...webAccessibleResources(manifest),
-        ...contentSecurityPolicy(manifest),
-        ...omnibox_omnibox(manifest)
-    };
-}
-function getManifestOverrides(manifestPath, manifest) {
-    const manifestContent = manifest || JSON.parse(stripBom(__rspack_external_fs.readFileSync(manifestPath, 'utf8')));
-    const omit = (obj, key)=>{
-        if (!obj) return {};
-        const { [key]: _ignored, ...rest } = obj;
-        return rest;
-    };
-    const pickBackground = (obj)=>{
-        const value = obj.background;
-        return value && 'object' == typeof value ? value : {};
-    };
-    const common = manifestCommon(manifestContent, manifestPath);
-    const mv2 = manifestV2(manifestContent);
-    const mv3 = manifestV3(manifestContent);
-    const backgroundMerged = {
-        ...manifestContent.background || {},
-        ...pickBackground(common),
-        ...pickBackground(mv2),
-        ...pickBackground(mv3)
-    };
-    const merged = {
-        ...manifestContent,
-        ...omit(common, 'background'),
-        ...omit(mv2, 'background'),
-        ...omit(mv3, 'background')
-    };
-    if (Object.keys(backgroundMerged).length) merged.background = backgroundMerged;
-    return JSON.stringify(merged, null, 2);
-}
-const cjsRequire = createRequire(import.meta.url);
-const INTERNAL_MANIFEST_SOURCE = '__extensionjs_manifest_source__';
-const INTERNAL_MANIFEST_CURRENT_SOURCE = '__extensionjs_manifest_current_source__';
-function readAssetSource(asset) {
-    if (!asset) return '';
-    const source = asset.source;
-    if ('string' == typeof source) return source;
-    if ('function' == typeof source) {
-        const out = source();
-        return 'string' == typeof out ? out : String(out || '');
-    }
-    if (source && 'function' == typeof source.source) {
-        const out = source.source();
-        return 'string' == typeof out ? out : String(out || '');
-    }
-    return '';
-}
-function setOriginalManifestContent(compilation, source) {
-    compilation[INTERNAL_MANIFEST_SOURCE] = source;
-}
-function getOriginalManifestContent(compilation) {
-    return compilation[INTERNAL_MANIFEST_SOURCE];
-}
-function setCurrentManifestContent(compilation, source) {
-    compilation[INTERNAL_MANIFEST_CURRENT_SOURCE] = source;
-}
-function getCurrentManifestContent(compilation) {
-    return compilation[INTERNAL_MANIFEST_CURRENT_SOURCE];
-}
-function getManifestContent(compilation, manifestPath) {
-    const currentManifest = getCurrentManifestContent(compilation);
-    if (currentManifest) return parseJsonSafe(currentManifest);
-    const getAsset = compilation.getAsset;
-    if ('function' == typeof getAsset) {
-        const manifestAsset = getAsset.call(compilation, 'manifest.json');
-        const manifest = readAssetSource(manifestAsset);
-        if (manifest) return parseJsonSafe(manifest);
-    }
-    const manifestAsset = compilation.assets?.['manifest.json'];
-    if (manifestAsset) {
-        const manifest = readAssetSource(manifestAsset);
-        if (manifest) return parseJsonSafe(manifest);
-    }
-    const originalManifest = getOriginalManifestContent(compilation);
-    if (originalManifest) return parseJsonSafe(originalManifest);
-    try {
-        const text = __rspack_external_fs.readFileSync(manifestPath, 'utf8');
-        return parseJsonSafe(text);
-    } catch  {
-        try {
-            const resolved = cjsRequire.resolve(manifestPath);
-            delete cjsRequire.cache[resolved];
-        } catch  {}
-        return 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_path.join(__rspack_import_meta_dirname__, '..', 'runtime', 'process-shim.cjs');
     try {
@@ -1738,7 +1058,7 @@ class EnvPlugin {
                 unmatchedEnvFiles = __rspack_external_fs.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 core_WebpackError(envNoMatchingFile(String(this.browser), String(mode), unmatchedEnvFiles, envFiles));
+                const warn = new WebpackError(envNoMatchingFile(String(this.browser), String(mode), unmatchedEnvFiles, envFiles));
                 warn.name = 'EnvNoMatchingFile';
                 compilation.warnings.push(warn);
             });
@@ -1786,7 +1106,7 @@ class EnvPlugin {
         compiler.hooks.thisCompilation.tap('manifest:update-manifest', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'env:module',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
             }, (assets)=>{
                 const files = Object.keys(compilation.assets || assets);
                 files.forEach((filename)=>{
@@ -2188,7 +1508,7 @@ class CompilationPlugin {
         setupCompilerDoneDiagnostics(compiler, this.port);
     }
 }
-const sass_cjsRequire = createRequire(import.meta.url);
+const cjsRequire = createRequire(import.meta.url);
 let userMessageDelivered = false;
 function isUsingSass(projectPath) {
     if (hasDependency(projectPath, 'sass')) {
@@ -2214,7 +1534,7 @@ function resolveSassImplementation(projectPath) {
         return mod;
     } catch  {}
     try {
-        let mod = sass_cjsRequire('sass');
+        let mod = cjsRequire('sass');
         if (mod && 'object' == typeof mod && 'default' in mod) mod = mod.default;
         return mod;
     } catch  {
@@ -3010,7 +2330,7 @@ class CssPlugin {
                 const key = `${issuer}|${req}`;
                 if (!warned.has(key) && compilation?.warnings) {
                     warned.add(key);
-                    const warning = new core_WebpackError(deadCssUrlRef(__rspack_external_path.relative(manifestDir, issuer) || issuer, raw));
+                    const warning = new WebpackError(deadCssUrlRef(__rspack_external_path.relative(manifestDir, issuer) || issuer, raw));
                     warning.file = __rspack_external_path.relative(manifestDir, issuer);
                     compilation.warnings.push(warning);
                 }
@@ -3499,7 +2819,7 @@ async function maybeUseSvelte(projectPath, mode) {
         alias: Object.keys(alias).length > 0 ? alias : void 0
     };
 }
-function parse_html_isUrl(src) {
+function isUrl(src) {
     try {
         new URL(src);
         return true;
@@ -3512,7 +2832,7 @@ function parseHtml(node, onResourceFound) {
     if ("script" === node.nodeName) {
         const src = node.attrs?.find((attr)=>'src' === attr.name)?.value;
         if (!src) return;
-        if (parse_html_isUrl(src)) return;
+        if (isUrl(src)) return;
         onResourceFound({
             filePath: src,
             childNode: node,
@@ -3526,14 +2846,14 @@ function parseHtml(node, onResourceFound) {
             const url = candidate.trim().split(/\s+/)[0];
             if (!url) continue;
             const { cleanPath } = cleanAssetUrl(url);
-            if (cleanPath && !parse_html_isUrl(cleanPath)) onResourceFound({
+            if (cleanPath && !isUrl(cleanPath)) onResourceFound({
                 filePath: cleanPath,
                 childNode: node,
                 assetType: 'staticHref'
             });
         }
         if (!href) return;
-        if (parse_html_isUrl(href)) return;
+        if (isUrl(href)) return;
         const nonStylesheetRelTokens = [
             'dns-prefetch',
             'icon',
@@ -3560,7 +2880,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 (parse_html_isUrl(src)) return;
+        if (isUrl(src)) return;
         onResourceFound({
             filePath: src,
             childNode: node,
@@ -3574,7 +2894,7 @@ function parseHtml(node, onResourceFound) {
                 const url = parts[0];
                 if (!url) continue;
                 const { cleanPath } = cleanAssetUrl(url);
-                if (cleanPath && !parse_html_isUrl(cleanPath)) onResourceFound({
+                if (cleanPath && !isUrl(cleanPath)) onResourceFound({
                     filePath: cleanPath,
                     childNode: node,
                     assetType: 'staticSrc'
@@ -3583,7 +2903,7 @@ function parseHtml(node, onResourceFound) {
         }
         if ('video' === node.nodeName) {
             const poster = node.attrs?.find((attr)=>'poster' === attr.name)?.value;
-            if (poster && !parse_html_isUrl(poster)) {
+            if (poster && !isUrl(poster)) {
                 const { cleanPath } = cleanAssetUrl(poster);
                 if (cleanPath) onResourceFound({
                     filePath: cleanPath,
@@ -3596,21 +2916,6 @@ function parseHtml(node, onResourceFound) {
     const { childNodes = [] } = node;
     for (const childNode of childNodes)if ('#comment' !== childNode.nodeName && '#text' !== childNode.nodeName) parseHtml(childNode, onResourceFound);
 }
-function createIssue(compiler, message, type = 'error') {
-    const ErrorCtor = compiler?.rspack?.WebpackError || Error;
-    const issue = new ErrorCtor(message);
-    issue.name = 'warning' === type ? 'ExtensionWarning' : 'ExtensionError';
-    return issue;
-}
-function reportToCompilation(compilation, compiler, message, type = 'error', file) {
-    const issue = createIssue(compiler, message, type);
-    if (file) issue.file = file;
-    const bucket = 'warning' === type ? 'warnings' : 'errors';
-    compilation[bucket] ||= [];
-    const already = compilation[bucket].some((e)=>(e?.file || '') === (issue.file || '') && String(e?.message) === String(issue.message));
-    if (already) return;
-    compilation[bucket].push(issue);
-}
 const cloneParsedHtmlAsset = (assets)=>({
         css: [
             ...assets.css || []
@@ -3903,7 +3208,7 @@ class JsFrameworksPlugin {
         }
         const platformModulePaths = new Set();
         try {
-            const browserManifest = external_browser_extension_manifest_fields_filterKeysForThisBrowser(manifest, this.browser);
+            const browserManifest = filterKeysForThisBrowser(manifest, this.browser);
             const background = browserManifest?.background;
             if (background?.type === 'module' && 'string' == typeof background?.service_worker) platformModulePaths.add(toResourceKey(__rspack_external_path.resolve(manifestDir, background.service_worker)));
             const htmlPages = {
@@ -4189,7 +3494,7 @@ class EmitManifest {
         compiler.hooks.thisCompilation.tap('manifest:emit-manifest', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'manifest:emit-manifest',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS
+                stage: Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS
             }, ()=>{
                 let jsonContent;
                 try {
@@ -4498,7 +3803,7 @@ class UpdateManifest {
         compiler.hooks.thisCompilation.tap('manifest:update-manifest', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'manifest:update-manifest',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE + 1
+                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE + 1
             }, ()=>{
                 if (compilation.errors.length > 0) return;
                 const manifest = getManifestContent(compilation, this.manifestPath);
@@ -4524,7 +3829,7 @@ class UpdateManifest {
                 const sanitized = sanitizeFatalManifestShapes(patchedManifest, __rspack_external_path.dirname(this.manifestPath));
                 patchedManifest = sanitized.manifest;
                 for (const fix of sanitized.fixes){
-                    const warn = new core_WebpackError(fatalManifestShapeFixed(fix.field, fix.detail));
+                    const warn = new WebpackError(fatalManifestShapeFixed(fix.field, fix.detail));
                     warn.name = 'ManifestFatalShapeWarning';
                     warn.file = 'manifest.json';
                     compilation.warnings.push(warn);
@@ -4610,11 +3915,11 @@ function warPatchedSummary(v3Groups, v3ResourcesTotal, v2Resources) {
     return `Web resources: WAR patched — v3Groups=${String(v3Groups)}, v3Resources=${String(v3ResourcesTotal)}, v2Resources=${String(v2Resources)}`;
 }
 function isPublicRootLike(possiblePath) {
-    const normalizedPath = unixify(possiblePath || '');
+    const normalizedPath = paths_unixify(possiblePath || '');
     return normalizedPath.startsWith('/') || /^(?:\.\/)?public\//i.test(normalizedPath) || /^\/public\//i.test(normalizedPath);
 }
 function toPublicOutput(possiblePath) {
-    const normalizedPath = unixify(possiblePath || '');
+    const normalizedPath = paths_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(/^\//, '');
@@ -4637,7 +3942,7 @@ function emitDirectoryAsAssets(compilation, absDir, baseDir) {
                 continue;
             }
             if (!entry.isFile()) continue;
-            const outName = unixify(__rspack_external_path.relative(baseDir, full));
+            const outName = paths_unixify(__rspack_external_path.relative(baseDir, full));
             if (!compilation.getAsset(outName)) compilation.emitAsset(outName, new core_sources.RawSource(__rspack_external_fs.readFileSync(full)));
             compilation.fileDependencies.add(full);
         }
@@ -4656,7 +3961,7 @@ function emitFileAsAsset(compilation, absPath) {
     }
     if (!compilation.getAsset(outName)) compilation.emitAsset(outName, new core_sources.RawSource(content));
     compilation.fileDependencies.add(absPath);
-    return unixify(outName);
+    return paths_unixify(outName);
 }
 function resolve_war_findSourceSibling(absOutputPath) {
     const candidatesByExt = {
@@ -4705,7 +4010,7 @@ function validateMatchesOrReport(compilation, matches, browser) {
     compilation.errors ||= [];
     for (const m of matches)if (!isValidChromeMatchPattern(m)) {
         const msg = warInvalidMatchPattern(m);
-        const err = new core_WebpackError(msg);
+        const err = new WebpackError(msg);
         err.file = 'manifest.json';
         err.name = 'WARInvalidMatchPattern';
         compilation.errors.push(err);
@@ -4773,7 +4078,7 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
                     publicRootHint: true,
                     relativeRef: res
                 });
-                const err = new core_WebpackError(msg);
+                const err = new WebpackError(msg);
                 err.file = 'manifest.json';
                 compilation.warnings.push(err);
             }
@@ -4797,7 +4102,7 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
                 relativeRef: res,
                 sourceSibling: sourceSibling ? __rspack_external_path.relative(manifestDir, sourceSibling) : void 0
             });
-            const warn = new core_WebpackError(msg);
+            const warn = new WebpackError(msg);
             warn.file = 'manifest.json';
             warn.name = 'WARRelativeAssetMissing';
             compilation.warnings.push(warn);
@@ -4805,11 +4110,11 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
         }
         if (__rspack_external_fs.statSync(abs).isDirectory()) {
             emitDirectoryAsAssets(compilation, abs, manifestDir);
-            const dirResource = unixify(res).replace(/\/+$/, '') + '/*';
+            const dirResource = paths_unixify(res).replace(/\/+$/, '') + '/*';
             pushResource(matches, dirResource, extra);
             return;
         }
-        const relOut = unixify(__rspack_external_path.relative(manifestDir, abs));
+        const relOut = paths_unixify(__rspack_external_path.relative(manifestDir, abs));
         if (!relOut.startsWith('..')) {
             if (!compilation.getAsset(relOut)) compilation.emitAsset(relOut, new core_sources.RawSource(__rspack_external_fs.readFileSync(abs)));
             compilation.fileDependencies.add(abs);
@@ -4823,7 +4128,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 core_WebpackError(msg);
+            const err = new WebpackError(msg);
             err.file = 'manifest.json';
             err.name = 'WARStringEntryInMv3';
             compilation.errors = compilation.errors || [];
@@ -5051,7 +4356,7 @@ class PatchWAR {
         compiler.hooks.thisCompilation.tap('manifest:patch-war', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'manifest:patch-war',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT
+                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT
             }, ()=>{
                 if (compilation.errors.length > 0) return;
                 const shared = getSharedFor(compilation);
@@ -5302,7 +4607,7 @@ class ApplyDevDefaults {
             if (!compilation?.hooks?.processAssets) return;
             compilation.hooks.processAssets.tap({
                 name: 'manifest:apply-dev-defaults',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 100
+                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT + 100
             }, ()=>{
                 if (compilation.errors.length > 0) return;
                 if (!this.manifestPath) {
@@ -5418,7 +4723,7 @@ class PersistManifestToDisk {
         compiler.hooks.thisCompilation.tap('manifest:persist-manifest:capture', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'manifest:persist-manifest:capture',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 1000
+                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT + 1000
             }, ()=>{
                 pendingHadErrors = compilation.errors.length > 0;
                 pendingOutputPath = compilation.outputOptions.path || compiler.options.output?.path;
@@ -5509,7 +4814,7 @@ class ManifestLegacyWarnings {
         compiler.hooks.thisCompilation.tap(ManifestLegacyWarnings.name, (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: ManifestLegacyWarnings.name,
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT
+                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT
             }, ()=>{
                 const asset = compilation.getAsset('manifest.json');
                 if (!asset) return;
@@ -5517,7 +4822,7 @@ class ManifestLegacyWarnings {
                 let count = 0;
                 legacy.forEach((needle)=>{
                     if (text.includes(needle)) {
-                        const warn = new core_WebpackError(legacyManifestPathWarning(needle));
+                        const warn = new WebpackError(legacyManifestPathWarning(needle));
                         warn.name = 'ManifestLegacyWarning';
                         warn.file = 'manifest.json';
                         compilation.warnings.push(warn);
@@ -5691,7 +4996,7 @@ class EmitHtmlFile {
             };
             if (processAssetsHook && 'function' == typeof processAssetsHook.tap) processAssetsHook.tap({
                 name: 'AddAssetsToCompilationPlugin',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
             }, ()=>runner());
             else runner();
         });
@@ -5788,7 +5093,7 @@ function warnIfPublicRootAssetMissing(compilation, htmlEntry, cleanPath) {
     const projectDir = __rspack_external_path.dirname(__rspack_external_path.dirname(htmlEntry));
     const publicCandidate = __rspack_external_path.join(projectDir, 'public', cleanPath.slice(1));
     if (__rspack_external_fs.existsSync(publicCandidate)) return;
-    const warn = new core_WebpackError(fileNotFound(htmlEntry, cleanPath));
+    const warn = new WebpackError(fileNotFound(htmlEntry, cleanPath));
     warn.name = 'HtmlPublicAssetMissing';
     warn.file = htmlEntry;
     const filtered = String(warn.message).split('\n').filter((line)=>!line.includes(String(cleanPath)));
@@ -6116,7 +5421,7 @@ class AddAssetsToCompilation {
             };
             if (processAssetsHook && 'function' == typeof processAssetsHook.tap) processAssetsHook.tap({
                 name: 'html:add-assets-to-compilation',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>runner());
             else runner();
         });
@@ -6169,29 +5474,31 @@ function normalizeHotValue(value) {
     if ('boolean' == typeof value) return String(value);
     return 'true';
 }
+const HMR_CLIENT_SPECIFIER = '@rspack/dev-server/client/index.js';
+const HMR_HOT_SPECIFIER = '@rspack/core/hot/dev-server';
 let _resolvedClientPath;
 let _resolvedHotPath;
 function resolveHmrClientPath() {
     if (!_resolvedClientPath) try {
-        _resolvedClientPath = dev_server_client_import_cjsRequire.resolve('@rspack/dev-server/client/index.js', {
+        _resolvedClientPath = dev_server_client_import_cjsRequire.resolve(HMR_CLIENT_SPECIFIER, {
             paths: [
                 __rspack_import_meta_dirname__
             ]
         });
     } catch  {
-        _resolvedClientPath = '@rspack/dev-server/client/index.js';
+        _resolvedClientPath = HMR_CLIENT_SPECIFIER;
     }
     return _resolvedClientPath;
 }
 function resolveHmrHotPath() {
     if (!_resolvedHotPath) try {
-        _resolvedHotPath = dev_server_client_import_cjsRequire.resolve('webpack/hot/dev-server', {
+        _resolvedHotPath = dev_server_client_import_cjsRequire.resolve(HMR_HOT_SPECIFIER, {
             paths: [
                 __rspack_import_meta_dirname__
             ]
         });
     } catch  {
-        _resolvedHotPath = 'webpack/hot/dev-server';
+        _resolvedHotPath = HMR_HOT_SPECIFIER;
     }
     return _resolvedHotPath;
 }
@@ -6320,7 +5627,7 @@ class UpdateHtmlFile {
             const hasProcessAssets = Boolean(compilation?.hooks?.processAssets?.tap);
             if (hasProcessAssets) compilation.hooks.processAssets.tap({
                 name: 'html:update-html-file',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
             }, ()=>run());
             else run();
         });
@@ -6339,7 +5646,7 @@ class AddToFileDependencies {
         compiler.hooks.thisCompilation.tap('html:add-to-file-dependencies', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'html:add-to-file-dependencies',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>{
                 if (compilation.errors?.length) return;
                 const allEntries = this.includeList || {};
@@ -6410,7 +5717,7 @@ class ThrowIfRecompileIsNeeded {
                 if (this.hasEntriesChanged(updatedCssEntries, css) || this.hasEntriesChanged(updatedJsEntries, js)) {
                     const projectRoot = __rspack_external_path.dirname(this.manifestPath);
                     const relToManifest = __rspack_external_path.relative(projectRoot, changedFile);
-                    const err = new core_WebpackError(serverRestartRequiredFromHtml(relToManifest, changedFile));
+                    const err = new WebpackError(serverRestartRequiredFromHtml(relToManifest, changedFile));
                     err.name = 'HtmlEntrypointChanged';
                     err.file = relToManifest;
                     compilation.errors.push(err);
@@ -6470,7 +5777,7 @@ function handleCantResolveError(includesList, error, compilation, manifestDir) {
                 const errorMsg = fileNotFound(resource, overrideNotFoundPath || wrongFilename, {
                     publicRootHint: isPublicRoot
                 });
-                const warn = new core_WebpackError(errorMsg);
+                const warn = new WebpackError(errorMsg);
                 warn.name = 'HtmlEntrypointMissing';
                 warn.file = __rspack_external_path.relative(manifestDir, resource);
                 return warn;
@@ -6493,7 +5800,7 @@ class HandleCommonErrors {
             const hasProcessAssets = Boolean(compilation?.hooks?.processAssets?.tap);
             if (hasProcessAssets) return void compilation.hooks.processAssets.tap({
                 name: 'html:handle-common-errors',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
             }, ()=>{
                 const errs = [
                     ...compilation.errors
@@ -6605,18 +5912,6 @@ class HtmlPlugin {
         }).apply(compiler);
     }
 }
-function utils_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 utils_reportToCompilation(compilation, compiler, message, type = 'error') {
-    const issue = utils_createIssue(compiler, message, type);
-    const bucket = 'warning' === type ? 'warnings' : 'errors';
-    compilation[bucket] ||= [];
-    compilation[bucket].push(issue);
-}
 function getScriptEntries(scriptPath) {
     const scriptEntries = Array.isArray(scriptPath) ? scriptPath || [] : scriptPath ? [
         scriptPath
@@ -6665,15 +5960,16 @@ function resolveMainWorldBridgeSourcePath(options) {
     const packageRoot = options?.packageRoot || findPackageRoot(lookupDir);
     return resolveExistingFile([
         path_0.resolve(lookupDir, 'main-world-bridge'),
-        packageRoot ? path_0.resolve(packageRoot, "plugin-web-extension/feature-scripts/steps/setup-reload-strategy/add-content-script-wrapper/main-world-bridge") : void 0,
+        packageRoot ? path_0.resolve(packageRoot, "plugin-web-extension/feature-scripts/steps/add-content-script-wrapper/main-world-bridge") : void 0,
         packageRoot ? path_0.resolve(packageRoot, 'dist', 'main-world-bridge') : void 0
     ]);
 }
-function getMainWorldBridgeScripts(manifestPath) {
+function getMainWorldBridgeScripts(manifestPath, browser = 'chrome') {
     const bridgeScripts = {};
     try {
         const raw = JSON.parse(stripBom(fs.readFileSync(manifestPath, 'utf-8')));
-        const contentScripts = Array.isArray(raw?.content_scripts) ? raw.content_scripts : [];
+        const resolved = manifest_utils_filterKeysForThisBrowser(raw, browser);
+        const contentScripts = Array.isArray(resolved?.content_scripts) ? resolved.content_scripts : [];
         const originalCount = contentScripts.length;
         const bridgeSource = resolveMainWorldBridgeSourcePath();
         if (!bridgeSource) return bridgeScripts;
@@ -6688,8 +5984,8 @@ function getMainWorldBridgeScripts(manifestPath) {
     return bridgeScripts;
 }
 class AddContentScriptWrapper {
-    static getBridgeScripts(manifestPath) {
-        return getMainWorldBridgeScripts(manifestPath);
+    static getBridgeScripts(manifestPath, browser = 'chrome') {
+        return getMainWorldBridgeScripts(manifestPath, browser);
     }
     manifestPath;
     browser;
@@ -6774,12 +6070,14 @@ function createSequentialEntryModule(feature, scriptImports) {
 class AddScripts {
     manifestPath;
     includeList;
+    browser;
     constructor(options){
         this.manifestPath = options.manifestPath;
         this.includeList = options.includeList || {};
+        this.browser = options.browser || 'chrome';
     }
     apply(compiler) {
-        const bridgeScripts = AddContentScriptWrapper.getBridgeScripts(this.manifestPath);
+        const bridgeScripts = AddContentScriptWrapper.getBridgeScripts(this.manifestPath, this.browser);
         const scriptFields = {
             ...this.includeList,
             ...bridgeScripts
@@ -6873,2340 +6171,10 @@ class AddScripts {
         };
     }
 }
-function TemplateFn(compilation, Template) {
-    return {
-        f: (args, body)=>{
-            if (!compilation) throw new TypeError('No compilation is found.');
-            if (compilation.runtimeTemplate) return compilation.runtimeTemplate.basicFunction(args, body);
-            return compilation.outputOptions.environment.arrowFunction ? `(${args}) => {\n${Template.indent(body)}\n}` : `function(${args}) {\n${Template.indent(body)}\n}`;
-        },
-        retF: (returnValue, args = '')=>{
-            if (!compilation) throw new TypeError('No compilation is found.');
-            if (compilation.runtimeTemplate) return compilation.runtimeTemplate.returningFunction(returnValue, args);
-            return compilation.outputOptions.environment.arrowFunction ? `(${args}) => (${returnValue})` : `function(${args}) { return ${returnValue}; }`;
-        }
-    };
-}
-const RuntimeGlobal = '__webpack_require__.webExtRt';
-const RuntimeGlobalIsBrowser = '__webpack_require__.webExtRtModern';
-function BrowserRuntimeModule(webpack, acceptWeak) {
-    const { RuntimeModule, Template } = webpack;
-    class BrowserRuntime extends RuntimeModule {
-        constructor(){
-            super('WebExtensionBrowserRuntime', RuntimeModule.STAGE_NORMAL);
-        }
-        generate() {
-            const { compilation } = this;
-            if (!compilation) return Template.asString('/* [webpack-target-webextension] BrowserRuntimeModule skipped because no compilation is found. */');
-            const optionalChaining = compilation.outputOptions.environment.optionalChaining;
-            const _let = compilation.outputOptions.environment.const ? 'let' : 'var';
-            return Template.asString([
-                `${_let} isChrome, runtime;`,
-                'try {',
-                Template.indent([
-                    `if (typeof globalThis === "object" && globalThis && typeof globalThis.browser !== "undefined" && ${optionalChaining ? 'typeof globalThis.browser.runtime?.getURL === "function"' : 'typeof globalThis.browser.runtime === "object" && typeof globalThis.browser.runtime.getURL === "function"'}) {`,
-                    Template.indent([
-                        'runtime = globalThis.browser;'
-                    ]),
-                    '}'
-                ]),
-                '} catch (_) {}',
-                'if (!runtime) {',
-                Template.indent([
-                    'try {',
-                    Template.indent([
-                        `if (typeof globalThis === "object" && globalThis && typeof globalThis.chrome !== "undefined" && ${optionalChaining ? 'typeof globalThis.chrome.runtime?.getURL === "function"' : 'typeof globalThis.chrome.runtime === "object" && typeof globalThis.chrome.runtime.getURL === "function"'}) {`,
-                        Template.indent([
-                            'isChrome = true;',
-                            'runtime = globalThis.chrome;'
-                        ]),
-                        '}'
-                    ]),
-                    '} catch (_) {}'
-                ]),
-                '}',
-                `${RuntimeGlobalIsBrowser} = !isChrome;`,
-                `${RuntimeGlobal} = runtime || { runtime: null };`,
-                acceptWeak ? 'if (!runtime && (typeof self !== "object" || !self.addEventListener)) {' : '',
-                acceptWeak ? Template.indent([
-                    `${RuntimeGlobal} = { runtime: { getURL: String } };`
-                ]) : '',
-                acceptWeak ? '}' : ''
-            ].filter(Boolean));
-        }
-    }
-    return new BrowserRuntime();
-}
-const DYNAMIC_IMPORT_LOADER = 'dynamicImportLoader';
-const DOM_LOADER = "scriptLoader";
-const WORKER_LOADER = 'workerLoader';
-const CLASSIC_LOADER = 'classicLoader';
-const MAIN_CLASSIC_LOADER = 'classicLoaderMainWorld';
-const FALLBACK_LOADER = 'fallbackLoader';
-function LoadScriptRuntimeModule(webpack, supportDynamicImport, classicLoaderEnabled, contentScriptsMeta) {
-    const { Template, RuntimeGlobals, RuntimeModule } = webpack;
-    class LoadScriptRuntime extends RuntimeModule {
-        supportDynamicImport;
-        classicLoaderEnabled;
-        contentScriptsMeta;
-        constructor(){
-            super("load script", RuntimeModule.STAGE_BASIC);
-            this.supportDynamicImport = Boolean(supportDynamicImport);
-            this.classicLoaderEnabled = Boolean(classicLoaderEnabled);
-            this.contentScriptsMeta = contentScriptsMeta || {};
-        }
-        generate() {
-            const { compilation } = this;
-            if (!compilation) return Template.asString('/* [webpack-target-webextension] ChunkLoaderFallbackRuntimeModule skipped because no compilation is found. */');
-            const { f } = TemplateFn(compilation, Template);
-            const _const = compilation.outputOptions.environment.const ? 'const' : 'var';
-            const _let = compilation.outputOptions.environment.const ? 'let' : 'var';
-            const chunkName = (this.chunk && this.chunk.name ? this.chunk.name : '') || (compilation && compilation.chunk && compilation.chunk.name ? compilation.chunk.name : '');
-            const bundleId = chunkName ? `${chunkName}.js` : '';
-            const world = bundleId && this.contentScriptsMeta[bundleId] ? this.contentScriptsMeta[bundleId].world : void 0;
-            const isMainWorld = 'main' === world;
-            const HasExtensionRuntime = `${_const} hasExtensionRuntime = (function(){ try {return ((typeof globalThis === "object" && globalThis && globalThis.browser && globalThis.browser.runtime && typeof globalThis.browser.runtime.sendMessage === "function") || (typeof globalThis === "object" && globalThis && globalThis.chrome && globalThis.chrome.runtime && typeof globalThis.chrome.runtime.sendMessage === "function"));} catch (e) { return false; } })();`;
-            const DynamicImportLoader = `${_const} ${DYNAMIC_IMPORT_LOADER} = ` + f('url, done, key, chunkId', `import(url).then(${f('', [
-                'if (isNotIframe) return done();',
-                'try {',
-                Template.indent([
-                    "// It's a Chrome bug, if the import() is called in a sandboxed iframe, it _fails_ the script loading but _resolve_ the Promise.",
-                    `// we call ${RuntimeGlobals.ensureChunkHandlers}.j(chunkId) to check if it is loaded.`,
-                    '// if it is, this is a no-op. if it is not, it will throw a TypeError because this function requires 2 parameters.',
-                    '// This call will not trigger the chunk loading because it is already loading.',
-                    '// see https://github.com/awesome-webextension/webpack-target-webextension/issues/41',
-                    `chunkId !== undefined && ${RuntimeGlobals.ensureChunkHandlers}.j(chunkId);`,
-                    'done();'
-                ]),
-                '}',
-                'catch (_) {',
-                Template.indent([
-                    'if (!bug816121warned) {',
-                    Template.indent([
-                        'console.warn("Chrome bug https://crbug.com/816121 hit.");',
-                        'bug816121warned = true;'
-                    ]),
-                    '}',
-                    `return ${FALLBACK_LOADER}(url, done, key, chunkId);`
-                ]),
-                '}'
-            ])}, ${f('e', [
-                'console.warn("Dynamic import loader failed. Using fallback loader (see https://github.com/awesome-webextension/webpack-target-webextension#content-script).", e);',
-                `${FALLBACK_LOADER}(url, done, key, chunkId);`
-            ])});`);
-            const DOMLoader = `${_const} ${DOM_LOADER} = ` + f('url, done', [
-                `${_const} script = document.createElement('script');`,
-                "script.src = url;",
-                "script.onload = done;",
-                "script.onerror = done;",
-                "document.body.appendChild(script);"
-            ]);
-            const WorkerLoader = `${_const} ${WORKER_LOADER} = ` + f('url, done', [
-                'try {',
-                Template.indent([
-                    'importScripts(url);',
-                    'done();'
-                ]),
-                '} catch (e) {',
-                Template.indent([
-                    'done(e);'
-                ]),
-                '}'
-            ]);
-            const ClassicLoader = `${_const} ${CLASSIC_LOADER} = ` + f('url, done', Template.asString([
-                `${_const} msg = { type: "WTW_INJECT", file: url };`,
-                `${_const} onError = ${f('e', 'done(Object.assign(e, { type: "missing" }))')};`,
-                'try {',
-                `if (${RuntimeGlobalIsBrowser}) {`,
-                Template.indent([
-                    `${RuntimeGlobal}.runtime.sendMessage(msg).then(done, onError);`
-                ]),
-                '} else {',
-                Template.indent([
-                    `${RuntimeGlobal}.runtime.sendMessage(msg, ${f('', [
-                        `${_const} error = ${RuntimeGlobal}.runtime.lastError;`,
-                        'if (error) onError(error);',
-                        'else done();'
-                    ])});`
-                ]),
-                '}',
-                '} catch (e) { onError(e); }'
-            ])) + ';';
-            const ClassicLoaderDisabled = `${_const} ${CLASSIC_LOADER} = ` + f('', [
-                "throw new Error(\"[webpack-target-webextension] Failed to load async chunk in the content script. No script loader is found. You can either\\n - Set output.environment.dynamicImport to true if your environment supports native ES Module\\n - Specify the background entry to enable the fallback loader\\n - Set module.parser.javascript.dynamicImportMode to 'eager' to inline all async chunks.\");"
-            ]);
-            return Template.asString([
-                this.supportDynamicImport ? `${_let} bug816121warned, isNotIframe;` : '',
-                this.supportDynamicImport ? Template.asString([
-                    'try {',
-                    Template.indent([
-                        'isNotIframe = typeof window === "object" ? window.top === window : true;'
-                    ]),
-                    '} catch(e) {',
-                    Template.indent([
-                        'isNotIframe = false /* CORS error */;'
-                    ]),
-                    '}'
-                ]) : '',
-                HasExtensionRuntime,
-                this.classicLoaderEnabled ? ClassicLoader : ClassicLoaderDisabled,
-                this.supportDynamicImport ? DynamicImportLoader : '',
-                DOMLoader,
-                WorkerLoader,
-                `${_const} isWorker = typeof importScripts === 'function'`,
-                "if (typeof location === 'object' && location.protocol.includes('-extension:')) {",
-                Template.indent([
-                    `${RuntimeGlobals.loadScript} = isWorker ? ${WORKER_LOADER} : ${DOM_LOADER};`
-                ]),
-                "} else {",
-                Template.indent(isMainWorld ? Template.asString([
-                    `${_const} __extjsMark = "__extjs__";`,
-                    `${_const} __extjsReqType = "EXTJS_WTW_LOAD";`,
-                    `${_const} __extjsResType = "EXTJS_WTW_LOADED";`,
-                    `${_const} ${MAIN_CLASSIC_LOADER} = ` + f('url, done', [
-                        `${_const} requestId = String(Date.now()) + "-" + Math.random().toString(16).slice(2);`,
-                        `${_const} onMessage = ${f('event', [
-                            'try {',
-                            Template.indent([
-                                'if (!event || event.source !== window) return;',
-                                `${_const} data = event.data || null;`,
-                                "if (!data || data[__extjsMark] !== true) return;",
-                                "if (data.type !== __extjsResType || data.requestId !== requestId) return;",
-                                'window.removeEventListener("message", onMessage);',
-                                'if (data.ok) done();',
-                                'else done(Object.assign(new Error(data.error || "Bridge failed"), { type: "missing" }));'
-                            ]),
-                            '} catch (e) {',
-                            Template.indent([
-                                'window.removeEventListener("message", onMessage);',
-                                'done(Object.assign(e, { type: "missing" }));'
-                            ]),
-                            '}'
-                        ])};`,
-                        'window.addEventListener("message", onMessage);',
-                        'try {',
-                        Template.indent([
-                            'window.postMessage({ [__extjsMark]: true, type: __extjsReqType, requestId: requestId, url: url }, "*");'
-                        ]),
-                        '} catch (e) {',
-                        Template.indent([
-                            'window.removeEventListener("message", onMessage);',
-                            'done(Object.assign(e, { type: "missing" }));'
-                        ]),
-                        '}',
-                        'setTimeout(function(){ try { window.removeEventListener("message", onMessage); } catch(_){} done(Object.assign(new Error("Bridge timeout"), { type: "missing" })); }, 5000);'
-                    ]) + ';',
-                    `if (!isWorker) ${RuntimeGlobals.loadScript} = ${MAIN_CLASSIC_LOADER};`
-                ]) : Template.asString([
-                    `if (!isWorker && hasExtensionRuntime) ${RuntimeGlobals.loadScript} = ${CLASSIC_LOADER};`,
-                    `else if (!isWorker) ${RuntimeGlobals.loadScript} = ${DOM_LOADER};`
-                ])),
-                "}",
-                this.supportDynamicImport ? `${_const} ${FALLBACK_LOADER} = ${RuntimeGlobals.loadScript};` : '',
-                this.supportDynamicImport ? `${RuntimeGlobals.loadScript} = ${DYNAMIC_IMPORT_LOADER};` : ''
-            ].filter(Boolean));
-        }
-    }
-    return new LoadScriptRuntime();
-}
-function 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;
-                    const e = new WebpackError(`[webpack-extension-target] Output file name ${JSON.stringify(name)} starts with "_" which is prohibited.`);
-                    e.stack = '';
-                    compilation.errors.push(e);
-                }
-            });
-        });
-    }
-}
-function createEagerlyLoadChunksRuntimeModule(webpack) {
-    const { RuntimeGlobals, RuntimeModule, Template } = webpack;
-    return class extends RuntimeModule {
-        chunkIds;
-        constructor(chunkIds){
-            super('eagerly load chunks', RuntimeModule.STAGE_NORMAL);
-            this.chunkIds = chunkIds;
-        }
-        generate() {
-            const { compilation } = this;
-            if (!compilation) return Template.asString('/* [webpack-target-webextension] EagerlyLoadChunksRuntimeModule skipped because no compilation is found. */');
-            const _const = compilation.outputOptions.environment.const ? 'const' : 'var';
-            return Template.asString([
-                `${_const} __extjsChunkIds = ${JSON.stringify(this.chunkIds)};`,
-                `${_const} __extjsLoad = ${RuntimeGlobals.ensureChunkHandlers};`,
-                `for (${_const} __extjsId of __extjsChunkIds) __extjsLoad(__extjsId);`
-            ]);
-        }
-    };
-}
-class WebExtensionServiceWorkerEntryPlugin {
-    options;
-    backgroundOutputEmitted;
-    constructor(options, backgroundOutputEmitted){
-        this.options = options;
-        this.backgroundOutputEmitted = backgroundOutputEmitted;
-    }
-    apply(compiler) {
-        const { javascript, sources } = compiler.webpack;
-        const entry = this.options.serviceWorkerEntry;
-        if (void 0 === entry) return;
-        if (!(compiler.options.output.module || compiler.options.experiments.outputModule)) {
-            const hook = compiler.hooks.entryOption;
-            hook.tap(WebExtensionServiceWorkerEntryPlugin.name, (_context, entries)=>{
-                if ('function' == typeof entries) {
-                    if (this.options.noDynamicEntryWarning) return;
-                    console.warn(`[webpack-extension-target] Dynamic entry points not supported yet.
-You must manually set the chuck loading of entry point ${entry} to "import-scripts".
-
-See https://webpack.js.org/configuration/entry-context/#entry-descriptor
-
-Set background.noDynamicEntryWarning to true to disable this warning.
-`);
-                }
-                const selectedEntry = entries?.[entry];
-                if (!selectedEntry) throw new Error(`[webpack-extension-target] There is no entry called ${entry}.`);
-                selectedEntry.chunkLoading = "import-scripts";
-            });
-        }
-        if (false !== this.options.eagerChunkLoading) compiler.hooks.compilation.tap(WebExtensionServiceWorkerEntryPlugin.name, (compilation)=>{
-            compilation.hooks.afterOptimizeChunkIds?.tap(WebExtensionServiceWorkerEntryPlugin.name, ()=>{
-                const entryPoint = compilation.entrypoints.get(entry);
-                if (!entryPoint) return;
-                const entryChunk = entryPoint.getEntrypointChunk();
-                const reachableChunks = getReachableChunks(entryPoint, new Set(entryPoint.chunks));
-                const reachableChunkIds = new Set([
-                    ...reachableChunks
-                ].map((x)=>x.id));
-                for (const id of getInitialChunkIds(entryChunk, compilation.chunkGraph, chunkHasJs))reachableChunkIds.delete(id);
-                if (reachableChunkIds.size) {
-                    const EagerlyLoadChunksRuntimeModule = createEagerlyLoadChunksRuntimeModule(compiler.webpack);
-                    compilation.hooks.additionalTreeRuntimeRequirements.tap(EagerlyLoadChunksRuntimeModule.name, (chunk, set)=>{
-                        if (chunk.id !== entryChunk.id) return;
-                        set.add(compiler.webpack.RuntimeGlobals.ensureChunkHandlers);
-                        compilation.addRuntimeModule(entryChunk, new EagerlyLoadChunksRuntimeModule([
-                            ...reachableChunkIds
-                        ]));
-                    });
-                }
-            });
-        });
-        if (false !== this.options.tryCatchWrapper && 'module' !== compiler.options.output.chunkFormat && !this.backgroundOutputEmitted) compiler.hooks.compilation.tap(WebExtensionServiceWorkerEntryPlugin.name, (compilation)=>{
-            const hooks = javascript.JavascriptModulesPlugin.getCompilationHooks(compilation);
-            if (hooks.renderContent) hooks.renderContent.tap(WebExtensionServiceWorkerEntryPlugin.name, (source, context)=>{
-                const entryPoint = compilation.entrypoints.get(entry);
-                const entryChunk = entryPoint?.getEntrypointChunk();
-                if (entryChunk !== context.chunk) return source;
-                return new sources.ConcatSource('/******/ try { // If the initial code of the serviceWorkerEntry throws, the console cannot be opened.\n', source, '\n/******/ } catch (e) {\n/******/ \tPromise.reject(e);\n/******/ }');
-            });
-        });
-    }
-}
-function getInitialChunkIds(chunk, chunkGraph, filterFn) {
-    const initialChunkIds = new Set(chunk.ids);
-    for (const c of chunk.getAllInitialChunks())if (!(c === chunk || filterFn(c, chunkGraph)) && c.ids) for (const id of c.ids)initialChunkIds.add(id);
-    return initialChunkIds;
-}
-function chunkHasJs(chunk, chunkGraph) {
-    if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return true;
-    return !!chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript");
-}
-function getReachableChunks(chunkGroup, reachableChunks = new Set(), visitedChunkGroups = new Set()) {
-    for (const x of chunkGroup.getChildren())if (!visitedChunkGroups.has(x)) {
-        visitedChunkGroups.add(x);
-        x.chunks.forEach((c)=>reachableChunks.add(c));
-        getReachableChunks(x, reachableChunks, visitedChunkGroups);
-    }
-    return reachableChunks;
-}
-class WebExtensionContentScriptEntryPlugin {
-    options;
-    constructor(options){
-        this.options = options;
-    }
-    apply(compiler) {
-        const { WebpackError, sources, Template } = compiler.webpack;
-        const { experimental_output } = this.options;
-        if (!experimental_output) return;
-        {
-            const sw = this.options.background?.serviceWorkerEntry;
-            if (sw && sw in experimental_output && 'function' == typeof experimental_output[sw]) throw new Error(`[webpack-extension-target] options.experimental_output[${JSON.stringify(sw)}] cannot be a function because it is a service worker entry. Use { file, touch(manifest, file) { manifest.background.service_worker = file; } } instead.`);
-        }
-        compiler.hooks.thisCompilation.tap(WebExtensionContentScriptEntryPlugin.name, (compilation)=>{
-            compilation.hooks.processAssets.tap({
-                name: WebExtensionContentScriptEntryPlugin.name,
-                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_DERIVED
-            }, (assets)=>{
-                let manifest;
-                const serviceWorkerEntry = this.options.background?.serviceWorkerEntry;
-                if (serviceWorkerEntry && !(serviceWorkerEntry in experimental_output) && (getInitialFiles(compilation, serviceWorkerEntry)?.length || 0) > 1) {
-                    const e = new WebpackError(`[webpack-extension-target] Entry ${JSON.stringify(serviceWorkerEntry)} is not specified in options.experimental_output.`);
-                    e.stack = '';
-                    compilation.warnings.push(e);
-                }
-                for(const entry in experimental_output){
-                    const isBackgroundEntry = entry === serviceWorkerEntry;
-                    const entryOption = experimental_output[entry];
-                    const initialFiles = getInitialFiles(compilation, entry);
-                    if (!initialFiles || 0 === initialFiles.length) {
-                        const name = JSON.stringify(entry);
-                        const e = new WebpackError(initialFiles ? `[webpack-extension-target] Entry ${name} does not emit any initial file (specified in options.experimental_output).` : `[webpack-extension-target] Entry ${name} does not exist (specified in options.experimental_output).`);
-                        e.stack = '';
-                        compilation.errors.push(e);
-                        continue;
-                    }
-                    if (false === entryOption) {
-                        if (initialFiles.length > 1) {
-                            const name = JSON.stringify(entry);
-                            const e = new WebpackError(`[webpack-extension-target] Entry ${name} emits more than one initial file which is prohibited (specified in options.experimental_output).`);
-                            e.stack = '';
-                            compilation.errors.push(e);
-                        }
-                        continue;
-                    }
-                    const emitFile = (entryOptionFile, files)=>{
-                        if (entryOptionFile in assets) {
-                            const e = new WebpackError(`[webpack-extension-target] Cannot override an existing file ${JSON.stringify(entryOptionFile)} (specified by options.experimental_output[${JSON.stringify(entry)}]).`);
-                            e.stack = '';
-                            compilation.errors.push(e);
-                            return;
-                        }
-                        let code;
-                        if (isBackgroundEntry) {
-                            const asyncAndSyncFiles = getInitialAndAsyncFiles(compilation, entry);
-                            code = 'module' === compilation.outputOptions.chunkFormat ? asyncAndSyncFiles.map((file)=>`import ${JSON.stringify('./' + file)};`) : [
-                                'try {',
-                                Template.indent('importScripts(' + asyncAndSyncFiles.map((file)=>JSON.stringify(file)).join(', ') + ');'),
-                                '} catch (e) {',
-                                Template.indent('Promise.reject(e);'),
-                                '}'
-                            ];
-                        } else code = [
-                            ';(() => {',
-                            Template.indent([
-                                'const getURL = typeof globalThis === "object" && globalThis && typeof globalThis.browser === "object" ? globalThis.browser.runtime.getURL : globalThis.chrome.runtime.getURL;',
-                                `${JSON.stringify(files)}.forEach(file => import(getURL(file)));`
-                            ]),
-                            '})();',
-                            'null;'
-                        ];
-                        const source = new compiler.webpack.sources.RawSource(Template.asString(code));
-                        compilation.emitAsset(entryOptionFile, source);
-                    };
-                    if ('string' == typeof entryOption) {
-                        emitFile(entryOption, initialFiles);
-                        continue;
-                    }
-                    if (!manifest) {
-                        const manifestAsset = assets['manifest.json'];
-                        const name = JSON.stringify(entry);
-                        if (!manifestAsset) {
-                            const e = new WebpackError(`[webpack-extension-target] A manifest.json is required (required by options.experimental_output[${name}]). You can emit this file by using CopyPlugin or any other plugins.`);
-                            e.stack = '';
-                            compilation.errors.push(e);
-                            continue;
-                        }
-                        try {
-                            const source = manifestAsset.source();
-                            manifest = 'string' == typeof source ? JSON.parse(source) : JSON.parse(source.toString('utf-8'));
-                        } catch  {
-                            const e = new WebpackError(`[webpack-extension-target] Failed to parse manifest.json (required by options.experimental_output[${name}]).`);
-                            e.stack = '';
-                            e.file = 'manifest.json';
-                            compilation.errors.push(e);
-                            continue;
-                        }
-                    }
-                    if ('function' == typeof entryOption) entryOption(manifest, initialFiles);
-                    else if ('object' == typeof entryOption) {
-                        emitFile(entryOption.file, initialFiles);
-                        entryOption.touch(manifest, entryOption.file);
-                    }
-                }
-                if (manifest) compilation.updateAsset('manifest.json', new sources.RawSource(JSON.stringify(manifest, void 0, 4)));
-            });
-        });
-    }
-}
-function getInitialFiles(compilation, entry) {
-    const entryPoint = compilation.entrypoints.get(entry);
-    if (!entryPoint) return;
-    const files = new Set();
-    const runtimeChunk = entryPoint.getRuntimeChunk();
-    if (runtimeChunk) runtimeChunk.files.forEach((file)=>{
-        if (!isJSFile(file)) return;
-        const asset = compilation.getAsset(file);
-        if (!asset) return;
-        if (!asset.info.hotModuleReplacement) files.add(file);
-    });
-    entryPoint.getFiles().forEach((file)=>{
-        if (!isJSFile(file)) return;
-        const asset = compilation.getAsset(file);
-        if (!asset) return;
-        if (!asset.info.hotModuleReplacement) files.add(file);
-    });
-    return [
-        ...files
-    ];
-}
-function getInitialAndAsyncFiles(compilation, entry) {
-    const entryPoint = compilation.entrypoints.get(entry);
-    if (!entryPoint) return [];
-    const files = new Set();
-    const visitedChunk = new Set();
-    function visit(chunk) {
-        const chunkId = 'rspack' in compilation.compiler ? chunk.id && chunk.hash ? chunk.id + chunk.hash : Array.from(chunk.files).join('') : chunk;
-        if (visitedChunk.has(chunkId)) return;
-        visitedChunk.add(chunkId);
-        chunk.files.forEach((file)=>{
-            if (!isJSFile(file)) return;
-            const asset = compilation.getAsset(file);
-            if (!asset) return;
-            if (!asset.info.hotModuleReplacement) files.add(file);
-        });
-        for (const child of chunk.getAllAsyncChunks())visit(child);
-    }
-    entryPoint.chunks.forEach(visit);
-    const allFiles = [
-        ...files
-    ].filter((file)=>isJSFile(file) && compilation.getAsset(file));
-    return allFiles;
-}
-function isJSFile(file) {
-    return file.endsWith('.js') || file.endsWith('.mjs');
-}
-class DevServerConfigPlugin {
-    apply(compiler) {
-        if (!compiler.options.devServer) compiler.options.devServer = {};
-        const devServer = compiler.options.devServer;
-        setDefault(devServer, 'devMiddleware', {});
-        setDefault(devServer.devMiddleware, 'writeToDisk', true);
-        if (void 0 === devServer.hot) devServer.hot = 'only';
-        if (!devServer.hot) return;
-        setDefault(devServer, 'host', '127.0.0.1');
-        setDefault(devServer, 'client', {
-            overlay: false,
-            progress: false,
-            webSocketURL: {
-                protocol: 'ws'
-            }
-        });
-        setDefault(devServer.client, 'overlay', false);
-        setDefault(devServer.client, 'progress', false);
-        setDefault(devServer.client, 'webSocketURL', {
-            protocol: 'ws'
-        });
-        setDefault(devServer.client.webSocketURL, 'protocol', 'ws');
-        const connectableHost = resolveClientHost(process.env.EXTENSION_DEV_SERVER_CONNECTABLE_HOST, devServer.host);
-        if (connectableHost) setDefault(devServer.client.webSocketURL, 'hostname', connectableHost);
-        if (devServer.port) setDefault(devServer.client.webSocketURL, 'port', devServer.port);
-        setDefault(devServer, 'allowedHosts', 'all');
-        setDefault(devServer, 'headers', {
-            'Access-Control-Allow-Origin': '*'
-        });
-        setDefault(devServer, 'static', {
-            watch: {
-                ignored: /\bnode_modules\b/
-            }
-        });
-        setDefault(devServer.static, 'watch', {
-            ignored: /\bnode_modules\b/
-        });
-        isObject(devServer.static) && 'watch' in devServer.static && isObject(devServer.static.watch) && setDefault(devServer.static.watch, 'ignored', /\bnode_modules\b/);
-    }
-}
-function setDefault(obj, key, val) {
-    if (isObject(obj) && void 0 === obj[key]) obj[key] = val;
-}
-const HMRDevServer_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 HMRDevServer_WILDCARD_HOSTS.has(bind) ? '127.0.0.1' : bind;
-}
-function isObject(x) {
-    return 'object' == typeof x && null !== x;
-}
-class WebExtensionPlugin {
-    options;
-    constructor(options = {}){
-        const { background } = options;
-        if (background) {
-            const { serviceWorkerEntry, pageEntry } = background;
-            if ('entry' in background || 'manifest' in background) throw new Error('[webpack-extension-target] background.entry and background.manifest has been removed. Use background.pageEntry and/or background.serviceWorkerEntry instead.');
-            if (serviceWorkerEntry && serviceWorkerEntry === pageEntry) throw new Error(`[webpack-extension-target] background.serviceWorkerEntry must not be the same as background.pageEntry. Service Worker entry only supports importScript, but importScript does not exist in background page (mv2) or limited event page (mv3).
-    A possible fix is to create two new files to be the service worker entry and the page entry, then those two files imports the background entry.`);
-        }
-        this.options = options;
-    }
-    apply(compiler) {
-        const { background, experimental_output } = this.options;
-        if (background?.serviceWorkerEntry) {
-            const serviceWorkerEntry = this.options.background?.serviceWorkerEntry;
-            const output = serviceWorkerEntry ? this.options.experimental_output?.[serviceWorkerEntry] : false;
-            new WebExtensionServiceWorkerEntryPlugin(background, !!output).apply(compiler);
-        }
-        if (experimental_output) new WebExtensionContentScriptEntryPlugin(this.options).apply(compiler);
-        if (false !== this.options.hmrConfig) new DevServerConfigPlugin().apply(compiler);
-        new WebExtensionChuckLoaderRuntimePlugin(this.options).apply(compiler);
-        new NoDangerNamePlugin().apply(compiler);
-        compiler.hooks.environment.tap(WebExtensionPlugin.name, ()=>{
-            const { output } = compiler.options;
-            if (false !== output.environment.dynamicImport) output.environment.dynamicImport = true;
-            if (void 0 !== output.hotUpdateChunkFilename) output.hotUpdateChunkFilename = 'hot/[id].[fullhash].js';
-            if (void 0 !== output.hotUpdateMainFilename) output.hotUpdateMainFilename = 'hot/[runtime].[fullhash].json';
-        });
-        compiler.hooks.compilation.tap(WebExtensionPlugin.name, (compilation)=>{
-            compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobal).tap(WebExtensionPlugin.name, (chunk)=>{
-                compilation.addRuntimeModule(chunk, BrowserRuntimeModule(compiler.webpack, !!this.options.weakRuntimeCheck));
-                return true;
-            });
-        });
-    }
-}
-const webpack_target_webextension_fork = WebExtensionPlugin;
-function manifest_filterKeysForThisBrowser(manifest, browser) {
-    return filterKeysForThisBrowser(manifest, browser);
-}
-class SetupBackgroundEntry {
-    manifestPath;
-    browser;
-    constructor(options){
-        this.manifestPath = options.manifestPath;
-        this.browser = options.browser || 'chrome';
-    }
-    getMissingBackgroundError(bgFile) {
-        if (!__rspack_external_fs.existsSync(bgFile) && this.manifestPath) {
-            const manifest = JSON.parse(stripBom(__rspack_external_fs.readFileSync(this.manifestPath, 'utf8')));
-            const patched = manifest_filterKeysForThisBrowser(manifest, this.browser);
-            const fieldKey = 3 === patched.manifest_version ? 'background/service_worker' : "background/scripts";
-            return backgroundIsRequiredMessageOnly(fieldKey);
-        }
-    }
-    addDefaultEntry(compiler, name, defaultScript) {
-        compiler.options.entry = {
-            ...compiler.options.entry,
-            [name]: {
-                import: [
-                    defaultScript
-                ]
-            }
-        };
-    }
-    apply(compiler) {
-        const manifest = JSON.parse(stripBom(__rspack_external_fs.readFileSync(this.manifestPath, 'utf-8')));
-        const browser = this.browser;
-        const isGecko = constants_isGeckoBasedBrowser(String(browser));
-        const minimumBgScript = resolveDevelopDistFile(isGecko ? 'minimum-firefox-file' : 'minimum-chromium-file');
-        const dirname = __rspack_external_path.dirname(this.manifestPath);
-        const filteredManifest = manifest_filterKeysForThisBrowser(manifest, browser) || manifest;
-        const manifestBg = filteredManifest?.background ?? manifest.background;
-        const manifestVersion = filteredManifest?.manifest_version ?? manifest.manifest_version;
-        function hookError(maybeError) {
-            compiler.hooks.thisCompilation.tap('run-chromium:setup-background-entry', (compilation)=>{
-                utils_reportToCompilation(compilation, compiler, maybeError, 'error');
-            });
-        }
-        if (isGecko) {
-            const bgScripts = manifestBg?.scripts;
-            if (bgScripts && bgScripts.length > 0) {
-                const bgScriptPath = __rspack_external_path.join(dirname, bgScripts[0]);
-                const maybeError = this.getMissingBackgroundError(bgScriptPath);
-                if (maybeError) hookError(maybeError);
-            } else this.addDefaultEntry(compiler, "background/script", minimumBgScript);
-            return;
-        }
-        if (2 === manifestVersion) {
-            const bgScripts = manifestBg?.scripts;
-            if (bgScripts && bgScripts.length > 0) {
-                const bgScriptPath = __rspack_external_path.join(dirname, bgScripts[0]);
-                const maybeError = this.getMissingBackgroundError(bgScriptPath);
-                if (maybeError) hookError(maybeError);
-            } else this.addDefaultEntry(compiler, "background/script", minimumBgScript);
-        } else {
-            const serviceWorker = manifestBg?.service_worker;
-            if (serviceWorker) {
-                const swPath = __rspack_external_path.join(dirname, serviceWorker);
-                const maybeError = this.getMissingBackgroundError(swPath);
-                if (maybeError) hookError(maybeError);
-                const existingEntry = compiler.options.entry && 'background/service_worker' in compiler.options.entry ? compiler.options.entry['background/service_worker'] : void 0;
-                if (!existingEntry && __rspack_external_fs.existsSync(swPath)) this.addDefaultEntry(compiler, 'background/service_worker', swPath);
-            } else this.addDefaultEntry(compiler, 'background/service_worker', minimumBgScript);
-        }
-    }
-}
-class SetupReloadStrategy {
-    manifestPath;
-    browser;
-    constructor(options){
-        this.manifestPath = options.manifestPath;
-        this.browser = options.browser || 'chrome';
-    }
-    getEntryName(manifest) {
-        if (manifest.background) {
-            if (constants_isGeckoBasedBrowser(String(this.browser))) return {
-                pageEntry: "background/script",
-                tryCatchWrapper: true,
-                eagerChunkLoading: false
-            };
-            if (3 === manifest.manifest_version) return {
-                serviceWorkerEntry: 'background/service_worker',
-                tryCatchWrapper: true,
-                eagerChunkLoading: false
-            };
-            if (2 === manifest.manifest_version) return {
-                pageEntry: "background/script",
-                tryCatchWrapper: true,
-                eagerChunkLoading: false
-            };
-        }
-        return {
-            pageEntry: 'background',
-            tryCatchWrapper: true,
-            eagerChunkLoading: false
-        };
-    }
-    apply(compiler) {
-        const manifest = JSON.parse(stripBom(__rspack_external_fs.readFileSync(this.manifestPath, 'utf-8')));
-        const patchedManifest = manifest_filterKeysForThisBrowser(manifest, this.browser);
-        const contentScriptsMeta = {};
-        try {
-            const csList = Array.isArray(patchedManifest.content_scripts) ? patchedManifest.content_scripts : [];
-            const originalCount = csList.length;
-            let bridgeOrdinal = 0;
-            for(let i = 0; i < csList.length; i++){
-                const cs = csList[i];
-                const bundleId = getCanonicalContentScriptJsAssetName(i);
-                const isMain = cs?.world === 'MAIN';
-                if (isMain) {
-                    const bridgeIndex = originalCount + bridgeOrdinal++;
-                    const bridgeBundleId = getCanonicalContentScriptJsAssetName(bridgeIndex);
-                    contentScriptsMeta[bundleId] = {
-                        index: i,
-                        bundleId,
-                        world: 'main',
-                        bridgeBundleId
-                    };
-                    contentScriptsMeta[bridgeBundleId] = {
-                        index: bridgeIndex,
-                        bundleId: bridgeBundleId,
-                        world: 'extension',
-                        role: 'main_world_bridge',
-                        mainBundleId: bundleId
-                    };
-                } else contentScriptsMeta[bundleId] = {
-                    index: i,
-                    bundleId,
-                    world: 'extension'
-                };
-            }
-        } catch  {}
-        new SetupBackgroundEntry({
-            manifestPath: this.manifestPath,
-            browser: this.browser
-        }).apply(compiler);
-        new webpack_target_webextension_fork({
-            background: this.getEntryName(patchedManifest),
-            hmrConfig: false,
-            weakRuntimeCheck: true,
-            contentScriptsMeta
-        }).apply(compiler);
-    }
-}
-const SCRIPTS_REPLAY_SHIM_SOURCE = `;(function () {
-  try {
-    if (typeof globalThis !== "object" || !globalThis) return;
-    var chromeRef =
-      (globalThis.chrome && globalThis.chrome.scripting && typeof globalThis.chrome.scripting.executeScript === "function")
-        ? globalThis.chrome
-        : (globalThis.browser && globalThis.browser.scripting && typeof globalThis.browser.scripting.executeScript === "function")
-          ? globalThis.browser
-          : null;
-    if (!chromeRef) return;
-    if (globalThis.__extjsScriptsReplayInstalled) return;
-    globalThis.__extjsScriptsReplayInstalled = true;
-
-    var registry = new Map();
-    var originalExecuteScript = chromeRef.scripting.executeScript.bind(chromeRef.scripting);
-
-    var serialize = function (entry) {
-      try {
-        return JSON.stringify({
-          files: entry && Array.isArray(entry.files) ? entry.files : [],
-          world: entry && entry.world ? String(entry.world) : ""
-        });
-      } catch (error) {
-        return "";
-      }
-    };
-
-    var track = function (injection) {
-      try {
-        var tabId = injection && injection.target && injection.target.tabId;
-        var files =
-          injection && Array.isArray(injection.files) ? injection.files.slice() : null;
-        if (typeof tabId !== "number") return;
-        if (!files || !files.length) return;
-        var world = injection.world ? String(injection.world) : undefined;
-        var entry = { files: files, world: world, sig: serialize({ files: files, world: world }) };
-        var existing = registry.get(tabId) || [];
-        // Dedupe by signature — repeated identical injections (e.g. user
-        // clicks the action twice) shouldn't stack in the replay list.
-        if (existing.some(function (e) { return e.sig === entry.sig; })) return;
-        existing.push(entry);
-        // Cap to the most recent 50 distinct injections per tab so a misbehaving
-        // user loop can't grow the registry unbounded.
-        registry.set(tabId, existing.slice(-50));
-      } catch (error) {
-        // Tracking is best-effort; never break the user's executeScript call.
-      }
-    };
-
-    chromeRef.scripting.executeScript = function (injection, callback) {
-      track(injection);
-      return originalExecuteScript(injection, callback);
-    };
-
-    var normalizeFile = function (value) {
-      return String(value || "").replace(/^[/\\\\]+/, "");
-    };
-
-    var fileMatches = function (entryFile, changedNormalized) {
-      var fn = normalizeFile(entryFile);
-      for (var i = 0; i < changedNormalized.length; i++) {
-        var c = changedNormalized[i];
-        if (!c) continue;
-        if (fn === c) return true;
-        if (fn.length > c.length && fn.slice(fn.length - c.length - 1) === "/" + c) return true;
-        if (c.length > fn.length && c.slice(c.length - fn.length - 1) === "/" + fn) return true;
-      }
-      return false;
-    };
-
-    globalThis.__extjsScriptsReplay = function (changedFiles) {
-      var changedNormalized = (Array.isArray(changedFiles) ? changedFiles : []).map(normalizeFile);
-      var promises = [];
-      registry.forEach(function (entries, tabId) {
-        entries.forEach(function (entry) {
-          var matches = false;
-          for (var i = 0; i < entry.files.length; i++) {
-            if (fileMatches(entry.files[i], changedNormalized)) {
-              matches = true;
-              break;
-            }
-          }
-          if (!matches) return;
-          try {
-            promises.push(
-              originalExecuteScript({
-                target: { tabId: tabId },
-                files: entry.files,
-                world: entry.world
-              }).then(
-                function () { return { ok: true, tabId: tabId, files: entry.files }; },
-                function (error) {
-                  return {
-                    ok: false,
-                    tabId: tabId,
-                    files: entry.files,
-                    error: String((error && error.message) || error)
-                  };
-                }
-              )
-            );
-          } catch (error) {
-            // Tab may have closed; skip silently.
-          }
-        });
-      });
-      return Promise.all(promises);
-    };
-  } catch (error) {
-    // Best-effort shim; do not break the SW bootstrap on any failure.
-  }
-})();
-`;
-const BACKGROUND_ASSET = /(^|\/)background\/(?:service_worker|script)\.js$/i;
-class InjectScriptsReplayShim {
-    apply(compiler) {
-        compiler.hooks.thisCompilation.tap(InjectScriptsReplayShim.name, (compilation)=>{
-            compilation.hooks.processAssets.tap({
-                name: InjectScriptsReplayShim.name,
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 100
-            }, ()=>{
-                for (const asset of compilation.getAssets()){
-                    if (!BACKGROUND_ASSET.test(asset.name)) continue;
-                    const original = asset.source.source().toString();
-                    if (-1 !== original.indexOf('__extjsScriptsReplayInstalled')) continue;
-                    const next = SCRIPTS_REPLAY_SHIM_SOURCE + '\n' + original;
-                    compilation.updateAsset(asset.name, new core_sources.RawSource(next));
-                }
-            });
-        });
-    }
-}
-const BRIDGE_PRODUCER_SOURCE = `;(function () {
-  try {
-    var g = (typeof globalThis === "object" && globalThis) ? globalThis : this;
-    if (!g || g.__extjsBridgeProducerInstalled) return;
-
-    var PORT = parseInt("__EXTJS_CONTROL_PORT__", 10);
-    var INSTANCE_ID = "__EXTJS_INSTANCE_ID__";
-    var CONTEXT = "__EXTJS_CONTEXT__";
-    // Connectable host of the dev-server control WS. Baked from the resolved
-    // connectable host (loopback locally; the public host for remote/devcontainer).
-    var HOST = "__EXTJS_CONTROL_HOST__";
-    if (!HOST || HOST.indexOf("__EXTJS") === 0) HOST = "127.0.0.1";
-    if (!PORT || PORT < 1) return;
-
-    var WS = g.WebSocket;
-    if (typeof WS !== "function") return;
-
-    var consoleRef = g.console || {};
-    g.__extjsBridgeProducerInstalled = true;
-
-    // Capture extension event listeners at install time. The producer is
-    // prepended to the background bundle, so these wraps run BEFORE user code
-    // registers its listeners — letting the bridge replay them on demand. The
-    // platform exposes no API to dispatch these events, and CDP attaches too
-    // late to wrap addListener, so this is the only path. Replay invokes the
-    // handler WITHOUT a user gesture, so the gesture-derived activeTab grant
-    // does NOT apply (callers are told gesture:false). This is engine-agnostic:
-    // it works on Chromium and Gecko because it only touches addListener.
-    //
-    // captureEvent transparently wraps addListener/removeListener (delegating to
-    // the originals) and records callbacks into the sink array.
-    function captureEvent(event, sink) {
-      try {
-        if (!event || typeof event.addListener !== "function") return;
-        var origAdd = event.addListener.bind(event);
-        event.addListener = function (cb) {
-          if (typeof cb === "function" && sink.indexOf(cb) === -1) sink.push(cb);
-          return origAdd(cb);
-        };
-        if (typeof event.removeListener === "function") {
-          var origRemove = event.removeListener.bind(event);
-          event.removeListener = function (cb) {
-            var i = sink.indexOf(cb);
-            if (i !== -1) sink.splice(i, 1);
-            return origRemove(cb);
-          };
-        }
-      } catch (e) { /* non-fatal: trigger falls back to its no-listener reply */ }
-    }
-
-    // Use g.chrome (not the hoisted chrome var below) — this runs first.
-    var actionClickedListeners = [];
-    var commandListeners = [];
-    if (g.chrome) {
-      captureEvent(g.chrome.action && g.chrome.action.onClicked, actionClickedListeners);
-      captureEvent(g.chrome.commands && g.chrome.commands.onCommand, commandListeners);
-    }
-
-    var LEVELS = ["log", "info", "warn", "error", "debug", "trace"];
-    var socket = null;
-    var open = false;
-    var queue = [];
-    var backoff = 250;
-    var MAX_BACKOFF = 5000;
-    var MAX_QUEUE = 1000;
-    var MAX_RESULT_BYTES = 256 * 1024;
-
-    function nowId() {
-      return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
-    }
-
-    function engineName() {
-      try {
-        return (typeof navigator !== "undefined" && /firefox/i.test(navigator.userAgent)) ? "firefox" : "chromium";
-      } catch (e) { return "chromium"; }
-    }
-
-    // JSON-safe, byte-capped clone of a result value.
-    function safeValue(v) {
-      try {
-        var s = JSON.stringify(v);
-        if (s === undefined) return {value: undefined, truncated: false};
-        if (s.length > MAX_RESULT_BYTES) {
-          return {value: {__type: "truncated", preview: s.slice(0, 1024)}, truncated: true};
-        }
-        return {value: JSON.parse(s), truncated: false};
-      } catch (e) {
-        return {value: {__type: "unserializable", preview: String(v).slice(0, 512)}, truncated: false};
-      }
-    }
-
-    function replyOk(cmdId, value) {
-      var s = safeValue(value);
-      var frame = {type: "result", cmdId: cmdId, ok: true, value: s.value};
-      if (s.truncated) frame.truncated = true;
-      try { socket && socket.send(JSON.stringify(frame)); } catch (e) {}
-    }
-
-    function replyErr(cmdId, name, message) {
-      var frame = {type: "result", cmdId: cmdId, ok: false, error: {name: name, message: String(message), engine: engineName()}};
-      try { socket && socket.send(JSON.stringify(frame)); } catch (e) {}
-    }
-
-    // Execute one authorized command in the SW (or route to a tab). chrome.*
-    // promise APIs are used; callback-only APIs are wrapped.
-    function executeCommand(cmd) {
-      var op = cmd.op, target = cmd.target || {}, args = cmd.args || {};
-      var ctx = target.context || "background";
-      var chrome = g.chrome;
-      var cmdId = cmd.cmdId;
-      try {
-        if (!chrome) { replyErr(cmdId, "Unsupported", "chrome.* not available in this context"); return; }
-        if (op === "eval") {
-          if (ctx === "background") {
-            Promise.resolve().then(function () { return (0, eval)(args.expression); })
-              .then(function (r) { replyOk(cmdId, r); }, function (e) {
-                var msg = (e && e.message) || String(e);
-                // MV3 forbids eval of strings in the SW/extension pages; Chrome
-                // rejects 'unsafe-eval' in MV3 extension_pages, so this can't be
-                // relaxed. Surface it honestly with a usable alternative.
-                if (/Content Security Policy|unsafe-eval/i.test(msg)) {
-                  replyErr(cmdId, "Unsupported", "eval is blocked in the MV3 service worker by CSP. Use --context page --tab <id> (eval runs in the page's MAIN world), or run on an MV2/Firefox build. Engine: " + engineName());
-                } else {
-                  replyErr(cmdId, (e && e.name) || "EvalError", msg);
-                }
-              });
-          } else if ((ctx === "content" || ctx === "page") && target.tabId && chrome.scripting) {
-            chrome.scripting.executeScript({
-              target: {tabId: target.tabId},
-              world: ctx === "page" ? "MAIN" : "ISOLATED",
-              func: function (src) { return eval(src); },
-              args: [String(args.expression)]
-            }).then(function (res) { replyOk(cmdId, res && res[0] ? res[0].result : undefined); },
-                    function (e) { replyErr(cmdId, "EvalError", e); });
-          } else {
-            replyErr(cmdId, "Unsupported", "eval in context " + ctx + " requires a tabId");
-          }
-          return;
-        }
-        if (op === "storage.get") {
-          chrome.storage[args.area || "local"].get(args.key != null ? args.key : null)
-            .then(function (r) { replyOk(cmdId, r); }, function (e) { replyErr(cmdId, "StorageError", e); });
-          return;
-        }
-        if (op === "storage.set") {
-          chrome.storage[args.area || "local"].set(args.items || {})
-            .then(function () { replyOk(cmdId, {set: Object.keys(args.items || {})}); }, function (e) { replyErr(cmdId, "StorageError", e); });
-          return;
-        }
-        if (op === "reload") {
-          if (ctx === "background") {
-            replyOk(cmdId, {reloading: true});
-            setTimeout(function () { try { chrome.runtime.reload(); } catch (e) {} }, 50);
-          } else if (target.tabId) {
-            chrome.tabs.reload(target.tabId).then(function () { replyOk(cmdId, {reloaded: target.tabId}); }, function (e) { replyErr(cmdId, "ReloadError", e); });
-          } else {
-            replyErr(cmdId, "Unsupported", "reload needs background or a tabId");
-          }
-          return;
-        }
-        if (op === "open") {
-          var surface = args.surface || ctx;
-          // getPopup is promise-style on Gecko and (MV3) Chromium; fall back to
-          // callback-style for older Chromium. Always resolves to a string.
-          var getActionPopup = function (cb) {
-            try {
-              var r = chrome.action && chrome.action.getPopup && chrome.action.getPopup({});
-              if (r && typeof r.then === "function") {
-                r.then(function (p) { cb(p || ""); }, function () { cb(""); });
-                return;
-              }
-            } catch (e) {}
-            try { chrome.action.getPopup({}, function (p) { cb(p || ""); }); }
-            catch (e) { cb(""); }
-          };
-          // Resolve the tab a replayed event should carry: an explicit args.tabId,
-          // else the active tab of the focused window.
-          var resolveActiveTab = function (a, cb) {
-            if (a && typeof a.tabId === "number") {
-              try { chrome.tabs.get(a.tabId, function (t) { cb(t || {id: a.tabId}); }); return; }
-              catch (e) {}
-            }
-            try { chrome.tabs.query({active: true, lastFocusedWindow: true}, function (tabs) { cb((tabs && tabs[0]) || undefined); }); }
-            catch (e) { cb(undefined); }
-          };
-          // Replaying a listener carries no user gesture, so activeTab is never
-          // granted. Warn when the manifest declares it (handler will diverge
-          // from a real click).
-          var activeTabWarning = function () {
-            try {
-              var m = chrome.runtime.getManifest();
-              var perms = (m && m.permissions) || [];
-              if (perms.indexOf("activeTab") !== -1) {
-                return "replayed without a user gesture: activeTab is NOT granted, so APIs that depend on it (scripting on the active tab, captureVisibleTab) behave differently than a real click";
-              }
-            } catch (e) {}
-            return null;
-          };
-          if (surface === "popup") {
-            if (chrome.action && chrome.action.openPopup) {
-              chrome.action.openPopup().then(function () { replyOk(cmdId, {opened: "popup"}); }, function (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); });
-            } else { replyErr(cmdId, "Unsupported", "action.openPopup not available"); }
-          } else if (surface === "options") {
-            try { chrome.runtime.openOptionsPage(function () { replyOk(cmdId, {opened: "options"}); }); }
-            catch (e) { replyErr(cmdId, "Unsupported", "openOptionsPage: " + e); }
-          } else if (surface === "sidebar") {
-            if (chrome.sidePanel && chrome.sidePanel.open && chrome.windows) {
-              chrome.windows.getCurrent(function (w) {
-                chrome.sidePanel.open({windowId: w.id}).then(function () { replyOk(cmdId, {opened: "sidebar"}); }, function (e) { replyErr(cmdId, "Unsupported", "sidePanel.open: " + e); });
-              });
-            } else { replyErr(cmdId, "Unsupported", "sidePanel not available (engine: " + engineName() + ")"); }
-          } else if (surface === "action") {
-            // Trigger the toolbar action. With a default_popup, clicking the icon
-            // opens it (reuse openPopup). Without a popup, clicking fires
-            // chrome.action.onClicked — we replay the listeners captured at install.
-            if (chrome.action) {
-              getActionPopup(function (popup) {
-                if (popup) {
-                  try {
-                    chrome.action.openPopup().then(function () { replyOk(cmdId, {triggered: "popup"}); }, function (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); });
-                  } catch (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); }
-                } else if (actionClickedListeners.length) {
-                  resolveActiveTab(args, function (tab) {
-                    var fired = 0;
-                    for (var i = 0; i < actionClickedListeners.length; i++) {
-                      try { actionClickedListeners[i](tab); fired++; } catch (e) {}
-                    }
-                    var reply = {triggered: "onClicked", listeners: fired, gesture: false};
-                    var warning = activeTabWarning();
-                    if (warning) reply.warning = warning;
-                    replyOk(cmdId, reply);
-                  });
-                } else {
-                  replyErr(cmdId, "Unsupported", "action has no popup and no onClicked listener registered");
-                }
-              });
-            } else { replyErr(cmdId, "Unsupported", "chrome.action not available (engine: " + engineName() + ")"); }
-          } else if (surface === "command") {
-            // Replay a captured chrome.commands.onCommand listener (keyboard
-            // shortcut). Same no-gesture caveat as onClicked.
-            var commandName = (args && args.name) || undefined;
-            if (!commandListeners.length) {
-              replyErr(cmdId, "Unsupported", "no chrome.commands.onCommand listener registered");
-            } else {
-              resolveActiveTab(args, function (tab) {
-                var fired = 0;
-                for (var i = 0; i < commandListeners.length; i++) {
-                  try { commandListeners[i](commandName, tab); fired++; } catch (e) {}
-                }
-                replyOk(cmdId, {triggered: "command", command: commandName || null, listeners: fired, gesture: false});
-              });
-            }
-          } else { replyErr(cmdId, "BadRequest", "unknown surface: " + surface); }
-          return;
-        }
-        if (op === "tabs.query") {
-          chrome.tabs.query(args || {}).then(function (tabs) {
-            replyOk(cmdId, (tabs || []).map(function (t) { return {id: t.id, url: t.url, title: t.title, active: t.active, windowId: t.windowId}; }));
-          }, function (e) { replyErr(cmdId, "TabsError", e); });
-          return;
-        }
-        if (op === "inspect") {
-          // Slice 3 sidecar/default path: extract a DOM snapshot from the target
-          // page via chrome.scripting (CDP-free). Closed shadow roots need the
-          // --deep-dom CDP escape hatch (separate tool); here we read open ones.
-          if ((ctx === "content" || ctx === "page") && target.tabId && chrome.scripting) {
-            var maxBytes = (args && args.maxBytes) || 262144;
-            var includeHtml = !args || !args.include || args.include.indexOf("html") !== -1;
-            chrome.scripting.executeScript({
-              target: {tabId: target.tabId},
-              world: ctx === "page" ? "MAIN" : "ISOLATED",
-              func: function (wantHtml, cap) {
-                function countShadow(root) {
-                  var n = 0, els = root.querySelectorAll("*");
-                  for (var i = 0; i < els.length; i++) { if (els[i].shadowRoot) { n++; n += countShadow(els[i].shadowRoot); } }
-                  return n;
-                }
-                var doc = document;
-                var roots = doc.querySelectorAll('#extension-root,[data-extension-root]');
-                var out = {
-                  url: location.href,
-                  title: doc.title,
-                  summary: {
-                    htmlLength: doc.documentElement.outerHTML.length,
-                    scriptCount: doc.querySelectorAll("script").length,
-                    styleCount: doc.querySelectorAll("style,link[rel=stylesheet]").length,
-                    extensionRootCount: roots.length,
-                    openShadowRoots: countShadow(doc),
-                    bodyChildCount: doc.body ? doc.body.children.length : 0
-                  }
-                };
-                if (wantHtml) {
-                  var html = doc.documentElement.outerHTML;
-                  if (cap > 0 && html.length > cap) { out.html = html.slice(0, cap); out.htmlTruncated = true; }
-                  else { out.html = html; }
-                }
-                return out;
-              },
-              args: [includeHtml, maxBytes]
-            }).then(function (res) { replyOk(cmdId, res && res[0] ? res[0].result : undefined); },
-                    function (e) { replyErr(cmdId, "InspectError", e); });
-          } else if (ctx === "popup" || ctx === "options" || ctx === "sidebar" || ctx === "devtools") {
-            // The SW can't read a surface page's DOM; ask the surface's own
-            // in-bundle relay (only the open, matching-context page responds).
-            chrome.runtime.sendMessage(
-              {__extjsInspectRequest: true, target: target, args: args},
-              function (resp) {
-                if (chrome.runtime.lastError || !resp) {
-                  replyErr(cmdId, "Unsupported", "surface '" + ctx + "' is not open (open it first: extension open " + ctx + ")");
-                } else if (resp.ok) {
-                  replyOk(cmdId, resp.value);
-                } else {
-                  replyErr(cmdId, (resp.error && resp.error.name) || "InspectError", (resp.error && resp.error.message) || "inspect failed");
-                }
-              }
-            );
-          } else if (ctx === "background") {
-            replyErr(cmdId, "Unsupported", "the service worker has no DOM; inspect a content/page (with --tab) or an open surface");
-          } else {
-            replyErr(cmdId, "Unsupported", "inspect of " + ctx + " requires a tabId (content/page) or an open surface");
-          }
-          return;
-        }
-        replyErr(cmdId, "BadRequest", "unknown op: " + op);
-      } catch (e) {
-        replyErr(cmdId, "ExecutorError", e);
-      }
-    }
-
-    function noopLastError() { try { void g.chrome.runtime.lastError; } catch (e) {} }
-
-    // Only http(s)/file/ftp tabs can run a content script; skip chrome://, the
-    // extension's own pages, about:blank, etc.
-    function isInjectableUrl(url) {
-      return typeof url === "string" && /^(https?|file|ftp):/i.test(url);
-    }
-
-    // Re-inject a single declared content-script entry's fresh files into every
-    // open tab it matches, in place. The wrapper's reinject runtime tears down
-    // the previous mount (matched by data-extjs-reinject-owner + build hash) and
-    // mounts the new one — so this is the controller-less equivalent of the CDP
-    // controller's reinjection, just driven from inside the extension.
-    //
-    // exclude_matches MUST be honored: the browser's own static injection never
-    // touches excluded pages, and extensions can rely on that (e.g. a script
-    // whose message handler opens the very page it excludes — injecting there
-    // anyway creates an open-a-tab → inject → open-a-tab runaway loop). Chrome's
-    // tabs.query has no exclude support, so query the exclude patterns
-    // separately and subtract — the browser stays the single pattern matcher.
-    function reinjectContentScriptEntry(entry) {
-      var chrome = g.chrome;
-      var matches = (entry && entry.matches) || [];
-      if (!Array.isArray(matches) || !matches.length) return;
-      var excludeMatches = (entry && entry.exclude_matches) || [];
-      var jsFiles = ((entry && entry.js) || []).filter(function (f) { return typeof f === "string"; });
-      var cssFiles = ((entry && entry.css) || []).filter(function (f) { return typeof f === "string"; });
-      if (!jsFiles.length && !cssFiles.length) return;
-      var world = entry.world === "MAIN" ? "MAIN" : "ISOLATED";
-      var allFrames = !!entry.all_frames;
-      function injectInto(excludedTabIds) {
-        try {
-          chrome.tabs.query({url: matches}, function (tabs) {
-            var err = null;
-            try { err = chrome.runtime.lastError; } catch (e) {}
-            if (err || !tabs) return;
-            for (var i = 0; i < tabs.length; i++) {
-              (function (tab) {
-                if (!tab || tab.id == null || !isInjectableUrl(tab.url)) return;
-                if (excludedTabIds[tab.id]) return;
-                var target = {tabId: tab.id, allFrames: allFrames};
-                if (cssFiles.length && chrome.scripting.insertCSS) {
-                  try { chrome.scripting.insertCSS({target: target, files: cssFiles}, noopLastError); } catch (e) {}
-                }
-                if (jsFiles.length && chrome.scripting.executeScript) {
-                  try {
-                    chrome.scripting.executeScript(
-                      {target: target, files: jsFiles, world: world, injectImmediately: true},
-                      noopLastError
-                    );
-                  } catch (e) {}
-                }
-              })(tabs[i]);
-            }
-          });
-        } catch (e) {}
-      }
-      if (Array.isArray(excludeMatches) && excludeMatches.length) {
-        try {
-          chrome.tabs.query({url: excludeMatches}, function (excludedTabs) {
-            try { void chrome.runtime.lastError; } catch (e) {}
-            var excluded = {};
-            if (excludedTabs) {
-              for (var i = 0; i < excludedTabs.length; i++) {
-                if (excludedTabs[i] && excludedTabs[i].id != null) excluded[excludedTabs[i].id] = true;
-              }
-            }
-            injectInto(excluded);
-          });
-          return;
-        } catch (e) {}
-      }
-      injectInto({});
-    }
-
-    // Re-inject all content scripts into their open tabs. Reads the manifest
-    // FROM DISK (not chrome.runtime.getManifest(), which is frozen at extension-
-    // registration time) because dev content-script filenames are content-hashed
-    // and change on every edit — disk has the new js/css paths.
-    function reinjectContentScripts(onDone) {
-      var chrome = g.chrome;
-      try {
-        if (typeof g.fetch !== "function" || !chrome.scripting) return false;
-        g.fetch(chrome.runtime.getURL("manifest.json"), {cache: "no-store"})
-          .then(function (r) { return r.json(); })
-          .then(function (manifest) {
-            var entries = (manifest && manifest.content_scripts) || [];
-            for (var i = 0; i < entries.length; i++) reinjectContentScriptEntry(entries[i]);
-            reregisterForFutureNavigations(entries);
-            if (onDone) { try { onDone(); } catch (e) {} }
-          })
-          .catch(function () {});
-        return true;
-      } catch (e) { return false; }
-    }
-
-    function mapRunAt(runAt) {
-      if (runAt === "document_start") return "document_start";
-      if (runAt === "document_end") return "document_end";
-      return "document_idle";
-    }
-
-    // Re-register the content scripts dynamically (chrome.scripting) pointing at
-    // the fresh files, so tabs opened AFTER an edit also get the new build. The
-    // static manifest registration still points at the old content-hashed file
-    // (it only updates on an extension reload) and keeps firing on new
-    // navigations; the dynamic registration injects the new file alongside it,
-    // and the wrapper's reinject runtime converges the mount to the newest build.
-    // Idempotent: update an existing id, else register it.
-    function reregisterForFutureNavigations(entries) {
-      var chrome = g.chrome;
-      if (
-        !chrome.scripting ||
-        !chrome.scripting.registerContentScripts ||
-        !chrome.scripting.getRegisteredContentScripts
-      ) return;
-
-      var scripts = [];
-      for (var i = 0; i < entries.length; i++) {
-        var e = entries[i] || {};
-        if (!Array.isArray(e.matches) || !e.matches.length) continue;
-        var js = (e.js || []).filter(function (f) { return typeof f === "string"; });
-        var css = (e.css || []).filter(function (f) { return typeof f === "string"; });
-        if (!js.length && !css.length) continue;
-        var s = {
-          id: "extjs-dev-cs-" + i,
-          matches: e.matches,
-          runAt: mapRunAt(e.run_at),
-          allFrames: !!e.all_frames,
-          world: e.world === "MAIN" ? "MAIN" : "ISOLATED"
-        };
-        // Dev registration must not be BROADER than the static one: dropping
-        // exclude_matches injects into pages the browser itself would skip.
-        if (Array.isArray(e.exclude_matches) && e.exclude_matches.length) {
-          s.excludeMatches = e.exclude_matches;
-        }
-        if (js.length) s.js = js;
-        if (css.length) s.css = css;
-        scripts.push(s);
-      }
-      if (!scripts.length) return;
-
-      try {
-        chrome.scripting.getRegisteredContentScripts(function (existing) {
-          try { void chrome.runtime.lastError; } catch (e) {}
-          var have = {};
-          if (existing) for (var k = 0; k < existing.length; k++) have[existing[k].id] = true;
-          var toRegister = [], toUpdate = [];
-          for (var j = 0; j < scripts.length; j++) {
-            (have[scripts[j].id] ? toUpdate : toRegister).push(scripts[j]);
-          }
-          if (toRegister.length) {
-            try { chrome.scripting.registerContentScripts(toRegister, noopLastError); } catch (e) {}
-          }
-          if (toUpdate.length) {
-            try { chrome.scripting.updateContentScripts(toUpdate, noopLastError); } catch (e) {}
-          }
-        });
-      } catch (e) {}
-    }
-
-    // Perform a dev-loop reload without the CDP controller:
-    //   - content-scripts: re-inject the fresh script into open matching tabs in
-    //     place (no extension restart), the controller-less equivalent of CDP
-    //     reinjection. Needs the scripting permission + host access to the tab —
-    //     both injected in dev by ApplyDevDefaults. Falls back to a full reload
-    //     if scripting is unavailable.
-    //   - service-worker / full / manifest: restart the whole extension so it
-    //     re-registers from the fresh manifest.
-    function performDevReload(type, onDone) {
-      var chrome = g.chrome;
-      if (!chrome) return;
-
-      var fullReload = function () {
-        // Leave a pending-reinject flag for the NEXT producer generation:
-        // Chrome never re-runs content scripts in tabs that were already open
-        // when the extension reloads, and runtime.reload() does NOT fire
-        // onInstalled (verified Chromium 146), so the boot-time heal below is
-        // the only thing that converges open tabs after a SW/full reload —
-        // without it a shared SW+content module edit restarts the SW while
-        // every open tab keeps the stale content world (family F).
-        try {
-          if (chrome.storage && chrome.storage.local) {
-            chrome.storage.local.set({__extjsDevPendingReinject: Date.now()}, noopLastError);
-          }
-        } catch (e) {}
-        // Deferred so any in-flight result/log frame — and the "Reloading…"
-        // console announcement dispatched into tabs — flushes before the SW
-        // dies. runtime.reload() restarts the whole extension; the devtools
-        // companion confirms completion via chrome.management events, so no
-        // onDone here.
-        try { setTimeout(function () { try { chrome.runtime.reload(); } catch (e) {} }, 150); } catch (e) {}
-      };
-
-      if (type === "content-scripts" && chrome.scripting && chrome.tabs && chrome.tabs.query) {
-        if (reinjectContentScripts(onDone)) return;
-      }
-
-      fullReload();
-    }
-
-    // ---- Dev-reload announcement surfaces --------------------------------
-    // One server-built label travels the ReloadFrame; the producer echoes it
-    // 1:1 into (a) the page's devtools console and (b) the bundled
-    // extension-js-devtools companion (the bottom-left pill). Both fire HERE,
-    // next to the actual reload action, so a surface can only say
-    // "Reloading…" when a reload is actually being performed.
-
-    // Stable IDs of the bundled extension-js-devtools companion: Chromium pins
-    // via the manifest "key"; Firefox via browser_specific_settings.gecko.id.
-    // Absent companion (e.g. --no-browser in the user's own browser) is fine —
-    // sendMessage just reports no receiver and we swallow it.
-    var DEVTOOLS_COMPANION_ID_CHROMIUM = "kgdaecdpfkikjncaalnmmnjjfpofkcbl";
-    var DEVTOOLS_COMPANION_ID_FIREFOX = "devtools@extension.js";
-
-    function notifyDevtoolsCompanion(phase, label, kind) {
-      try {
-        var chrome = g.chrome;
-        if (!chrome || !chrome.runtime || typeof chrome.runtime.sendMessage !== "function") return;
-        var id = engineName() === "firefox" ? DEVTOOLS_COMPANION_ID_FIREFOX : DEVTOOLS_COMPANION_ID_CHROMIUM;
-        chrome.runtime.sendMessage(
-          id,
-          {type: "extjs-dev-reload-state", phase: phase, label: label || "", kind: kind || "", instanceId: INSTANCE_ID},
-          function () { noopLastError(); }
-        );
-      } catch (e) {}
-    }
-
-    // console.log the reload line into every open injectable tab. Runs in the
-    // user extension's ISOLATED world, where the bridge relay patched console —
-    // so the same line also lands in the centralized dev-server log stream.
-    function announceReloadInTabs(text) {
-      var chrome = g.chrome;
-      if (!chrome || !chrome.tabs || !chrome.tabs.query) return;
-      try {
-        chrome.tabs.query({}, function (tabs) {
-          noopLastError();
-          if (!tabs) return;
-          for (var i = 0; i < tabs.length; i++) {
-            (function (tab) {
-              if (!tab || tab.id == null || !isInjectableUrl(tab.url)) return;
-              if (chrome.scripting && chrome.scripting.executeScript) {
-                try {
-                  chrome.scripting.executeScript(
-                    {target: {tabId: tab.id}, func: function (t) { console.log(t); }, args: [text]},
-                    noopLastError
-                  );
-                  return;
-                } catch (e) {}
-              }
-              // MV2 fallback (Firefox without the scripting API).
-              if (chrome.tabs.executeScript) {
-                try {
-                  chrome.tabs.executeScript(tab.id, {code: "console.log(" + JSON.stringify(text) + ");"}, noopLastError);
-                } catch (e) {}
-              }
-            })(tabs[i]);
-          }
-        });
-      } catch (e) {}
-    }
-
-    function handleDevReloadFrame(frame) {
-      var kind = frame.reloadType || "full";
-      var label = typeof frame.label === "string" ? frame.label : "";
-      // The server always builds the label; the kind-derived fallback only
-      // covers a malformed frame so the announcement stays truthful.
-      var fallback = kind === "content-scripts" ? "content_script"
-        : kind === "service-worker" ? "service_worker"
-        : "extension";
-      var announced = "[extension.js] Reloading " + (label || fallback) + "…";
-
-      notifyDevtoolsCompanion("reloading", label, kind);
-
-      if (kind === "page") {
-        // Notify-only: rspack-dev-server's livereload refreshes the open
-        // surface; reloading the extension here would race it. No tab console
-        // line either — the reloading page clears its own console anyway.
-        return;
-      }
-
-      // Delivery ack for the broker: proves this SW's message pump actually
-      // processed the frame — a successful socket WRITE proves nothing when
-      // the worker is wedged-but-connected (bug 27). The broker latches a
-      // content-scripts reload until this ack and replays it to the next
-      // producer hello, so an edit that landed on a dead pump still converges.
-      // Sent on receipt (not after reinjection): the scripting-unavailable
-      // fallback restarts the whole extension, and an unacked latch would
-      // replay into the fresh SW and restart it a second time.
-      send({type: "reload-ack", reloadType: kind, label: label});
-
-      announceReloadInTabs(announced);
-      performDevReload(kind, function () {
-        // Only the content-scripts path confirms from here (reinjection ran to
-        // completion in this same SW). Full/SW reloads are confirmed by the
-        // devtools companion's chrome.management listeners.
-        notifyDevtoolsCompanion("reloaded", label, kind);
-      });
-    }
-
-    function sanitize(args) {
-      var out = [];
-      for (var i = 0; i < args.length; i++) {
-        var p = args[i];
-        try {
-          if (typeof p === "string") out.push(p.length > 2048 ? p.slice(0, 2048) + "..." : p);
-          else if (p instanceof Error) out.push(p.name + ": " + p.message);
-          else out.push(JSON.stringify(p));
-        } catch (e) {
-          out.push(String(p));
-        }
-        if (out.join(" ").length > 8192) break;
-      }
-      return out;
-    }
-
-    function flush() {
-      while (queue.length && open && socket) {
-        var f = queue.shift();
-        try { socket.send(JSON.stringify(f)); } catch (e) { break; }
-      }
-    }
-
-    function send(frame) {
-      if (open && socket) {
-        try { socket.send(JSON.stringify(frame)); return; } catch (e) {}
-      }
-      if (queue.length < MAX_QUEUE) queue.push(frame);
-    }
-
-    function schedule() {
-      var delay = backoff;
-      backoff = Math.min(backoff * 2, MAX_BACKOFF);
-      try { setTimeout(connect, delay); } catch (e) {}
-    }
-
-    function connect() {
-      try {
-        socket = new WS("ws://" + HOST + ":" + PORT + "/extjs-control");
-      } catch (e) {
-        schedule();
-        return;
-      }
-      socket.onopen = function () {
-        open = true;
-        backoff = 250;
-        try {
-          socket.send(JSON.stringify({type: "hello", v: 1, role: "producer", instanceId: INSTANCE_ID}));
-        } catch (e) {}
-        flush();
-      };
-      socket.onmessage = function (ev) {
-        // Slice 2: the broker routes authorized command frames to this SW.
-        var frame;
-        try { frame = JSON.parse(typeof ev.data === "string" ? ev.data : ""); } catch (e) { return; }
-        if (frame && frame.type === "command") {
-          try { executeCommand(frame); } catch (e) { replyErr(frame.cmdId, "ExecutorError", e); }
-        } else if (frame && frame.type === "reload") {
-          // Dev-loop reload broadcast (see broker.broadcastReload).
-          // Fire-and-forget: no result frame is expected.
-          try { handleDevReloadFrame(frame); } catch (e) {}
-        } else if (frame && frame.type === "ping") {
-          // Server keepalive: merely RECEIVING this message resets the MV3
-          // service worker's ~30s idle timer (Chrome 116+), keeping this SW
-          // reachable for reload broadcasts. Nothing to do.
-        }
-      };
-      socket.onclose = function () {
-        open = false;
-        socket = null;
-        schedule();
-      };
-      socket.onerror = function () {
-        try { socket && socket.close(); } catch (e) {}
-      };
-    }
-
-    LEVELS.forEach(function (level) {
-      var orig = typeof consoleRef[level] === "function"
-        ? consoleRef[level].bind(consoleRef)
-        : function () {};
-      consoleRef[level] = function () {
-        try {
-          send({
-            type: "log",
-            event: {
-              v: 1,
-              id: nowId(),
-              timestamp: Date.now(),
-              level: level,
-              context: CONTEXT,
-              messageParts: sanitize([].slice.call(arguments)),
-              runId: INSTANCE_ID
-            }
-          });
-        } catch (e) {}
-        return orig.apply(consoleRef, arguments);
-      };
-    });
-
-    // Multi-context console forwarding: other contexts (content scripts, surface
-    // pages) can't reliably open ws://127.0.0.1 (page CSP / connect-src), so they
-    // relay console to this SW, which owns the WS. The relay travels a NAMED
-    // runtime.Port — never runtime.sendMessage — because port traffic is
-    // invisible to the extension's own onMessage listeners. With sendMessage, an
-    // extension whose SW echoes every message back to its tabs (wild newtube:
-    // onMessage → tabs.sendMessage(msg) to all tabs) turned each relayed log
-    // into a new tab message, whose subject-side console.log became another
-    // relayed envelope — a self-sustaining dev-only message storm (25k rows/10min
-    // observed) that starved the extension system and wedged Chromium's DevTools
-    // endpoint (family B). We enrich with the real tabId/url from the port sender.
-    function shipRelayedLog(ev, sender) {
-      try {
-        send({
-          type: "log",
-          event: {
-            v: 1,
-            id: nowId(),
-            timestamp: Date.now(),
-            level: ev.level || "log",
-            context: ev.context || "content",
-            messageParts: Array.isArray(ev.messageParts) ? ev.messageParts : [],
-            url: ev.url || (sender ? sender.url : undefined),
-            tabId: sender && sender.tab ? sender.tab.id : undefined,
-            frameId: sender ? sender.frameId : undefined,
-            runId: INSTANCE_ID
-          }
-        });
-      } catch (e) {}
-    }
-    try {
-      var rtPort = g.chrome;
-      if (rtPort && rtPort.runtime && rtPort.runtime.onConnect) {
-        rtPort.runtime.onConnect.addListener(function (port) {
-          if (!port || port.name !== "__extjs-bridge-log__") return;
-          try {
-            port.onMessage.addListener(function (msg) {
-              if (!msg || !msg.__extjsBridgeLog) return;
-              shipRelayedLog(msg.__extjsBridgeLog, port.sender);
-            });
-          } catch (e) {}
-        });
-      }
-    } catch (e) {}
-    // Legacy sendMessage path: kept for any surface still relaying the old way
-    // (harmless one-predicate listener; new relays never use it).
-    try {
-      var rt = g.chrome;
-      if (rt && rt.runtime && rt.runtime.onMessage) {
-        rt.runtime.onMessage.addListener(function (msg, sender) {
-          if (!msg || !msg.__extjsBridgeLog) return;
-          shipRelayedLog(msg.__extjsBridgeLog, sender);
-          // No async response.
-        });
-      }
-    } catch (e) {}
-
-    // Chrome never injects manifest content scripts into tabs that were
-    // already open when the extension (re)loads, so after a dev full reload
-    // (manifest edit, SW edit, chrome.runtime.reload) every open tab keeps the
-    // PREVIOUS build's content-script DOM as a zombie: the nodes still render
-    // but their listeners died with the old world, and nothing heals the tab
-    // until the next recompile happens to reinject. Fire one producer-driven
-    // reinject when this SW generation is a fresh install/reload so open tabs
-    // converge to the new build immediately. onInstalled is the gate: it fires
-    // for install/update/reload (fresh worlds) but NOT for idle-stop SW wakes,
-    // where reinjecting would churn mounted UI for no reason.
-    try {
-      var rtBoot = g.chrome;
-      if (rtBoot && rtBoot.runtime && rtBoot.runtime.onInstalled) {
-        rtBoot.runtime.onInstalled.addListener(function () {
-          try {
-            setTimeout(function () {
-              try { reinjectContentScripts(); } catch (e) {}
-            }, 250);
-          } catch (e) {}
-        });
-      }
-    } catch (e) {}
-
-    // runtime.reload() does NOT fire onInstalled (verified Chromium 146), so
-    // a dev-driven SW/full reload leaves the listener above silent and every
-    // open tab keeps the previous build's content world. fullReload() stamps
-    // __extjsDevPendingReinject into storage.local right before reloading;
-    // consume it here (fresh flags only — a stale one from a crashed session
-    // is dropped) and heal open tabs from the on-disk manifest. Idle-stop SW
-    // wakes never see the flag, so this cannot churn mounted UI.
-    try {
-      var stBoot = g.chrome;
-      if (stBoot && stBoot.storage && stBoot.storage.local) {
-        stBoot.storage.local.get("__extjsDevPendingReinject", function (res) {
-          noopLastError();
-          var ts = res && res.__extjsDevPendingReinject;
-          if (ts == null) return;
-          try { stBoot.storage.local.remove("__extjsDevPendingReinject", noopLastError); } catch (e) {}
-          if (typeof ts !== "number" || Date.now() - ts > 30000) return;
-          setTimeout(function () {
-            try { reinjectContentScripts(); } catch (e) {}
-          }, 250);
-        });
-      }
-    } catch (e) {}
-
-    connect();
-  } catch (e) {}
-})();
-`;
-const BRIDGE_RELAY_SOURCE = `;(function () {
-  try {
-    var g = (typeof globalThis === "object" && globalThis) ? globalThis : this;
-    if (!g || g.__extjsBridgeRelayInstalled) return;
-
-    var CONTEXT = "__EXTJS_CONTEXT__";
-    var chrome = g.chrome;
-    if (!chrome || !chrome.runtime) return;
-    var canRelay = typeof chrome.runtime.connect === "function";
-
-    g.__extjsBridgeRelayInstalled = true;
-    var consoleRef = g.console || {};
-    var LEVELS = ["log", "info", "warn", "error", "debug", "trace"];
-
-    function sanitize(args) {
-      var out = [];
-      for (var i = 0; i < args.length; i++) {
-        var p = args[i];
-        try {
-          if (typeof p === "string") out.push(p.length > 2048 ? p.slice(0, 2048) + "..." : p);
-          else if (p instanceof Error) out.push(p.name + ": " + p.message);
-          else out.push(JSON.stringify(p));
-        } catch (e) { out.push(String(p)); }
-        if (out.join(" ").length > 8192) break;
-      }
-      return out;
-    }
-
-    function here() { try { return g.location ? g.location.href : undefined; } catch (e) { return undefined; } }
-
-    // Lazy named port to the SW producer. Connecting wakes an idle SW like
-    // sendMessage does, but port frames never reach the extension's own
-    // onMessage listeners (see the loop note above). Reconnect on demand: the
-    // SW idling out (or reloading) disconnects the port; the next log redials.
-    var logPort = null;
-    function getLogPort() {
-      if (!canRelay) return null;
-      if (logPort) return logPort;
-      try {
-        logPort = chrome.runtime.connect({name: "__extjs-bridge-log__"});
-        logPort.onDisconnect.addListener(function () {
-          try { void chrome.runtime.lastError; } catch (e) {}
-          logPort = null;
-        });
-      } catch (e) { logPort = null; }
-      return logPort;
-    }
-
-    LEVELS.forEach(function (level) {
-      var orig = typeof consoleRef[level] === "function" ? consoleRef[level].bind(consoleRef) : function () {};
-      consoleRef[level] = function () {
-        try {
-          var p = getLogPort();
-          if (p) {
-            try {
-              p.postMessage({__extjsBridgeLog: {level: level, context: CONTEXT, messageParts: sanitize([].slice.call(arguments)), url: here()}});
-            } catch (e) {
-              // stale port (SW restarted): drop it and redial once
-              logPort = null;
-              var p2 = getLogPort();
-              if (p2) { try { p2.postMessage({__extjsBridgeLog: {level: level, context: CONTEXT, messageParts: sanitize([].slice.call(arguments)), url: here()}}); } catch (e2) {} }
-            }
-          }
-        } catch (e) {}
-        return orig.apply(consoleRef, arguments);
-      };
-    });
-
-    // Surface DOM inspection: the SW executor can't reach popup/options/sidebar
-    // DOM (separate extension pages), and the sidecar can't either (cross-extension
-    // isolation). So THIS page — the user extension's own surface — answers an
-    // inspect request for its own context. The SW broadcasts the request; only the
-    // matching-context surface responds with its DOM snapshot.
-    try {
-      if (chrome.runtime && chrome.runtime.onMessage) {
-        chrome.runtime.onMessage.addListener(function (msg, _sender, sendResponse) {
-          if (!msg || !msg.__extjsInspectRequest) return;
-          if (!msg.target || msg.target.context !== CONTEXT) return; // not for me
-          try {
-            var args = msg.args || {};
-            var wantHtml = !args.include || args.include.indexOf("html") !== -1;
-            var cap = args.maxBytes || 262144;
-            function countShadow(root) {
-              var n = 0, els = root.querySelectorAll("*");
-              for (var i = 0; i < els.length; i++) { if (els[i].shadowRoot) { n++; n += countShadow(els[i].shadowRoot); } }
-              return n;
-            }
-            var doc = g.document;
-            var roots = doc.querySelectorAll('#extension-root,[data-extension-root]');
-            var snap = {
-              context: CONTEXT,
-              url: here(),
-              title: doc.title,
-              summary: {
-                htmlLength: doc.documentElement.outerHTML.length,
-                scriptCount: doc.querySelectorAll("script").length,
-                styleCount: doc.querySelectorAll("style,link[rel=stylesheet]").length,
-                extensionRootCount: roots.length,
-                openShadowRoots: countShadow(doc),
-                bodyChildCount: doc.body ? doc.body.children.length : 0
-              }
-            };
-            if (wantHtml) {
-              var html = doc.documentElement.outerHTML;
-              if (cap > 0 && html.length > cap) { snap.html = html.slice(0, cap); snap.htmlTruncated = true; }
-              else { snap.html = html; }
-            }
-            sendResponse({ok: true, value: snap});
-          } catch (e) {
-            sendResponse({ok: false, error: {name: "InspectError", message: String(e)}});
-          }
-          return true; // responded
-        });
-      }
-    } catch (e) {}
-  } catch (e) {}
-})();
-`;
-function buildBridgeRelaySource(opts) {
-    return BRIDGE_RELAY_SOURCE.replace(/__EXTJS_CONTEXT__/g, String(opts.context || 'content'));
-}
-function 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 inject_bridge_producer_BACKGROUND_ASSET = /(^|\/)background\/(?:service_worker|scripts?)\.js$/i;
-class InjectBridgeProducer {
-    apply(compiler) {
-        const controlPort = parseInt(String(process.env.EXTENSION_CONTROL_PORT || ''), 10);
-        const instanceId = String(process.env.EXTENSION_INSTANCE_ID || '');
-        const host = String(process.env.EXTENSION_DEV_SERVER_CONNECTABLE_HOST || '').trim() || '127.0.0.1';
-        const source = buildBridgeProducerSource({
-            controlPort: Number.isFinite(controlPort) ? controlPort : null,
-            instanceId,
-            context: 'background',
-            host
-        });
-        if (!source) return;
-        compiler.hooks.thisCompilation.tap(InjectBridgeProducer.name, (compilation)=>{
-            compilation.hooks.processAssets.tap({
-                name: InjectBridgeProducer.name,
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 101
-            }, ()=>{
-                for (const asset of compilation.getAssets()){
-                    if (!inject_bridge_producer_BACKGROUND_ASSET.test(asset.name)) continue;
-                    const original = asset.source.source().toString();
-                    if (-1 !== original.indexOf('__extjsBridgeProducerInstalled')) continue;
-                    const next = source + '\n' + original;
-                    compilation.updateAsset(asset.name, new core_sources.RawSource(next));
-                }
-            });
-        });
-    }
-}
-const RELAY_TARGETS = [
-    {
-        re: /(^|\/)content_scripts\/.+\.js$/i,
-        context: 'content'
-    },
-    {
-        re: /(^|\/)action\/index\.js$/i,
-        context: 'popup'
-    },
-    {
-        re: /(^|\/)options\/index\.js$/i,
-        context: 'options'
-    },
-    {
-        re: /(^|\/)sidebar\/index\.js$/i,
-        context: 'sidebar'
-    },
-    {
-        re: /(^|\/)devtools\/index\.js$/i,
-        context: 'devtools'
-    }
-];
-class InjectBridgeRelay {
-    apply(compiler) {
-        const controlPort = parseInt(String(process.env.EXTENSION_CONTROL_PORT || ''), 10);
-        if (!Number.isFinite(controlPort) || controlPort < 1) return;
-        const sourceFor = new Map();
-        for (const t of RELAY_TARGETS)if (!sourceFor.has(t.context)) sourceFor.set(t.context, buildBridgeRelaySource({
-            context: t.context
-        }));
-        compiler.hooks.thisCompilation.tap(InjectBridgeRelay.name, (compilation)=>{
-            compilation.hooks.processAssets.tap({
-                name: InjectBridgeRelay.name,
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 101
-            }, ()=>{
-                for (const asset of compilation.getAssets()){
-                    const target = RELAY_TARGETS.find((t)=>t.re.test(asset.name));
-                    if (!target) continue;
-                    const original = asset.source.source().toString();
-                    if (-1 !== original.indexOf('__extjsBridgeRelayInstalled')) continue;
-                    const next = sourceFor.get(target.context) + '\n' + original;
-                    compilation.updateAsset(asset.name, new core_sources.RawSource(next));
-                }
-            });
-        });
-    }
-}
-const DEV_SERVER_STRONG_MARKERS = [
-    '@rspack/dev-server/client/index.js?',
-    '@rspack/dev-server/client/utils/ansiHTML.js',
-    '[HMR] Waiting for update signal from WDS...'
-];
-const DEV_SERVER_WEAK_MARKERS = [
-    'webpack-dev-server',
-    'WebSocketClient',
-    '.hot.check()',
-    '[HMR] Cannot find update. Need to do a full reload!'
-];
-function contentScriptRetainsDevServerRuntime(source) {
-    return source.includes('@rspack/dev-server/client');
-}
-function stripDevServerStartupFromContentScript(source) {
-    let nextSource = source;
-    const startupModuleIds = getStartupModuleIds(source);
-    for (const moduleId of startupModuleIds){
-        const moduleBody = getModuleBody(source, moduleId);
-        if (!moduleBody) continue;
-        const strongHit = DEV_SERVER_STRONG_MARKERS.some((marker)=>moduleBody.includes(marker));
-        const weakHits = DEV_SERVER_WEAK_MARKERS.filter((marker)=>moduleBody.includes(marker)).length;
-        if (strongHit || weakHits >= 2) nextSource = stripStartupRequire(nextSource, moduleId);
-    }
-    return nextSource;
-}
-function getStartupModuleIds(source) {
-    const startupIndex = source.indexOf('// startup');
-    if (-1 === startupIndex) return [];
-    const startupSection = source.slice(startupIndex);
-    const requirePattern = /__webpack_require__\((\d+)\);/g;
-    const ids = [];
-    let match = null;
-    while(match = requirePattern.exec(startupSection))ids.push(match[1]);
-    return ids;
-}
-function getModuleBody(source, moduleId) {
-    const moduleHeaderPattern = new RegExp(`(?:^|\\n)${moduleId}\\([^)]*\\)\\s*\\{`, 'm');
-    const headerMatch = moduleHeaderPattern.exec(source);
-    if (!headerMatch) return null;
-    const moduleStart = headerMatch.index;
-    const nextHeaderPattern = /(?:^|\n)\d+\([^)]*\)\s*\{/g;
-    nextHeaderPattern.lastIndex = moduleStart + headerMatch[0].length;
-    const nextHeaderMatch = nextHeaderPattern.exec(source);
-    return source.slice(moduleStart, nextHeaderMatch ? nextHeaderMatch.index : source.length);
-}
-function stripStartupRequire(source, moduleId) {
-    const startupRequirePattern = new RegExp(`^\\s*__webpack_require__\\(${moduleId}\\);\\n?`, 'm');
-    return source.replace(startupRequirePattern, '');
-}
-const CONTENT_SCRIPT_ASSET = /(^|\/)content_scripts\/content-\d+(?:\.[a-f0-9]+)?\.js$/i;
-class StripContentScriptDevServerRuntime {
-    apply(compiler) {
-        compiler.hooks.thisCompilation.tap(StripContentScriptDevServerRuntime.name, (compilation)=>{
-            compilation.hooks.processAssets.tap({
-                name: StripContentScriptDevServerRuntime.name,
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT
-            }, ()=>{
-                for (const asset of compilation.getAssets()){
-                    if (!CONTENT_SCRIPT_ASSET.test(asset.name)) continue;
-                    const originalSource = asset.source.source().toString();
-                    const strippedSource = stripDevServerStartupFromContentScript(originalSource);
-                    if (strippedSource !== originalSource) compilation.updateAsset(asset.name, new core_sources.RawSource(strippedSource));
-                    if (contentScriptRetainsDevServerRuntime(strippedSource)) {
-                        const warning = new core_WebpackError(`Could not strip the dev-server runtime from ${asset.name}. This usually means the bundler's output format changed and Extension.js needs an update. The content script may try to open a dev-server connection on the host page. Please report this at https://github.com/extension-js/extension.js/issues.`);
-                        warning.name = 'ContentScriptDevServerRuntimeWarning';
-                        warning.file = asset.name;
-                        compilation.warnings ||= [];
-                        compilation.warnings.push(warning);
-                    }
-                }
-            });
-        });
-    }
-}
-class KeepGetURLImportsNative {
-    manifestPath;
-    constructor(options){
-        this.manifestPath = options.manifestPath;
+class KeepGetURLImportsNative {
+    manifestPath;
+    constructor(options){
+        this.manifestPath = options.manifestPath;
     }
     apply(compiler) {
         const manifestDir = canonicalizeDir(__rspack_external_path.dirname(this.manifestPath));
@@ -9291,7 +6259,7 @@ class ValidateContentScriptSyntax {
         compiler.hooks.thisCompilation.tap("scripts:validate-content-script-syntax", (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: "scripts:validate-content-script-syntax",
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT
+                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT
             }, ()=>{
                 const assets = 'function' == typeof compilation.getAssets ? compilation.getAssets() : [];
                 for (const asset of assets){
@@ -9308,7 +6276,7 @@ class ValidateContentScriptSyntax {
                         new Function(source);
                     } catch (error) {
                         if (error?.name !== 'SyntaxError') continue;
-                        const err = new core_WebpackError([
+                        const err = new 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',
@@ -9336,7 +6304,8 @@ class ScriptsPlugin {
         if (!hasValidManifest) return;
         new AddScripts({
             manifestPath: this.manifestPath,
-            includeList: this.includeList || {}
+            includeList: this.includeList || {},
+            browser: this.browser
         }).apply(compiler);
         new TraceRuntimeLoadedFiles({
             manifestPath: this.manifestPath
@@ -9350,16 +6319,6 @@ class ScriptsPlugin {
         }).apply(compiler);
         if ('production' === compiler.options.mode) new AddPublicPathRuntimeModule().apply(compiler);
         new ValidateContentScriptSyntax().apply(compiler);
-        if ('production' !== compiler.options.mode && 'true' !== process.env.EXTENSION_NO_RELOAD) {
-            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);
-        }
     }
 }
 function manifestNotFoundMessageOnly(absPath) {
@@ -9611,7 +6570,7 @@ class LocalesPlugin {
         compiler.hooks.thisCompilation.tap('locales:module', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'locales:module',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>{
                 if (!__rspack_external_fs.existsSync(this.manifestPath)) {
                     const ErrorConstructor = compiler?.rspack?.WebpackError || Error;
@@ -9687,7 +6646,7 @@ function validateJsonAsset(compilation, feature, filePath, buf) {
     try {
         parsed = JSON.parse(stripBom(buf.toString('utf-8')));
     } catch (e) {
-        const err = new core_WebpackError(invalidJsonSyntax(feature, filePath, String(e?.message || e)));
+        const err = new WebpackError(invalidJsonSyntax(feature, filePath, String(e?.message || e)));
         err.file = filePath;
         err.name = 'JSONInvalidSyntax';
         compilation.errors.push(err);
@@ -9695,7 +6654,7 @@ function validateJsonAsset(compilation, feature, filePath, buf) {
     }
     if (feature.startsWith('declarative_net_request')) {
         if (!Array.isArray(parsed)) {
-            const err = new core_WebpackError(invalidRulesetStructure(feature, filePath));
+            const err = new WebpackError(invalidRulesetStructure(feature, filePath));
             err.file = filePath;
             err.name = 'DNRInvalidRuleset';
             compilation.errors.push(err);
@@ -9703,7 +6662,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 core_WebpackError(invalidManagedSchemaStructure(feature, filePath));
+            const err = new WebpackError(invalidManagedSchemaStructure(feature, filePath));
             err.file = filePath;
             err.name = 'ManagedSchemaInvalid';
             compilation.errors.push(err);
@@ -9745,7 +6704,7 @@ function processJsonAssets(compilation, manifestPath, includeList) {
                 const isPublicRoot = rawRef.startsWith('/') && !__rspack_external_path.isAbsolute(rawRef);
                 const outputRoot = compilation?.options?.output?.path || '';
                 const displayPath = isPublicRoot ? __rspack_external_path.join(outputRoot, rawRef.slice(1)) : abs;
-                const notFound = new core_WebpackError(jsonMissingFile(feature, displayPath, {
+                const notFound = new WebpackError(jsonMissingFile(feature, displayPath, {
                     publicRootHint: isPublicRoot
                 }));
                 notFound.name = 'JSONMissingFile';
@@ -9827,7 +6786,7 @@ class JsonPlugin {
         compiler.hooks.thisCompilation.tap('json:module', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'json:module',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>{
                 processJsonAssets(compilation, this.manifestPath, this.includeList || {});
                 trackJsonDependencies(compilation, this.manifestPath, this.includeList || {});
@@ -9887,14 +6846,6 @@ function normalizeIconIncludeKeys(icons) {
     else out[key] = value;
     return out;
 }
-function emit_file_reportToCompilation(compilation, message, compiler, opts) {
-    const ErrorConstructor = compiler?.rspack?.WebpackError || Error;
-    const errObj = new ErrorConstructor(message);
-    const arrKey = opts?.type === 'warning' ? 'warnings' : 'errors';
-    if (opts?.file) errObj.file = opts.file;
-    if (!compilation[arrKey]) compilation[arrKey] = [];
-    compilation[arrKey].push(errObj);
-}
 class EmitFile {
     manifestPath;
     includeList;
@@ -9906,7 +6857,7 @@ class EmitFile {
         compiler.hooks.thisCompilation.tap('icons:emit-file', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'icons:emit-file',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
+                stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
             }, ()=>{
                 if (compilation.errors.length > 0) return;
                 const iconFields = this.includeList || {};
@@ -9967,12 +6918,9 @@ class EmitFile {
                             const displayPath = !__rspack_external_path.isAbsolute(entry) && isPublicRoot ? __rspack_external_path.join(projectPath, 'public', entry.slice(1)) : __rspack_external_path.isAbsolute(entry) ? entry : __rspack_external_path.join(projectPath, entry);
                             const isDefaultIconFamily = ('action' === group || 'browser_action' === group || 'page_action' === group || 'sidebar_action' === group) && 'default_icon' === sub;
                             const severity = 'icons' === group || isDefaultIconFamily ? 'error' : 'warning';
-                            emit_file_reportToCompilation(compilation, iconsMissingFile(feature, displayPath, {
+                            reportToCompilation(compilation, compiler, iconsMissingFile(feature, displayPath, {
                                 publicRootHint: isPublicRoot
-                            }), compiler, {
-                                type: severity,
-                                file: 'manifest.json'
-                            });
+                            }), severity, 'manifest.json');
                             missingCount++;
                             continue;
                         }
@@ -10023,7 +6971,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: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+                stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>{
                 if (compilation.errors?.length) return;
                 const iconFields = this.includeList || {};
@@ -10155,7 +7103,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(unixify(files[j]));
+        for(let j = 0; j < files.length; j++)normalizedFiles.push(paths_unixify(files[j]));
         entryImports[name] = normalizedFiles;
     }
     return entryImports;
@@ -10169,7 +7117,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: core_Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+                stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
             }, ()=>{
                 const entryImports = collectContentScriptEntryImports(compilation, this.includeList);
                 const shared = getSharedFor(compilation);
@@ -10253,7 +7201,7 @@ class ManifestFieldsChangeDetector {
         });
         const scriptsMap = fields.scripts || {};
         const scripts = flattenValues(scriptsMap);
-        const bridgeScripts = AddContentScriptWrapper.getBridgeScripts(this.manifestPath);
+        const bridgeScripts = AddContentScriptWrapper.getBridgeScripts(this.manifestPath, this.browser);
         for (const val of Object.values(bridgeScripts))if (Array.isArray(val)) scripts.push(...val.filter(Boolean));
         else if (val) scripts.push(val);
         const html = fields.html || {};
@@ -10306,7 +7254,7 @@ class ManifestFieldsChangeDetector {
         compiler.hooks.thisCompilation.tap('manifest:fields-change-detector', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'manifest:fields-change-detector',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY
+                stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY
             }, ()=>{
                 this.emitErrors(compilation);
                 this.pending = {};
@@ -10317,21 +7265,21 @@ class ManifestFieldsChangeDetector {
         if (this.pending.scripts) {
             const p = this.pending.scripts;
             const msg = serverRestartRequiredFromManifestError(p.pathAfter || '', p.pathBefore || '');
-            const err = new core_WebpackError(msg);
+            const err = new 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 core_WebpackError(msg);
+            const err = new 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 core_WebpackError(msg);
+            const err = new WebpackError(msg);
             err.file = 'manifest.json';
             compilation.errors.push(err);
         }
@@ -10343,13 +7291,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 core_WebpackError(lines.join('\n'));
+            const err = new WebpackError(lines.join('\n'));
             err.file = 'manifest.json';
             compilation.errors.push(err);
         }
     }
 }
-class plugin_web_extension_WebExtensionPlugin {
+class WebExtensionPlugin {
     static name = 'plugin-extension';
     manifestPath;
     browser;
@@ -10678,7 +7626,7 @@ function webpackConfig(projectStructure, devOptions) {
     } catch (error) {
         throw new Error(manifestInvalidJson(manifestPath, error));
     }
-    const manifest = filterKeysForThisBrowser(rawManifest, devOptions.browser);
+    const manifest = manifest_utils_filterKeysForThisBrowser(rawManifest, devOptions.browser);
     const primaryExtensionOutputDir = asAbsolute(__rspack_external_path.isAbsolute(devOptions.output.path) ? devOptions.output.path : __rspack_external_path.resolve(packageJsonDir, devOptions.output.path));
     const companionUnpackedExtensionDirs = resolveCompanionExtensionDirs({
         projectRoot: packageJsonDir,
@@ -10733,7 +7681,11 @@ function webpackConfig(projectStructure, devOptions) {
             browser: devOptions.browser,
             polyfill: devOptions.polyfill
         }),
-        new plugin_web_extension_WebExtensionPlugin({
+        new WebExtensionPlugin({
+            manifestPath,
+            browser: devOptions.browser
+        }),
+        new ReloadPlugin({
             manifestPath,
             browser: devOptions.browser
         }),
@@ -10799,6 +7751,7 @@ function webpackConfig(projectStructure, devOptions) {
         packageJsonDir,
         browser: devOptions.browser,
         mode: devOptions.mode,
+        command: devOptions.metadataCommand,
         outputPath: primaryExtensionOutputDir,
         manifestPath,
         port: devOptions.port,