extension-develop 3.17.0 → 3.18.0

package/dist/0~rspack-config.mjs

@@ -1,7 +1,7 @@
 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, WebpackError as core_WebpackError, rspack, sources as core_sources } from "@rspack/core";
+import core, { Compilation as core_Compilation, DefinePlugin, ProvidePlugin, WebpackError as core_WebpackError, rspack, sources as core_sources } from "@rspack/core";
 import pintor from "pintor";
 import case_sensitive_paths_webpack_plugin from "case-sensitive-paths-webpack-plugin";
 import adm_zip from "adm-zip";
@@ -11,10 +11,10 @@ import { pathToFileURL } from "url";
 import { getManifestFieldsData } from "browser-extension-manifest-fields";
 import content_security_policy_parser from "content-security-policy-parser";
 import path_0 from "path";
-import fs_0 from "fs";
+import fs from "fs";
 import { getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName, EXTENSIONJS_CONTENT_SCRIPT_LAYER } from "./526.mjs";
-import { isUsingTypeScript, jsFrameworksIntegrationsEnabled, ensureOptionalContractModuleLoaded, resolveDevelopInstallRoot, isUsingCustomLoader, resolveOptionalDependencySync, loadOptionalContractModuleWithoutInstall, isUsingIntegration as messages_isUsingIntegration, resolveOptionalContractPackageWithoutInstall, jsFrameworksHmrSummary, parseJsonSafe, getUserTypeScriptConfigFile, jsFrameworksConfigsDetected, hasDependency, resolveDevelopDistFile, optional_deps_resolver_ensureOptionalContractPackageResolved } from "./962.mjs";
-import { debugExtensionsToLoad, treeWithSourceFiles, getDirs, bundlerFatalError, bundlerRecompiling, asAbsolute, browserRunnerDisabled, packagingDistributionFiles, PlaywrightPlugin, debugContextPath, noEntrypointsDetected, packagingSourceFiles, debugBrowser, spacerLine, debugOutputPath, messages_ready, treeWithSourceAndDistFiles, treeWithDistFilesbrowser, getSpecialFoldersDataForCompiler, computeExtensionsToLoad, noCompanionExtensionsResolved } from "./946.mjs";
+import { isUsingTypeScript, jsFrameworksIntegrationsEnabled, ensureTypeScriptConfig, ensureOptionalContractModuleLoaded, resolveDevelopInstallRoot, isUsingCustomLoader, resolveOptionalDependencySync, loadOptionalContractModuleWithoutInstall, isUsingIntegration as messages_isUsingIntegration, resolveOptionalContractPackageWithoutInstall, jsFrameworksHmrSummary, parseJsonSafe, getUserTypeScriptConfigFile, jsFrameworksConfigsDetected, hasDependency, resolveDevelopDistFile, optional_deps_resolver_ensureOptionalContractPackageResolved } from "./962.mjs";
+import { debugExtensionsToLoad, treeWithSourceFiles, getDirs, bundlerFatalError, bundlerRecompiling, asAbsolute, browserRunnerDisabled, packagingDistributionFiles, PlaywrightPlugin, resolveCompanionExtensionDirs, debugContextPath, noEntrypointsDetected, packagingSourceFiles, debugBrowser, spacerLine, debugOutputPath, messages_ready, manifestInvalidJson, treeWithSourceAndDistFiles, treeWithDistFilesbrowser, getSpecialFoldersDataForCompiler, computeExtensionsToLoad, noCompanionExtensionsResolved } from "./946.mjs";
 import { scrubBrand, makeSanitizedConsole } from "./0~branding.mjs";
 import { findNearestPackageJsonSync, backgroundIsRequiredMessageOnly } from "./314.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
@@ -37,7 +37,7 @@ function filterKeysForThisBrowser(manifest, browser) {
     const GECKO_BASED_BROWSERS = [
         'firefox'
     ];
-    const isChromiumTarget = CHROMIUM_BASED_BROWSERS.includes(browser) || String(browser).includes('chromium');
+    const isChromiumTarget = CHROMIUM_BASED_BROWSERS.includes(browser) || String(browser).includes('chromium') || 'safari' === browser || 'webkit-based' === browser || String(browser).includes('webkit');
     const isGeckoTarget = GECKO_BASED_BROWSERS.includes(browser) || String(browser).includes('gecko');
     const chromiumPrefixes = new Set([
         'chromium',
@@ -135,68 +135,6 @@ function isSubPath(resourcePath, directoryPath) {
     const dir = normalizePath(directoryPath).replace(/\/+$/, '');
     return resource === dir || resource.startsWith(`${dir}/`);
 }
-function isDir(p) {
-    try {
-        return __rspack_external_fs.existsSync(p) && __rspack_external_fs.statSync(p).isDirectory();
-    } catch  {
-        return false;
-    }
-}
-function isFile(p) {
-    try {
-        return __rspack_external_fs.existsSync(p) && __rspack_external_fs.statSync(p).isFile();
-    } catch  {
-        return false;
-    }
-}
-function toAbs(projectRoot, p) {
-    return __rspack_external_path.isAbsolute(p) ? p : __rspack_external_path.resolve(projectRoot, p);
-}
-function isValidExtensionRoot(dir) {
-    if (!isDir(dir)) return false;
-    return isFile(__rspack_external_path.join(dir, 'manifest.json'));
-}
-function resolveCompanionExtensionDirs(opts) {
-    const { projectRoot, config } = opts;
-    const explicitPaths = [];
-    let scanDir;
-    if (Array.isArray(config)) explicitPaths.push(...config.filter((p)=>'string' == typeof p));
-    else if (config && 'object' == typeof config) {
-        if (Array.isArray(config.paths)) explicitPaths.push(...config.paths.filter((p)=>'string' == typeof p));
-        if ('string' == typeof config.dir && config.dir.trim().length > 0) scanDir = config.dir.trim();
-    }
-    const found = [];
-    for (const p of explicitPaths){
-        const abs = toAbs(projectRoot, p);
-        if (isValidExtensionRoot(abs)) found.push(abs);
-    }
-    if (scanDir) {
-        const absScan = toAbs(projectRoot, scanDir);
-        if (isDir(absScan)) {
-            let entries = [];
-            try {
-                entries = __rspack_external_fs.readdirSync(absScan, {
-                    withFileTypes: true
-                });
-            } catch  {
-                entries = [];
-            }
-            for (const ent of entries){
-                if (!ent.isDirectory()) continue;
-                if (ent.name.startsWith('.')) continue;
-                const candidate = __rspack_external_path.join(absScan, ent.name);
-                if (isValidExtensionRoot(candidate)) found.push(candidate);
-            }
-        }
-    }
-    const unique = [];
-    const seen = new Set();
-    for (const p of found)if (!seen.has(p)) {
-        seen.add(p);
-        unique.push(p);
-    }
-    return unique;
-}
 function serverRestartRequiredFromSpecialFolderMessageOnly(addingOrRemoving, folder, typeOfAsset) {
     return `${pintor.red('ERROR')} in ${pintor.yellow('manifest.json')} entrypoint: ${addingOrRemoving} ${pintor.yellow(typeOfAsset)} in ${pintor.underline(folder + '/')} requires a dev server restart to apply changes.`;
 }
@@ -337,8 +275,7 @@ function checkManifestInPublic(compilation, publicDir) {
     try {
         const manifestInPublic = __rspack_external_path.join(publicDir, 'manifest.json');
         if (__rspack_external_fs.existsSync(manifestInPublic)) {
-            const ErrCtor = compilation.compiler.webpack?.WebpackError;
-            const err = new ErrCtor(`manifest.json must not be placed under public/: ${manifestInPublic}`);
+            const err = new core_WebpackError(`manifest.json must not be placed under public/: ${manifestInPublic}`);
             err.file = 'manifest.json';
             compilation.errors.push(err);
         }
@@ -363,6 +300,9 @@ class SpecialFoldersPlugin {
                     checkManifestInPublic(compilation, publicDir);
                 });
             });
+            const copyIgnore = [
+                'manifest.json'
+            ];
             new rspack.CopyRspackPlugin({
                 patterns: [
                     {
@@ -370,14 +310,12 @@ class SpecialFoldersPlugin {
                         to: '.',
                         noErrorOnMissing: true,
                         globOptions: {
-                            ignore: [
-                                'manifest.json'
-                            ]
+                            ignore: copyIgnore
                         }
                     }
                 ]
             }).apply(compiler);
-            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(specialFoldersSetupSummary(true, true, 1));
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(specialFoldersSetupSummary(true, true, copyIgnore.length));
         }
         if ('development' === compiler.options.mode) {
             if (compiler.options.watchOptions) new WarnUponFolderChanges().apply(compiler);
@@ -1038,6 +976,10 @@ function getManifestContent(compilation, manifestPath) {
         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);
     }
 }
@@ -1060,13 +1002,27 @@ function manifest_filterKeysForThisBrowser(manifest, browser) {
         'gecko',
         'firefox'
     ]);
-    const patchedManifest = JSON.parse(JSON.stringify(manifest), function(key, value) {
-        const indexOfColon = key.indexOf(':');
-        if (-1 === indexOfColon) return value;
-        const prefix = key.substring(0, indexOfColon);
-        if (prefix === browser || isChromiumTarget && chromiumPrefixes.has(prefix) || isGeckoTarget && geckoPrefixes.has(prefix)) this[key.substring(indexOfColon + 1)] = value;
-    });
-    return patchedManifest;
+    const prefixMatchesTarget = (prefix)=>prefix === browser || isChromiumTarget && chromiumPrefixes.has(prefix) || isGeckoTarget && geckoPrefixes.has(prefix);
+    const resolve = (node)=>{
+        if (Array.isArray(node)) return node.map((item)=>resolve(item));
+        if (node && 'object' == typeof node) {
+            const result = {};
+            const prefixedMatches = {};
+            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);
+                if (prefixMatchesTarget(prefix)) prefixedMatches[key.substring(indexOfColon + 1)] = resolve(value);
+            }
+            for (const [strippedKey, value] of Object.entries(prefixedMatches))result[strippedKey] = value;
+            return result;
+        }
+        return node;
+    };
+    return resolve(manifest);
 }
 function buildCanonicalManifest(manifestPath, manifest, browser) {
     const filteredManifest = manifest_filterKeysForThisBrowser(manifest, browser);
@@ -1075,6 +1031,15 @@ function buildCanonicalManifest(manifestPath, manifest, browser) {
         ...JSON.parse(getManifestOverrides(manifestPath, filteredManifest))
     };
 }
+var env_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+function resolveProcessShim() {
+    const candidate = __rspack_external_path.join(env_dirname, '..', 'runtime', 'process-shim.cjs');
+    try {
+        return __rspack_external_fs.existsSync(candidate) ? candidate : void 0;
+    } catch  {
+        return;
+    }
+}
 function findNearestWorkspaceRoot(startDir) {
     let current = __rspack_external_path.isAbsolute(startDir) ? __rspack_external_path.normalize(startDir) : __rspack_external_path.resolve(startDir);
     while(true){
@@ -1120,8 +1085,7 @@ class EnvPlugin {
             `.env.${this.browser}`,
             `.env.${mode}`,
             '.env.local',
-            '.env',
-            '.env.example'
+            '.env'
         ];
         const { envPath, defaultsPath } = resolveEnvPaths(projectPath, envFiles);
         if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(envSelectedFile(envPath));
@@ -1143,8 +1107,6 @@ class EnvPlugin {
             obj[`import.meta.env.${key}`] = JSON.stringify(combinedVars[key]);
             return obj;
         }, {});
-        filteredEnvVars['process.env'] = JSON.stringify({});
-        filteredEnvVars['process'] = '({env: {}})';
         filteredEnvVars['process.env.EXTENSION_PUBLIC_BROWSER'] = JSON.stringify(this.browser);
         filteredEnvVars['import.meta.env.EXTENSION_PUBLIC_BROWSER'] = JSON.stringify(this.browser);
         filteredEnvVars['process.env.EXTENSION_PUBLIC_MODE'] = JSON.stringify(mode);
@@ -1159,7 +1121,15 @@ class EnvPlugin {
         filteredEnvVars['import.meta.env.MODE'] = JSON.stringify(mode);
         const injectedCount = Object.keys(filteredEnvVars).filter((k)=>k.startsWith('process.env.EXTENSION_PUBLIC_')).length;
         if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(envInjectedPublicVars(injectedCount));
+        const processShim = resolveProcessShim();
+        if (!processShim) {
+            filteredEnvVars['process.env'] = '{}';
+            filteredEnvVars['process'] = '({env:{},argv:[],platform:"browser",browser:true,versions:{},nextTick:function(cb){Promise.resolve().then(function(){cb()})}})';
+        }
         new DefinePlugin(filteredEnvVars).apply(compiler);
+        if (processShim) new ProvidePlugin({
+            process: processShim
+        }).apply(compiler);
         compiler.hooks.thisCompilation.tap('manifest:update-manifest', (compilation)=>{
             compilation.hooks.processAssets.tap({
                 name: 'env:module',
@@ -1201,7 +1171,6 @@ class EnvPlugin {
         });
     }
 }
-const rmdirSync = __rspack_external_fs.rmdirSync;
 class CleanDistFolderPlugin {
     options;
     constructor(options){
@@ -1214,25 +1183,21 @@ class CleanDistFolderPlugin {
             const removedCount = countFilesRecursively(distPath);
             if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(cleanDistStarting(distPath));
             try {
-                if (__rspack_external_fs.rmSync) __rspack_external_fs.rmSync(distPath, {
+                __rspack_external_fs.rmSync(distPath, {
                     recursive: true,
                     force: true
                 });
-                else rmdirSync(distPath, {
-                    recursive: true
-                });
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(cleanDistRemovedSummary(removedCount, distPath));
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) logger.info('[CleanDistFolderPlugin] Removed old hot-update files before compilation.');
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
+                    console.log(cleanDistRemovedSummary(removedCount, distPath));
+                    logger.info('[CleanDistFolderPlugin] Removed old hot-update files before compilation.');
+                }
             } catch (error) {
-                if ('win32' === process.platform && /EBUSY|EPERM/i.test(String(error?.code || error?.message))) setTimeout(()=>{
+                if ('win32' === process.platform && /EBUSY|EPERM/i.test(String(error?.code || error?.message))) return void setTimeout(()=>{
                     try {
-                        if (__rspack_external_fs.rmSync) __rspack_external_fs.rmSync(distPath, {
+                        __rspack_external_fs.rmSync(distPath, {
                             recursive: true,
                             force: true
                         });
-                        else rmdirSync(distPath, {
-                            recursive: true
-                        });
                     } catch  {}
                 }, 100);
                 logger.error(`[CleanDistFolderPlugin] Failed to remove hot-update files: ${error.message}`);
@@ -1516,15 +1481,18 @@ class CompilationPlugin {
         ] : existing ? [
             existing
         ] : [];
+        const SUPPRESSED_THIRD_PARTY_WARNINGS = [
+            'Critical dependency: the request of a dependency is an expression',
+            'Critical dependency: require function is used in a way in which dependencies cannot be statically extracted',
+            'Accessing import.meta directly is unsupported'
+        ];
         ignoreWarnings.push((warning)=>{
             try {
                 const message = String(warning && (warning.message || warning) || '');
-                const modulePath = warning && warning.module && (warning.module.resource || warning.module.userRequest) || '';
-                if (message.includes('Critical dependency: the request of a dependency is an expression') && /[\\\/]@ffmpeg[\\\/]ffmpeg[\\\/]dist[\\\/]esm[\\\/](classes|worker)\.js$/.test(modulePath)) return true;
-                if (message.includes('Critical dependency: the request of a dependency is an expression') && /[\\\/]@techstark[\\\/]opencv-js[\\\/]dist[\\\/]opencv\.js$/.test(modulePath)) return true;
-                if (message.includes('Critical dependency: the request of a dependency is an expression') && /[\\\/]@sqlite\.org[\\\/]sqlite-wasm[\\\/]dist[\\\/]sqlite3-worker1\.mjs$/.test(modulePath)) return true;
-                if (message.includes('Critical dependency: require function is used in a way in which dependencies cannot be statically extracted') && /[\\\/]@vue[\\\/]compiler-sfc[\\\/]dist[\\\/]compiler-sfc\.esm-browser\.js$/.test(modulePath)) return true;
-                return message.includes('Accessing import.meta directly is unsupported') && /[\\\/]@huggingface[\\\/]transformers[\\\/].*transformers\.web\.js$/.test(modulePath);
+                const modulePath = String(warning && warning.module && (warning.module.resource || warning.module.userRequest) || '');
+                const isThirdParty = /[\\/]node_modules[\\/]/.test(modulePath);
+                if (!isThirdParty) return false;
+                return SUPPRESSED_THIRD_PARTY_WARNINGS.some((needle)=>message.includes(needle));
             } catch  {
                 return false;
             }
@@ -1571,9 +1539,9 @@ function cssIntegrationsEnabled(integrations) {
     const list = integrations.length > 0 ? integrations.map((n)=>pintor.yellow(n)).join(', ') : pintor.gray('none');
     return `${pintor.gray('⏵⏵⏵')} CSS: Integrations enabled (${pintor.gray(String(integrations.length))}) ${list}`;
 }
-function cssConfigsDetected(postcssConfig, stylelintConfig, tailwindConfig, browserslistSource) {
+function cssConfigsDetected(postcssConfig, tailwindConfig, browserslistSource) {
     const fmt = (v)=>v ? pintor.underline(v) : pintor.gray('none');
-    return `${pintor.gray('⏵⏵⏵')} CSS: Configs\n${pintor.gray('POSTCSS')} ${fmt(postcssConfig)}\n${pintor.gray('STYLELINT')} ${fmt(stylelintConfig)}\n${pintor.gray('TAILWIND')} ${fmt(tailwindConfig)}\n${pintor.gray('BROWSERSLIST')} ${fmt(browserslistSource)}`;
+    return `${pintor.gray('⏵⏵⏵')} CSS: Configs\n${pintor.gray('POSTCSS')} ${fmt(postcssConfig)}\n${pintor.gray('TAILWIND')} ${fmt(tailwindConfig)}\n${pintor.gray('BROWSERSLIST')} ${fmt(browserslistSource)}`;
 }
 function isUsingIntegration(name) {
     return `${pintor.gray('⏵⏵⏵')} Using ${pintor.brightBlue(name)}...`;
@@ -1642,48 +1610,12 @@ function createSassLoaderOptions(projectPath, mode) {
     return base;
 }
 async function maybeUseSass(projectPath) {
-    if (!isUsingSass(projectPath)) return [];
-    const sassLoaderPath = await optional_deps_resolver_ensureOptionalContractPackageResolved({
+    if (!isUsingSass(projectPath)) return;
+    await optional_deps_resolver_ensureOptionalContractPackageResolved({
         contractId: 'sass',
         projectPath,
         dependencyId: 'sass-loader'
     });
-    return [
-        {
-            test: /\.(sass|scss)$/,
-            exclude: /\.module\.(sass|scss)$/,
-            use: [
-                {
-                    loader: sassLoaderPath,
-                    options: createSassLoaderOptions(projectPath, 'development')
-                }
-            ]
-        },
-        {
-            test: /\.module\.(sass|scss)$/,
-            use: [
-                {
-                    loader: sassLoaderPath,
-                    options: createSassLoaderOptions(projectPath, 'development')
-                }
-            ]
-        }
-    ];
-}
-function isContentScriptEntry(absolutePath, manifestPath, projectPath) {
-    if (!absolutePath || !manifestPath || !projectPath) return false;
-    if (!__rspack_external_fs.existsSync(manifestPath)) return false;
-    const manifest = parseJsonSafe(__rspack_external_fs.readFileSync(manifestPath, 'utf8'));
-    const scriptsDir = __rspack_external_path.resolve(projectPath, "scripts");
-    const absPathNormalized = __rspack_external_path.resolve(absolutePath);
-    const relToScripts = __rspack_external_path.relative(scriptsDir, absPathNormalized);
-    const isScriptsFolderScript = relToScripts && !relToScripts.startsWith('..') && !__rspack_external_path.isAbsolute(relToScripts);
-    if (isScriptsFolderScript) return true;
-    for (const content of manifest.content_scripts || [])if (content.js?.length) for (const js of content.js){
-        const contentPath = __rspack_external_path.resolve(__rspack_external_path.dirname(manifestPath), js);
-        if (contentPath === absPathNormalized) return true;
-    }
-    return false;
 }
 let less_userMessageDelivered = false;
 function isUsingLess(projectPath) {
@@ -1696,88 +1628,44 @@ function isUsingLess(projectPath) {
     }
     return false;
 }
-async function maybeUseLess(projectPath, manifestPath) {
-    const resolvedManifestPath = manifestPath || __rspack_external_path.join(projectPath, 'manifest.json');
-    if (!isUsingLess(projectPath)) return [];
-    const lessLoaderPath = await optional_deps_resolver_ensureOptionalContractPackageResolved({
+async function maybeUseLess(projectPath) {
+    if (!isUsingLess(projectPath)) return;
+    await optional_deps_resolver_ensureOptionalContractPackageResolved({
         contractId: 'less',
         projectPath,
         dependencyId: 'less-loader'
     });
-    return [
-        {
-            test: /\.less$/,
-            exclude: /\.module\.less$/,
-            use: [
-                {
-                    loader: lessLoaderPath,
-                    options: {
-                        sourceMap: true
-                    }
-                }
-            ]
-        },
-        {
-            test: /\.module\.less$/,
-            use: [
-                {
-                    loader: lessLoaderPath,
-                    options: {
-                        sourceMap: true
-                    }
-                }
-            ]
-        },
-        {
-            test: /\.less$/,
-            exclude: /\.module\.less$/,
-            type: 'asset/resource',
-            generator: {
-                filename: "content_scripts/[name].[contenthash:8].css"
-            },
-            issuer: (issuer)=>isContentScriptEntry(issuer, resolvedManifestPath, projectPath)
-        }
-    ];
 }
-function getStylelintConfigFile(projectPath) {
-    const stylelintConfigJs = __rspack_external_path.join(projectPath, 'stylelint.config.js');
-    const stylelintConfigDotJs = __rspack_external_path.join(projectPath, '.stylelintrc.js');
-    const stylelintConfigMjs = __rspack_external_path.join(projectPath, 'stylelint.config.mjs');
-    const stylelintConfigDotMjs = __rspack_external_path.join(projectPath, '.stylelintrc.mjs');
-    const stylelintConfigCjs = __rspack_external_path.join(projectPath, 'stylelint.config.cjs');
-    const stylelintConfigDotCjs = __rspack_external_path.join(projectPath, '.stylelintrc.cjs');
-    const stylelintConfigJson = __rspack_external_path.join(projectPath, '.stylelintrc.json');
-    const stylelintConfigDotJson = __rspack_external_path.join(projectPath, '.stylelintrc');
-    const stylelintConfigYml = __rspack_external_path.join(projectPath, '.stylelintrc.yml');
-    const stylelintConfigDotYml = __rspack_external_path.join(projectPath, '.stylelintrc.yaml');
-    if (__rspack_external_fs.existsSync(stylelintConfigJs)) return stylelintConfigJs;
-    if (__rspack_external_fs.existsSync(stylelintConfigDotJs)) return stylelintConfigDotJs;
-    if (__rspack_external_fs.existsSync(stylelintConfigMjs)) return stylelintConfigMjs;
-    if (__rspack_external_fs.existsSync(stylelintConfigDotMjs)) return stylelintConfigDotMjs;
-    if (__rspack_external_fs.existsSync(stylelintConfigCjs)) return stylelintConfigCjs;
-    if (__rspack_external_fs.existsSync(stylelintConfigDotCjs)) return stylelintConfigDotCjs;
-    if (__rspack_external_fs.existsSync(stylelintConfigJson)) return stylelintConfigJson;
-    if (__rspack_external_fs.existsSync(stylelintConfigDotJson)) return stylelintConfigDotJson;
-    if (__rspack_external_fs.existsSync(stylelintConfigYml)) return stylelintConfigYml;
-    if (__rspack_external_fs.existsSync(stylelintConfigDotYml)) return stylelintConfigDotYml;
-}
-let stylelint_userMessageDelivered = false;
-function stylelint_isUsingStylelint(projectPath) {
-    const packageJsonPath = __rspack_external_path.join(projectPath, 'package.json');
-    if (!__rspack_external_fs.existsSync(packageJsonPath)) return false;
-    const configFile = getStylelintConfigFile(projectPath);
-    const isUsingStylelint = !!configFile;
-    if (isUsingStylelint) {
-        if (!stylelint_userMessageDelivered) {
-            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor.brightMagenta('⏵⏵⏵ Author says')} ${isUsingIntegration('Stylelint')}`);
-            stylelint_userMessageDelivered = true;
-        }
-    }
-    return isUsingStylelint;
+const indexCache = new Map();
+function getContentScriptIndex(manifestPath, projectPath) {
+    const cacheKey = `${manifestPath}::${projectPath}`;
+    let mtimeMs = -1;
+    try {
+        mtimeMs = __rspack_external_fs.statSync(manifestPath).mtimeMs;
+    } catch  {}
+    const cached = indexCache.get(cacheKey);
+    if (cached && (mtimeMs < 0 || cached.mtimeMs === mtimeMs)) return cached;
+    const manifest = parseJsonSafe(__rspack_external_fs.readFileSync(manifestPath, 'utf8'));
+    const manifestDir = __rspack_external_path.dirname(manifestPath);
+    const contentPaths = new Set();
+    for (const content of manifest.content_scripts || [])if (content.js?.length) for (const js of content.js)contentPaths.add(__rspack_external_path.resolve(manifestDir, js));
+    const index = {
+        mtimeMs,
+        scriptsDir: __rspack_external_path.resolve(projectPath, "scripts"),
+        contentPaths
+    };
+    indexCache.set(cacheKey, index);
+    return index;
 }
-async function maybeUseStylelint(projectPath) {
-    stylelint_isUsingStylelint(projectPath);
-    return [];
+function isContentScriptEntry(absolutePath, manifestPath, projectPath) {
+    if (!absolutePath || !manifestPath || !projectPath) return false;
+    if (!__rspack_external_fs.existsSync(manifestPath)) return false;
+    const { scriptsDir, contentPaths } = getContentScriptIndex(manifestPath, projectPath);
+    const absPathNormalized = __rspack_external_path.resolve(absolutePath);
+    const relToScripts = __rspack_external_path.relative(scriptsDir, absPathNormalized);
+    const isScriptsFolderScript = relToScripts && !relToScripts.startsWith('..') && !__rspack_external_path.isAbsolute(relToScripts);
+    if (isScriptsFolderScript) return true;
+    return contentPaths.has(absPathNormalized);
 }
 let tailwind_userMessageDelivered = false;
 function tailwind_isUsingTailwind(projectPath) {
@@ -1791,12 +1679,16 @@ function tailwind_isUsingTailwind(projectPath) {
     return isUsingTailwind;
 }
 function getTailwindConfigFile(projectPath) {
-    const configFileMjs = __rspack_external_path.join(projectPath, 'tailwind.config.mjs');
-    const configFileCjs = __rspack_external_path.join(projectPath, 'tailwind.config.cjs');
-    const configFileJs = __rspack_external_path.join(projectPath, 'tailwind.config.js');
-    if (__rspack_external_fs.existsSync(configFileMjs)) return configFileMjs;
-    if (__rspack_external_fs.existsSync(configFileCjs)) return configFileCjs;
-    if (__rspack_external_fs.existsSync(configFileJs)) return configFileJs;
+    const candidates = [
+        'tailwind.config.mjs',
+        'tailwind.config.cjs',
+        'tailwind.config.ts',
+        'tailwind.config.js'
+    ];
+    for (const candidate of candidates){
+        const configPath = __rspack_external_path.join(projectPath, candidate);
+        if (__rspack_external_fs.existsSync(configPath)) return configPath;
+    }
 }
 let postcss_userMessageDelivered = false;
 const postCssConfigFiles = [
@@ -2127,9 +2019,9 @@ async function commonStyleLoaders(projectPath, opts) {
 function resolvePreprocessorLoader(loader, projectPath) {
     return resolveOptionalDependencySync(loader, projectPath);
 }
-async function cssInContentScriptLoader(projectPath, manifestPath, mode, usage = {}) {
+async function buildCssRules(projectPath, mode, usage, opts) {
     const { useSass = true, useLess = true } = usage;
-    const isContentScript = (issuer)=>isContentScriptEntry(issuer, manifestPath, projectPath);
+    const { nonModuleType, issuer } = opts;
     const fileTypes = [
         {
             test: /\.module\.css$/,
@@ -2139,14 +2031,14 @@ async function cssInContentScriptLoader(projectPath, manifestPath, mode, usage =
         {
             test: /\.css$/,
             exclude: /\.module\.css$/,
-            type: 'asset/inline',
+            type: nonModuleType,
             loader: null
         },
         ...useSass ? [
             {
                 test: /\.(sass|scss)$/,
                 exclude: /\.module\.(sass|scss)$/,
-                type: 'asset/inline',
+                type: nonModuleType,
                 loader: 'sass-loader'
             },
             {
@@ -2159,7 +2051,7 @@ async function cssInContentScriptLoader(projectPath, manifestPath, mode, usage =
             {
                 test: /\.less$/,
                 exclude: /\.module\.less$/,
-                type: 'asset/inline',
+                type: nonModuleType,
                 loader: 'less-loader'
             },
             {
@@ -2169,7 +2061,7 @@ async function cssInContentScriptLoader(projectPath, manifestPath, mode, usage =
             }
         ] : []
     ];
-    const rules = await Promise.all(fileTypes.map(async ({ test, exclude, type, loader })=>{
+    return Promise.all(fileTypes.map(async ({ test, exclude, type, loader })=>{
         const use = loader ? await commonStyleLoaders(projectPath, {
             mode: mode,
             loader: resolvePreprocessorLoader(loader, projectPath),
@@ -2183,76 +2075,22 @@ async function cssInContentScriptLoader(projectPath, manifestPath, mode, usage =
             test,
             exclude,
             type,
-            issuer: isContentScript,
+            issuer,
             use
         };
     }));
-    return rules;
 }
-function css_in_html_loader_resolvePreprocessorLoader(loader, projectPath) {
-    return resolveOptionalDependencySync(loader, projectPath);
+async function cssInContentScriptLoader(projectPath, manifestPath, mode, usage = {}) {
+    return buildCssRules(projectPath, mode, usage, {
+        nonModuleType: 'asset/inline',
+        issuer: (issuer)=>isContentScriptEntry(issuer, manifestPath, projectPath)
+    });
 }
 async function cssInHtmlLoader(projectPath, mode, manifestPath, usage = {}) {
-    const { useSass = true, useLess = true } = usage;
-    const isNotContentScript = (issuer)=>!isContentScriptEntry(issuer, manifestPath, projectPath);
-    const fileTypes = [
-        {
-            test: /\.module\.css$/,
-            type: 'css/module',
-            loader: null
-        },
-        {
-            test: /\.css$/,
-            exclude: /\.module\.css$/,
-            type: 'css',
-            loader: null
-        },
-        ...useSass ? [
-            {
-                test: /\.(sass|scss)$/,
-                exclude: /\.module\.(sass|scss)$/,
-                type: 'css',
-                loader: 'sass-loader'
-            },
-            {
-                test: /\.module\.(sass|scss)$/,
-                type: 'css/module',
-                loader: 'sass-loader'
-            }
-        ] : [],
-        ...useLess ? [
-            {
-                test: /\.less$/,
-                exclude: /\.module\.less$/,
-                type: 'css',
-                loader: 'less-loader'
-            },
-            {
-                test: /\.module\.less$/,
-                type: 'css/module',
-                loader: 'less-loader'
-            }
-        ] : []
-    ];
-    const rules = await Promise.all(fileTypes.map(async ({ test, exclude, type, loader })=>{
-        const use = loader ? await commonStyleLoaders(projectPath, {
-            mode: mode,
-            loader: css_in_html_loader_resolvePreprocessorLoader(loader, projectPath),
-            loaderOptions: 'sass-loader' === loader ? createSassLoaderOptions(projectPath, mode) : {
-                sourceMap: true
-            }
-        }) : await commonStyleLoaders(projectPath, {
-            mode: mode
-        });
-        return {
-            test,
-            exclude,
-            type,
-            issuer: isNotContentScript,
-            use
-        };
-    }));
-    return rules;
+    return buildCssRules(projectPath, mode, usage, {
+        nonModuleType: 'css',
+        issuer: (issuer)=>!isContentScriptEntry(issuer, manifestPath, projectPath)
+    });
 }
 function injectCssLink(headNode, feature, firstLinkAttrs, hrefOverride) {
     const linkTag = __rspack_external_parse5_utilities_78b19c6a.createNode('link');
@@ -2291,14 +2129,11 @@ class CssPlugin {
     async configureOptions(compiler) {
         const mode = compiler.options.mode || 'development';
         const projectPath = compiler.options.context || process.cwd();
-        const plugins = [];
         const manifestPath = this.manifestPath;
         const usingSass = hasDependency(projectPath, 'sass');
         const usingLess = hasDependency(projectPath, 'less');
-        const maybeInstallStylelint = await maybeUseStylelint(projectPath);
-        plugins.push(...maybeInstallStylelint);
         await maybeUseSass(projectPath);
-        await maybeUseLess(projectPath, manifestPath);
+        await maybeUseLess(projectPath);
         const loaders = [
             ...await cssInContentScriptLoader(projectPath, manifestPath, mode, {
                 useSass: usingSass,
@@ -2311,10 +2146,6 @@ class CssPlugin {
         ];
         compiler.options.output.cssFilename = '[name].css';
         compiler.options.output.cssChunkFilename = '[name].css';
-        compiler.options.plugins = [
-            ...compiler.options.plugins,
-            ...plugins
-        ].filter(Boolean);
         compiler.options.module.rules = [
             ...compiler.options.module.rules,
             ...loaders
@@ -2322,39 +2153,24 @@ class CssPlugin {
         if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
             const integrations = [];
             const usingTailwind = hasDependency(projectPath, 'tailwindcss');
-            const usingPostcss = hasDependency(projectPath, 'postcss') || void 0 !== plugin_css_findPostCssConfig(projectPath) || usingSass || usingLess || usingTailwind;
+            const usingPostcss = hasDependency(projectPath, 'postcss') || void 0 !== findPostCssConfig(projectPath) || usingSass || usingLess || usingTailwind;
             if (usingPostcss) integrations.push('PostCSS');
             if (usingSass) integrations.push('Sass');
             if (usingLess) integrations.push('Less');
             if (usingTailwind) integrations.push('Tailwind');
             console.log(cssIntegrationsEnabled(integrations));
-            const postcssConfig = plugin_css_findPostCssConfig(projectPath);
-            const stylelintConfig = getStylelintConfigFile(projectPath);
+            const postcssConfig = findPostCssConfig(projectPath);
             const tailwindConfig = getTailwindConfigFile(projectPath);
             const browserslistSource = findBrowserslistSource(projectPath);
-            console.log(cssConfigsDetected(postcssConfig, stylelintConfig, tailwindConfig, browserslistSource));
+            console.log(cssConfigsDetected(postcssConfig, tailwindConfig, browserslistSource));
         }
     }
     async apply(compiler) {
         const mode = compiler.options.mode || 'development';
-        if ('production' === mode) return void compiler.hooks.beforeRun.tapPromise(CssPlugin.name, async ()=>await this.configureOptions(compiler));
-        await this.configureOptions(compiler);
-    }
-}
-const plugin_css_postCssConfigFiles = [
-    '.postcssrc',
-    '.postcssrc.json',
-    '.postcssrc.yaml',
-    '.postcssrc.yml',
-    '.postcssrc.js',
-    '.postcssrc.cjs',
-    'postcss.config.js',
-    'postcss.config.cjs'
-];
-function plugin_css_findPostCssConfig(projectPath) {
-    for (const configFile of plugin_css_postCssConfigFiles){
-        const configPath = __rspack_external_path.join(projectPath, configFile);
-        if (__rspack_external_fs.existsSync(configPath)) return configPath;
+        if ('production' === mode) return void compiler.hooks.beforeRun.tapPromise(CssPlugin.name, ()=>this.configureOptions(compiler));
+        const configuring = this.configureOptions(compiler);
+        compiler.hooks.watchRun.tapPromise(CssPlugin.name, ()=>configuring);
+        await configuring;
     }
 }
 function findBrowserslistSource(projectPath) {
@@ -2395,7 +2211,7 @@ class StaticAssetsPlugin {
     constructor(options){
         this.mode = options.mode;
     }
-    async apply(compiler) {
+    apply(compiler) {
         compiler.options.module = compiler.options.module || {
             rules: []
         };
@@ -2743,16 +2559,6 @@ function svelte_resolveFromProject(id, projectPath) {
         const req = createRequire(__rspack_external_path.join(base, 'package.json'));
         return req.resolve(id);
     } catch  {}
-    try {
-        return require.resolve(id, {
-            paths: [
-                projectPath,
-                process.cwd()
-            ]
-        });
-    } catch  {
-        return;
-    }
 }
 function isUsingSvelte(projectPath) {
     const using = hasDependency(projectPath, 'svelte');
@@ -2936,6 +2742,7 @@ class JsFrameworksPlugin {
         const mode = compiler.options.mode || 'development';
         const projectPath = compiler.options.context;
         const manifestDir = __rspack_external_path.dirname(this.manifestPath);
+        ensureTypeScriptConfig(projectPath);
         const swcIncludeDirs = Array.from(new Set([
             projectPath,
             manifestDir,
@@ -3159,8 +2966,10 @@ class JsFrameworksPlugin {
     }
     async apply(compiler) {
         const mode = compiler.options.mode || 'development';
-        if ('production' === mode) return void compiler.hooks.beforeRun.tapPromise(JsFrameworksPlugin.name, async ()=>await this.configureOptions(compiler));
-        await this.configureOptions(compiler);
+        if ('production' === mode) return void compiler.hooks.beforeRun.tapPromise(JsFrameworksPlugin.name, ()=>this.configureOptions(compiler));
+        const configuring = this.configureOptions(compiler);
+        compiler.hooks.watchRun.tapPromise(JsFrameworksPlugin.name, ()=>configuring);
+        await configuring;
     }
 }
 function serverRestartRequiredFromManifestError(fileAdded, fileRemoved) {
@@ -3598,6 +3407,33 @@ function isCoveredByExistingGlobs(existingPatterns, candidate) {
     } catch  {}
     return false;
 }
+function mergeIntoV3Group(groups, normalizedMatches, resources, options) {
+    if (0 === resources.length) return;
+    const createGroupWhenMissing = options?.createGroupWhenMissing ?? true;
+    const target = [
+        ...normalizedMatches
+    ].sort();
+    const existing = groups.find((group)=>{
+        const current = [
+            ...group.matches
+        ].sort();
+        return current.length === target.length && current.every((value, index)=>value === target[index]);
+    });
+    if (existing) {
+        const candidates = resources.filter((resource)=>!existing.resources.includes(resource) && !isCoveredByExistingGlobs(existing.resources, resource));
+        existing.resources = Array.from(new Set([
+            ...existing.resources,
+            ...candidates
+        ])).sort();
+        return;
+    }
+    if (createGroupWhenMissing) groups.push({
+        resources: Array.from(new Set(resources)).sort(),
+        matches: [
+            ...normalizedMatches
+        ].sort()
+    });
+}
 function isCanonicalContentScriptCss(resource) {
     return /^content_scripts\/content-\d+\.css$/.test(resource);
 }
@@ -3624,28 +3460,7 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
             const re = /assets\/[A-Za-z0-9._-]+/g;
             const found = source.match(re) || [];
             const filtered = Array.from(new Set(found.filter((r)=>!r.endsWith('.js') && !r.endsWith('.map')))).sort();
-            if (0 === filtered.length) continue;
-            const existingResource = webAccessibleResourcesV3.find((entry)=>{
-                const a = [
-                    ...entry.matches
-                ].sort();
-                const b = [
-                    ...normalizedMatches
-                ].sort();
-                return a.length === b.length && a.every((v, i)=>v === b[i]);
-            });
-            if (existingResource) {
-                const candidates = filtered.filter((resource)=>!existingResource.resources.includes(resource) && !isCoveredByExistingGlobs(existingResource.resources, resource));
-                existingResource.resources = Array.from(new Set([
-                    ...existingResource.resources || [],
-                    ...candidates
-                ])).sort();
-            } else webAccessibleResourcesV3.push({
-                resources: filtered,
-                matches: [
-                    ...normalizedMatches
-                ].sort()
-            });
+            if (0 !== filtered.length) mergeIntoV3Group(webAccessibleResourcesV3, normalizedMatches, filtered);
         }
     }
     for (const [entryName, resources] of Object.entries(entryImports)){
@@ -3661,31 +3476,7 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
             if (0 === filteredResources.length) continue;
             if (3 === canonicalManifest.manifest_version) {
                 const normalizedMatches = cleanMatches(matches);
-                const existingResource = webAccessibleResourcesV3.find((resourceEntry)=>{
-                    const a = [
-                        ...resourceEntry.matches
-                    ].sort();
-                    const b = [
-                        ...normalizedMatches
-                    ].sort();
-                    return a.length === b.length && a.every((v, i)=>v === b[i]);
-                });
-                if (existingResource) {
-                    const candidates = filteredResources.filter((resource)=>!existingResource.resources.includes(resource) && !isCoveredByExistingGlobs(existingResource.resources, resource));
-                    const merged = Array.from(new Set([
-                        ...existingResource.resources,
-                        ...candidates
-                    ])).sort();
-                    existingResource.resources = merged;
-                    existingResource.matches = [
-                        ...existingResource.matches
-                    ].sort();
-                } else webAccessibleResourcesV3.push({
-                    resources: Array.from(new Set(filteredResources)).sort(),
-                    matches: [
-                        ...normalizedMatches
-                    ].sort()
-                });
+                mergeIntoV3Group(webAccessibleResourcesV3, normalizedMatches, filteredResources);
             } else filteredResources.forEach((resource)=>{
                 if (!webAccessibleResourcesV2.includes(resource)) webAccessibleResourcesV2.push(resource);
             });
@@ -3697,26 +3488,8 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
         if (staticAssets.length > 0) {
             const allMatches = Array.from(new Set((canonicalManifest.content_scripts || []).flatMap((cs)=>cs.matches || [])));
             const normalizedMatches = cleanMatches(allMatches);
-            const existing = webAccessibleResourcesV3.find((entry)=>{
-                const a = [
-                    ...entry.matches
-                ].sort();
-                const b = [
-                    ...normalizedMatches
-                ].sort();
-                return a.length === b.length && a.every((v, i)=>v === b[i]);
-            });
-            if (existing) {
-                const candidates = staticAssets.filter((r)=>!existing.resources.includes(r) && !isCoveredByExistingGlobs(existing.resources, r));
-                existing.resources = Array.from(new Set([
-                    ...existing.resources || [],
-                    ...candidates
-                ])).sort();
-            } else if (normalizedMatches.length > 0) webAccessibleResourcesV3.push({
-                resources: staticAssets,
-                matches: [
-                    ...normalizedMatches
-                ].sort()
+            mergeIntoV3Group(webAccessibleResourcesV3, normalizedMatches, staticAssets, {
+                createGroupWhenMissing: normalizedMatches.length > 0
             });
         }
     }
@@ -3727,29 +3500,7 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
         if (fontAssets.length > 0) {
             const allMatches = Array.from(new Set((canonicalManifest.content_scripts || []).flatMap((cs)=>cs.matches || [])));
             const normalizedMatches = cleanMatches(allMatches);
-            if (normalizedMatches.length > 0) {
-                const existing = webAccessibleResourcesV3.find((entry)=>{
-                    const a = [
-                        ...entry.matches
-                    ].sort();
-                    const b = [
-                        ...normalizedMatches
-                    ].sort();
-                    return a.length === b.length && a.every((v, i)=>v === b[i]);
-                });
-                if (existing) {
-                    const candidates = fontAssets.filter((r)=>!existing.resources.includes(r) && !isCoveredByExistingGlobs(existing.resources, r));
-                    existing.resources = Array.from(new Set([
-                        ...existing.resources || [],
-                        ...candidates
-                    ])).sort();
-                } else webAccessibleResourcesV3.push({
-                    resources: fontAssets,
-                    matches: [
-                        ...normalizedMatches
-                    ].sort()
-                });
-            }
+            if (normalizedMatches.length > 0) mergeIntoV3Group(webAccessibleResourcesV3, normalizedMatches, fontAssets);
         }
     } else if (2 === canonicalManifest.manifest_version) {
         const assetKeys = Object.keys(compilation.assets || {});
@@ -3784,29 +3535,7 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
         if (cssUnderContentScripts.length > 0) {
             const allMatches = Array.from(new Set((canonicalManifest.content_scripts || []).flatMap((cs)=>cs.matches || [])));
             const normalizedMatches = cleanMatches(allMatches);
-            if (normalizedMatches.length > 0) {
-                const existing = webAccessibleResourcesV3.find((entry)=>{
-                    const a = [
-                        ...entry.matches
-                    ].sort();
-                    const b = [
-                        ...normalizedMatches
-                    ].sort();
-                    return a.length === b.length && a.every((v, i)=>v === b[i]);
-                });
-                if (existing) {
-                    const candidates = cssUnderContentScripts.filter((r)=>!existing.resources.includes(r) && !isCoveredByExistingGlobs(existing.resources, r));
-                    existing.resources = Array.from(new Set([
-                        ...existing.resources || [],
-                        ...candidates
-                    ])).sort();
-                } else webAccessibleResourcesV3.push({
-                    resources: cssUnderContentScripts,
-                    matches: [
-                        ...normalizedMatches
-                    ].sort()
-                });
-            }
+            if (normalizedMatches.length > 0) mergeIntoV3Group(webAccessibleResourcesV3, normalizedMatches, cssUnderContentScripts);
         }
     } else if (2 === canonicalManifest.manifest_version) {
         for (const resource of cssUnderContentScripts)if (!webAccessibleResourcesV2.includes(resource)) webAccessibleResourcesV2.push(resource);
@@ -4138,8 +3867,14 @@ function writeFileAtomically(targetPath, content) {
     __rspack_external_fs.mkdirSync(directory, {
         recursive: true
     });
-    __rspack_external_fs.writeFileSync(tempPath, content, 'utf-8');
-    __rspack_external_fs.renameSync(tempPath, targetPath);
+    try {
+        __rspack_external_fs.writeFileSync(tempPath, content, 'utf-8');
+        __rspack_external_fs.renameSync(tempPath, targetPath);
+    } finally{
+        try {
+            if (__rspack_external_fs.existsSync(tempPath)) __rspack_external_fs.unlinkSync(tempPath);
+        } catch  {}
+    }
 }
 class PersistManifestToDisk {
     apply(compiler) {
@@ -4211,10 +3946,7 @@ class AddDependencies {
             const deps = compilation.fileDependencies;
             if (this.dependencyList) this.dependencyList.forEach((dependency)=>{
                 const alreadyPresent = 'function' == typeof deps?.has ? deps.has(dependency) : false;
-                if (!alreadyPresent) {
-                    if ('function' == typeof deps?.add) deps.add(dependency);
-                    if (deps !== compilation.fileDependencies && 'function' == typeof compilation.fileDependencies?.add) compilation.fileDependencies.add(dependency);
-                }
+                if (!alreadyPresent && 'function' == typeof deps?.add) deps.add(dependency);
             });
             if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
                 const added = Array.isArray(this.dependencyList) ? this.dependencyList.length : 0;
@@ -4393,6 +4125,17 @@ function parseHtml(node, onResourceFound) {
     } else if ('link' === node.nodeName) {
         const href = node.attrs?.find((attr)=>'href' === attr.name)?.value;
         const rel = node.attrs?.find((attr)=>'rel' === attr.name)?.value;
+        const imagesrcset = node.attrs?.find((attr)=>'imagesrcset' === attr.name)?.value;
+        if (imagesrcset) for (const candidate of imagesrcset.split(',')){
+            const url = candidate.trim().split(/\s+/)[0];
+            if (!url) continue;
+            const { cleanPath } = cleanAssetUrl(url);
+            if (cleanPath && !parse_html_isUrl(cleanPath)) onResourceFound({
+                filePath: cleanPath,
+                childNode: node,
+                assetType: 'staticHref'
+            });
+        }
         if (!href) return;
         if (parse_html_isUrl(href)) return;
         onResourceFound('dns-prefetch' === rel || 'icon' === rel || 'manifest' === rel || 'modulepreload' === rel || 'preconnect' === rel || 'prefetch' === rel || 'preload' === rel || 'prerender' === rel ? {
@@ -4439,22 +4182,6 @@ function parseHtml(node, onResourceFound) {
                 });
             }
         }
-    } else if ('link' === node.nodeName) {
-        const imagesrcset = node.attrs?.find((attr)=>'imagesrcset' === attr.name)?.value;
-        if (imagesrcset) {
-            const candidates = imagesrcset.split(',');
-            for (const candidate of candidates){
-                const parts = candidate.trim().split(/\s+/);
-                const url = parts[0];
-                if (!url) continue;
-                const { cleanPath } = cleanAssetUrl(url);
-                if (cleanPath && !parse_html_isUrl(cleanPath)) onResourceFound({
-                    filePath: cleanPath,
-                    childNode: node,
-                    assetType: 'staticHref'
-                });
-            }
-        }
     }
     const { childNodes = [] } = node;
     for (const childNode of childNodes)if ('#comment' !== childNode.nodeName && '#text' !== childNode.nodeName) parseHtml(childNode, onResourceFound);
@@ -4474,6 +4201,18 @@ function reportToCompilation(compilation, compiler, message, type = 'error', fil
     if (already) return;
     compilation[bucket].push(issue);
 }
+const cloneParsedHtmlAsset = (assets)=>({
+        css: [
+            ...assets.css || []
+        ],
+        js: [
+            ...assets.js || []
+        ],
+        static: [
+            ...assets.static || []
+        ]
+    });
+const assetsFromHtmlCache = new Map();
 function getAssetsFromHtml(htmlFilePath, htmlContent, publicPath = 'public') {
     const assets = {
         css: [],
@@ -4481,6 +4220,15 @@ function getAssetsFromHtml(htmlFilePath, htmlContent, publicPath = 'public') {
         static: []
     };
     if (!htmlFilePath) return assets;
+    let cacheKey;
+    if (void 0 === htmlContent) try {
+        const stat = __rspack_external_fs.statSync(htmlFilePath);
+        cacheKey = `${stat.mtimeMs}:${stat.size}:${publicPath}`;
+        const cached = assetsFromHtmlCache.get(htmlFilePath);
+        if (cached && cached.key === cacheKey) return cloneParsedHtmlAsset(cached.assets);
+    } catch  {
+        cacheKey = void 0;
+    }
     try {
         const htmlString = htmlContent || __rspack_external_fs.readFileSync(htmlFilePath, {
             encoding: 'utf8'
@@ -4514,13 +4262,21 @@ function getAssetsFromHtml(htmlFilePath, htmlContent, publicPath = 'public') {
                     break;
             }
         });
-    } catch (error) {}
+    } catch (error) {
+        return assets;
+    }
+    if (cacheKey) assetsFromHtmlCache.set(htmlFilePath, {
+        key: cacheKey,
+        assets: cloneParsedHtmlAsset(assets)
+    });
     return assets;
 }
 function getHtmlPageDeclaredAssetPath(filepathList, filePath, extension) {
     const entryname = Object.keys(filepathList).find((key)=>{
         const includePath = filepathList[key];
-        return filepathList[key] === filePath || getAssetsFromHtml(includePath)?.js?.includes(filePath) || getAssetsFromHtml(includePath)?.css?.includes(filePath);
+        if (includePath === filePath) return true;
+        const assets = getAssetsFromHtml(includePath);
+        return Boolean(assets?.js?.includes(filePath) || assets?.css?.includes(filePath));
     }) || '';
     const extname = getExtname(filePath);
     if (!entryname) return `${filePath.replace(extname, '')}${extension}`;
@@ -4636,11 +4392,9 @@ class EmitHtmlFile {
                             continue;
                         }
                         const rawHtml = __rspack_external_fs.readFileSync(resolved, 'utf8');
-                        {
-                            const rawSource = new core_sources.RawSource(rawHtml);
-                            const filepath = getFilePath(featureName, '.html', false);
-                            compilation.emitAsset(filepath, rawSource);
-                        }
+                        const rawSource = new core_sources.RawSource(rawHtml);
+                        const filepath = getFilePath(featureName, '.html', false);
+                        compilation.emitAsset(filepath, rawSource);
                     }
                 }
             };
@@ -4714,6 +4468,17 @@ function resolveCssAsset(compilation, feature) {
         href: void 0
     };
 }
+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));
+    warn.name = 'HtmlPublicAssetMissing';
+    warn.file = htmlEntry;
+    const filtered = String(warn.message).split('\n').filter((line)=>!line.includes(String(cleanPath)));
+    warn.message = filtered.join('\n').trim();
+    compilation.warnings.push(warn);
+}
 function patchHtml(compilation, feature, htmlEntry, includeList) {
     const htmlFile = __rspack_external_fs.readFileSync(htmlEntry, {
         encoding: 'utf8'
@@ -4789,53 +4554,20 @@ function patchHtmlNested(compilation, htmlEntry) {
             switch(assetType){
                 case "script":
                     if (cleanPath.startsWith('/')) {
-                        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)) {
-                            const errorMessage = fileNotFound(htmlEntry, cleanPath);
-                            const warn = new core_WebpackError(errorMessage);
-                            warn.name = 'HtmlPublicAssetMissing';
-                            warn.file = htmlEntry;
-                            const lines = String(warn.message).split('\n');
-                            const filtered = lines.filter((line)=>!line.includes(String(cleanPath)));
-                            warn.message = filtered.join('\n').trim();
-                            compilation.warnings.push(warn);
-                        }
+                        warnIfPublicRootAssetMissing(compilation, htmlEntry, cleanPath);
                         thisChildNode = __rspack_external_parse5_utilities_78b19c6a.setAttribute(thisChildNode, 'src', cleanPath + (search || '') + (hash || ''));
                     }
                     break;
                 case 'css':
                     if (cleanPath.startsWith('/')) {
-                        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)) {
-                            const errorMessage = fileNotFound(htmlEntry, cleanPath);
-                            const warn = new core_WebpackError(errorMessage);
-                            warn.name = 'HtmlPublicAssetMissing';
-                            warn.file = htmlEntry;
-                            const lines = String(warn.message).split('\n');
-                            const filtered = lines.filter((line)=>!line.includes(String(cleanPath)));
-                            warn.message = filtered.join('\n').trim();
-                            compilation.warnings.push(warn);
-                        }
+                        warnIfPublicRootAssetMissing(compilation, htmlEntry, cleanPath);
                         thisChildNode = __rspack_external_parse5_utilities_78b19c6a.setAttribute(thisChildNode, 'href', cleanPath + (search || '') + (hash || ''));
                     }
                     break;
                 case 'staticHref':
                 case 'staticSrc':
                     if (cleanPath.startsWith('/')) {
-                        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)) {
-                            const errorMessage = fileNotFound(htmlEntry, cleanPath);
-                            const warn = new core_WebpackError(errorMessage);
-                            warn.name = 'HtmlPublicAssetMissing';
-                            warn.file = htmlEntry;
-                            const lines = String(warn.message).split('\n');
-                            const filtered = lines.filter((line)=>!line.includes(String(cleanPath)));
-                            warn.message = filtered.join('\n').trim();
-                            compilation.warnings.push(warn);
-                        }
+                        warnIfPublicRootAssetMissing(compilation, htmlEntry, cleanPath);
                         thisChildNode = __rspack_external_parse5_utilities_78b19c6a.setAttribute(thisChildNode, 'staticSrc' === assetType ? 'src' : 'href', cleanPath + (search || '') + (hash || ''));
                     } else if (__rspack_external_fs.existsSync(absolutePath)) {
                         const relativeFromHtml = __rspack_external_path.relative(htmlDir, absolutePath);
@@ -5509,7 +5241,7 @@ var get_bridge_scripts_dirname = __rspack_dirname(__rspack_fileURLToPath(import.
 function findPackageRoot(startDir) {
     let current = startDir;
     for(let i = 0; i < 15; i++){
-        if (fs_0.existsSync(path_0.join(current, 'package.json'))) return current;
+        if (fs.existsSync(path_0.join(current, 'package.json'))) return current;
         const parent = path_0.dirname(current);
         if (parent === current) break;
         current = parent;
@@ -5524,7 +5256,7 @@ function resolveExistingFile(candidates) {
     ];
     for (const candidate of candidates)if (candidate) for (const suffix of suffixes){
         const resolved = suffix ? `${candidate}${suffix}` : candidate;
-        if (fs_0.existsSync(resolved)) return resolved;
+        if (fs.existsSync(resolved)) return resolved;
     }
 }
 function resolveMainWorldBridgeSourcePath(options) {
@@ -5539,7 +5271,7 @@ function resolveMainWorldBridgeSourcePath(options) {
 function getMainWorldBridgeScripts(manifestPath) {
     const bridgeScripts = {};
     try {
-        const raw = JSON.parse(fs_0.readFileSync(manifestPath, 'utf-8'));
+        const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
         const contentScripts = Array.isArray(raw?.content_scripts) ? raw.content_scripts : [];
         const originalCount = contentScripts.length;
         const bridgeSource = resolveMainWorldBridgeSourcePath();
@@ -6620,9 +6352,6 @@ class WebExtensionPlugin {
     }
 }
 const webpack_target_webextension_fork = WebExtensionPlugin;
-function manifest_getManifestContent(compilation, manifestPath) {
-    return getManifestContent(compilation, manifestPath);
-}
 function scripts_lib_manifest_filterKeysForThisBrowser(manifest, browser) {
     return manifest_filterKeysForThisBrowser(manifest, browser);
 }
@@ -6692,253 +6421,6 @@ class SetupBackgroundEntry {
         }
     }
 }
-function patch_csp_resolveV2Policy(policy) {
-    if (!policy) return;
-    if ('string' == typeof policy) return policy;
-    if ('object' == typeof policy) {
-        const extensionPages = policy.extension_pages;
-        if ('string' == typeof extensionPages) return extensionPages;
-    }
-}
-function patch_csp_buildCSP(cspObject) {
-    const directives = Object.entries(cspObject).map(([directive, values])=>`${directive} ${values.join(' ')}`);
-    return directives.join('; ') + '; ';
-}
-function patch_csp_patchV2CSP(manifest) {
-    let policy = patch_csp_resolveV2Policy(manifest.content_security_policy);
-    if (!policy) return patch_csp_buildCSP({
-        "script-src": [
-            "'self'",
-            "'unsafe-eval'",
-            'blob:',
-            'filesystem:'
-        ],
-        'object-src': [
-            "'self'",
-            'blob:',
-            'filesystem:'
-        ]
-    });
-    const csp = content_security_policy_parser(policy);
-    if (csp.get("script-src")) {
-        const scriptSrc = csp.get("script-src") || [];
-        if (!scriptSrc.includes("'unsafe-eval'")) scriptSrc.push("'unsafe-eval'");
-        if (!scriptSrc.includes('blob:')) scriptSrc.push('blob:');
-        if (!scriptSrc.includes('filesystem:')) scriptSrc.push('filesystem:');
-        csp.set("script-src", scriptSrc);
-    } else csp.set("script-src", [
-        "'self'",
-        "'unsafe-eval'",
-        'blob:',
-        'filesystem:'
-    ]);
-    if (csp.get('object-src')) {
-        const objectSrc = csp.get('object-src') || [];
-        if (!objectSrc.includes('blob:')) objectSrc.push('blob:');
-        if (!objectSrc.includes('filesystem:')) objectSrc.push('filesystem:');
-        csp.set('object-src', objectSrc);
-    } else csp.set('object-src', [
-        "'self'",
-        'blob:',
-        'filesystem:'
-    ]);
-    const cspObject = Object.fromEntries(csp.entries());
-    return patch_csp_buildCSP(cspObject);
-}
-function patch_csp_patchV3CSP(manifest) {
-    const policy = manifest.content_security_policy;
-    if (!policy) return {
-        extension_pages: patch_csp_buildCSP({
-            "script-src": [
-                "'self'"
-            ],
-            'object-src': [
-                "'self'"
-            ]
-        })
-    };
-    const csp = content_security_policy_parser(policy.extension_pages || '');
-    const defaultDirectives = {
-        "script-src": [
-            "'self'"
-        ],
-        'object-src': [
-            "'self'"
-        ]
-    };
-    for(const directive in defaultDirectives)if (!csp.get(directive)) csp.set(directive, defaultDirectives[directive]);
-    const cspObject = Object.fromEntries(csp.entries());
-    const extensionPagesPolicy = patch_csp_buildCSP(cspObject);
-    return {
-        extension_pages: extensionPagesPolicy
-    };
-}
-function patch_web_resources_patchWebResourcesV2(manifest) {
-    const defaultResources = [
-        '/*.json',
-        '/*.js',
-        '/*.css',
-        '/*.scss',
-        '/*.sass',
-        '/*.less',
-        '*.styl',
-        "/scripts/*.js",
-        "/scripts/*.css",
-        '/hot/*',
-        '/*.png',
-        '/*.jpg',
-        '/*.jpeg',
-        '/*.svg',
-        '/*.gif',
-        '/*.webp',
-        '/*.ico',
-        '/*.avif'
-    ];
-    const resources = manifest.web_accessible_resources;
-    if (!resources || 0 === resources.length) return defaultResources;
-    const webResources = new Set(resources);
-    for (const resource of defaultResources)if (!webResources.has(resource)) webResources.add(resource);
-    return Array.from(webResources);
-}
-function patch_web_resources_patchWebResourcesV3(manifest) {
-    const defaultResources = [
-        '/*.json',
-        '/*.js',
-        '/*.css',
-        '/*.scss',
-        '/*.sass',
-        '/*.less',
-        '*.styl',
-        "/scripts/*.js",
-        "/scripts/*.css",
-        '/hot/*',
-        '/*.png',
-        '/*.jpg',
-        '/*.jpeg',
-        '/*.svg',
-        '/*.gif',
-        '/*.webp',
-        '/*.ico',
-        '/*.avif'
-    ];
-    return [
-        ...manifest.web_accessible_resources || [],
-        {
-            resources: defaultResources,
-            matches: [
-                '<all_urls>'
-            ]
-        }
-    ];
-}
-function patch_background_patchBackground(manifest, browser) {
-    if (!manifest.background) {
-        if ('firefox' === browser || 'gecko-based' === browser) return {
-            background: {
-                ...manifest.background || {},
-                scripts: [
-                    "background/script.js"
-                ]
-            }
-        };
-        if (2 === manifest.manifest_version) return {
-            background: {
-                ...manifest.background || {},
-                scripts: [
-                    "background/script.js"
-                ]
-            }
-        };
-        return {
-            background: {
-                ...manifest.background || {},
-                service_worker: 'background/service_worker.js'
-            }
-        };
-    }
-    return {
-        background: {
-            ...manifest.background
-        }
-    };
-}
-function patch_externally_connectable_patchExternallyConnectable(manifest) {
-    if (manifest.externally_connectable && !manifest.externally_connectable.ids) return {
-        externally_connectable: {
-            ...manifest.externally_connectable,
-            ids: [
-                ...new Set(manifest.externally_connectable.ids || []),
-                '*'
-            ]
-        }
-    };
-    if (manifest.externally_connectable && !manifest.externally_connectable.ids) return {
-        externally_connectable: {
-            ...manifest.externally_connectable,
-            ids: [
-                '*'
-            ]
-        }
-    };
-    return {};
-}
-class ApplyManifestDevDefaults {
-    manifestPath;
-    browser;
-    constructor(options){
-        this.manifestPath = options.manifestPath;
-        this.browser = options.browser || 'chrome';
-    }
-    generateManifestPatches(compilation) {
-        const canonicalManifest = manifest_getManifestContent(compilation, this.manifestPath);
-        const patchedManifest = {
-            ...canonicalManifest,
-            content_security_policy: 3 === canonicalManifest.manifest_version ? patch_csp_patchV3CSP(canonicalManifest) : patch_csp_patchV2CSP(canonicalManifest),
-            ...3 === canonicalManifest.manifest_version ? canonicalManifest.permissions ? {
-                permissions: [
-                    ...new Set([
-                        "scripting",
-                        'tabs',
-                        'management',
-                        ...canonicalManifest.permissions
-                    ])
-                ]
-            } : {
-                permissions: [
-                    "scripting",
-                    'tabs',
-                    'management'
-                ]
-            } : {},
-            ...patch_background_patchBackground(canonicalManifest, this.browser),
-            ...patch_externally_connectable_patchExternallyConnectable(canonicalManifest),
-            web_accessible_resources: 3 === canonicalManifest.manifest_version ? patch_web_resources_patchWebResourcesV3(canonicalManifest) : patch_web_resources_patchWebResourcesV2(canonicalManifest)
-        };
-        const source = JSON.stringify(patchedManifest, null, 2);
-        const rawSource = new core_sources.RawSource(source);
-        if (compilation.getAsset('manifest.json')) compilation.updateAsset('manifest.json', rawSource);
-    }
-    apply(compiler) {
-        if (!compiler?.hooks?.thisCompilation) return;
-        compiler.hooks.thisCompilation.tap('run-chromium:apply-manifest-dev-defaults', (compilation)=>{
-            if (!compilation?.hooks?.processAssets) return;
-            compilation.hooks.processAssets.tap({
-                name: 'run-chromium:apply-manifest-dev-defaults',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 100
-            }, (_assets)=>{
-                if (!this.manifestPath) {
-                    const errorMessage = 'No manifest.json found in your extension bundle. Unable to patch manifest.json.';
-                    try {
-                        const WebpackErrorCtor = compiler?.rspack?.WebpackError;
-                        compilation.errors.push(WebpackErrorCtor ? new WebpackErrorCtor(`run-chromium: ${errorMessage}`) : new Error(`run-chromium: ${errorMessage}`));
-                    } catch  {}
-                    return;
-                }
-                this.generateManifestPatches(compilation);
-            });
-        });
-    }
-}
 class SetupReloadStrategy {
     manifestPath;
     browser;
@@ -7005,10 +6487,6 @@ class SetupReloadStrategy {
                 };
             }
         } catch  {}
-        new ApplyManifestDevDefaults({
-            manifestPath: this.manifestPath,
-            browser: this.browser
-        }).apply(compiler);
         new SetupBackgroundEntry({
             manifestPath: this.manifestPath,
             browser: this.browser
@@ -7153,6 +6631,517 @@ class InjectScriptsReplayShim {
         });
     }
 }
+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__";
+    if (!PORT || PORT < 1) return;
+
+    var WS = g.WebSocket;
+    if (typeof WS !== "function") return;
+
+    var consoleRef = g.console || {};
+    g.__extjsBridgeProducerInstalled = true;
+
+    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;
+          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 { 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 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://127.0.0.1:" + 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); }
+        }
+      };
+      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 via chrome.runtime.sendMessage to this SW, which owns the WS.
+    // We enrich with the real tabId/url from the message sender.
+    try {
+      var rt = g.chrome;
+      if (rt && rt.runtime && rt.runtime.onMessage) {
+        rt.runtime.onMessage.addListener(function (msg, sender) {
+          if (!msg || !msg.__extjsBridgeLog) return;
+          var ev = msg.__extjsBridgeLog;
+          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) {}
+          // No async response.
+        });
+      }
+    } 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 || typeof chrome.runtime.sendMessage !== "function") return;
+
+    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; } }
+
+    LEVELS.forEach(function (level) {
+      var orig = typeof consoleRef[level] === "function" ? consoleRef[level].bind(consoleRef) : function () {};
+      consoleRef[level] = function () {
+        try {
+          chrome.runtime.sendMessage(
+            {__extjsBridgeLog: {level: level, context: CONTEXT, messageParts: sanitize([].slice.call(arguments)), url: here()}},
+            function () { void chrome.runtime.lastError; } // swallow "no receiver" while the SW wakes
+          );
+        } 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'));
+}
+const inject_bridge_producer_BACKGROUND_ASSET = /(^|\/)background\/(?:service_worker|script)\.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 source = buildBridgeProducerSource({
+            controlPort: Number.isFinite(controlPort) ? controlPort : null,
+            instanceId,
+            context: 'background'
+        });
+        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_CLIENT_MARKERS = [
     '@rspack/dev-server/client/index.js?',
     '@rspack/dev-server/client/utils/ansiHTML.js',
@@ -7164,6 +7153,9 @@ const DEV_SERVER_HOT_MARKERS = [
     '[HMR] Cannot find update. Need to do a full reload!',
     'module.hot.check()'
 ];
+function contentScriptRetainsDevServerRuntime(source) {
+    return source.includes('@rspack/dev-server/client');
+}
 function stripDevServerStartupFromContentScript(source) {
     let nextSource = source;
     const startupModuleIds = getStartupModuleIds(source);
@@ -7213,7 +7205,7 @@ function stripStartupRequire(source, moduleId) {
     const startupRequirePattern = new RegExp(`^\\s*__webpack_require__\\(${moduleId}\\);\\n?`, 'm');
     return source.replace(startupRequirePattern, '');
 }
-const strip_content_script_dev_server_runtime_CONTENT_SCRIPT_ASSET = /(^|\/)content_scripts\/content-\d+(?:\.[a-f0-9]+)?\.js$/i;
+const CONTENT_SCRIPT_ASSET = /(^|\/)content_scripts\/content-\d+(?:\.[a-f0-9]+)?\.js$/i;
 class StripContentScriptDevServerRuntime {
     apply(compiler) {
         compiler.hooks.thisCompilation.tap(StripContentScriptDevServerRuntime.name, (compilation)=>{
@@ -7222,10 +7214,17 @@ class StripContentScriptDevServerRuntime {
                 stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT
             }, ()=>{
                 for (const asset of compilation.getAssets()){
-                    if (!strip_content_script_dev_server_runtime_CONTENT_SCRIPT_ASSET.test(asset.name)) continue;
+                    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);
+                    }
                 }
             });
         });
@@ -7310,6 +7309,8 @@ class ScriptsPlugin {
                 browser: this.browser
             }).apply(compiler);
             new InjectScriptsReplayShim().apply(compiler);
+            new InjectBridgeProducer().apply(compiler);
+            new InjectBridgeRelay().apply(compiler);
         }
     }
 }
@@ -7440,17 +7441,17 @@ function validateLocales(compiler, compilation, manifestPath) {
                 pushCompilationError(compiler, compilation, 'LocalesValidationError', defaultLocaleMessagesMissing(defaultLocale), 'manifest.json');
                 return false;
             }
+            let defaultLocaleMessages;
             try {
                 const content = __rspack_external_fs.readFileSync(messagesJsonPath, 'utf8');
-                JSON.parse(content);
-            } catch (e) {
+                defaultLocaleMessages = JSON.parse(content);
+            } catch  {
                 if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(localesValidationDetected(`invalid JSON in _locales/${defaultLocale}/messages.json`));
                 pushCompilationError(compiler, compilation, 'LocalesValidationError', invalidMessagesJson(messagesJsonPath), 'manifest.json');
                 return false;
             }
             try {
-                const content = __rspack_external_fs.readFileSync(messagesJsonPath, 'utf8');
-                const dict = JSON.parse(content);
+                const dict = defaultLocaleMessages;
                 const collectMsgKeys = (value, acc)=>{
                     if ('string' == typeof value) {
                         const regex = /__MSG_([a-zA-Z0-9_]+)__/g;
@@ -7501,8 +7502,8 @@ function validateLocales(compiler, compilation, manifestPath) {
 function processLocaleAssets(compiler, compilation, manifestPath) {
     if (compilation.errors.length > 0) return;
     const projectRoot = compiler.options.context || void 0;
-    const localesFields = getLocales(manifestPath, projectRoot);
-    const discoveredList = getLocales(manifestPath, projectRoot) || [];
+    const localesFields = getLocales(manifestPath, projectRoot) || [];
+    const discoveredList = localesFields;
     const resolvedLocalesRoot = resolveLocalesFolder(manifestPath, projectRoot);
     let emittedCount = 0;
     let missingCount = 0;
@@ -7751,13 +7752,9 @@ function trackJsonDependencies(compilation, manifestPath, includeList) {
         ];
         for (const thisResource of resourceArr)if (thisResource) {
             const abs = __rspack_external_path.isAbsolute(thisResource) ? thisResource : __rspack_external_path.join(manifestDir, thisResource);
-            const fileDependencies = new Set(compilation.fileDependencies);
-            if (__rspack_external_fs.existsSync(abs)) {
-                if (!fileDependencies.has(abs)) {
-                    fileDependencies.add(abs);
-                    compilation.fileDependencies.add(abs);
-                    added++;
-                }
+            if (__rspack_external_fs.existsSync(abs) && !compilation.fileDependencies.has(abs)) {
+                compilation.fileDependencies.add(abs);
+                added++;
             }
         }
     }
@@ -7779,13 +7776,6 @@ class JsonPlugin {
                 stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>{
                 processJsonAssets(compilation, this.manifestPath, this.includeList || {});
-            });
-        });
-        compiler.hooks.thisCompilation.tap('json:module', (compilation)=>{
-            compilation.hooks.processAssets.tap({
-                name: 'json:module',
-                stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
-            }, ()=>{
                 trackJsonDependencies(compilation, this.manifestPath, this.includeList || {});
             });
         });
@@ -7819,6 +7809,30 @@ function iconsDepsTracked(addedCount) {
 function iconsNormalizationSummary(beforeKeys, afterKeys, changedCount) {
     return `Icons include normalization — keys ${pintor.gray(String(beforeKeys.length))} → ${pintor.gray(String(afterKeys.length))}, normalized ${pintor.gray(String(changedCount))}`;
 }
+function iconValuesToStrings(response) {
+    if (!response) return [];
+    if ('string' == typeof response) return [
+        response
+    ];
+    if (Array.isArray(response)) return response.flatMap((value)=>{
+        if ('string' == typeof value) return [
+            value
+        ];
+        if (value && 'object' == typeof value) return Object.values(value);
+        return [];
+    }).filter((value)=>'string' == typeof value);
+    if ('object' == typeof response) return Object.values(response).filter((value)=>'string' == typeof value);
+    return [];
+}
+function normalizeIconIncludeKeys(icons) {
+    const out = {};
+    for (const [key, value] of Object.entries(icons || {}))if ('action' === key) out['action/default_icon'] = value;
+    else if ('browser_action' === key) out['browser_action/default_icon'] = value;
+    else if ('page_action' === key) out['page_action/default_icon'] = value;
+    else if ('sidebar_action' === key) out['sidebar_action/default_icon'] = value;
+    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);
@@ -7848,25 +7862,7 @@ class EmitFile {
                 for (const field of Object.entries(iconFields)){
                     const [feature, resource] = field;
                     if (void 0 === resource) continue;
-                    const normalizeToStrings = (response)=>{
-                        if (!response) return [];
-                        if ('string' == typeof response) return [
-                            response
-                        ];
-                        if (Array.isArray(response)) {
-                            const flat = response.flatMap((v)=>{
-                                if ('string' == typeof v) return [
-                                    v
-                                ];
-                                if (v && 'object' == typeof v) return Object.values(v);
-                                return [];
-                            });
-                            return flat.filter((s)=>'string' == typeof s);
-                        }
-                        if ('object' == typeof response) return Object.values(response).filter((value)=>'string' == typeof value);
-                        return [];
-                    };
-                    const stringEntries = normalizeToStrings(resource);
+                    const stringEntries = iconValuesToStrings(resource);
                     let emittedCount = 0;
                     let underPublicCount = 0;
                     let missingCount = 0;
@@ -7975,34 +7971,10 @@ class add_to_file_dependencies_AddToFileDependencies {
                 let added = 0;
                 for (const field of Object.entries(iconFields)){
                     const [, resource] = field;
-                    const normalizeToStrings = (response)=>{
-                        if (!response) return [];
-                        if ('string' == typeof response) return [
-                            response
-                        ];
-                        if (Array.isArray(response)) {
-                            const flat = response.flatMap((value)=>{
-                                if ('string' == typeof value) return [
-                                    value
-                                ];
-                                if (value && 'object' == typeof value) return Object.values(value);
-                                return [];
-                            });
-                            return flat.filter((s)=>'string' == typeof s);
-                        }
-                        if ('object' == typeof response) return Object.values(response).filter((value)=>'string' == typeof value);
-                        return [];
-                    };
-                    const stringEntries = normalizeToStrings(resource);
-                    for (const entry of stringEntries)if (entry) {
-                        const fileDependencies = new Set(compilation.fileDependencies);
-                        if (__rspack_external_fs.existsSync(entry)) {
-                            if (!fileDependencies.has(entry)) {
-                                fileDependencies.add(entry);
-                                compilation.fileDependencies.add(entry);
-                                added++;
-                            }
-                        }
+                    const stringEntries = iconValuesToStrings(resource);
+                    for (const entry of stringEntries)if (entry && __rspack_external_fs.existsSync(entry) && !compilation.fileDependencies.has(entry)) {
+                        compilation.fileDependencies.add(entry);
+                        added++;
                     }
                 }
                 if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(iconsDepsTracked(added));
@@ -8010,15 +7982,6 @@ class add_to_file_dependencies_AddToFileDependencies {
         });
     }
 }
-function normalizeIconIncludeKeys(icons) {
-    const out = {};
-    for (const [key, value] of Object.entries(icons || {}))if ('action' === key) out['action/default_icon'] = value;
-    else if ('browser_action' === key) out['browser_action/default_icon'] = value;
-    else if ('page_action' === key) out['page_action/default_icon'] = value;
-    else if ('sidebar_action' === key) out['sidebar_action/default_icon'] = value;
-    else out[key] = value;
-    return out;
-}
 class IconsPlugin {
     manifestPath;
     includeList;
@@ -8187,7 +8150,7 @@ function flattenValues(map) {
     return paths;
 }
 function diffArray(prev, next) {
-    if (prev.join(',') === next.join(',')) return null;
+    if (prev.length === next.length && prev.every((value, i)=>value === next[i])) return null;
     const maxLen = Math.max(prev.length, next.length);
     let pathBefore;
     let pathAfter;
@@ -8466,16 +8429,18 @@ class CompatibilityPlugin {
         this.browser = options.browser || 'chrome';
         this.polyfill = options.polyfill || false;
     }
-    async apply(compiler) {
-        if (this.polyfill) {
-            if ('firefox' !== this.browser) {
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(compatibilityPolyfillEnabled(this.browser, 'webextension-polyfill'));
-                new PolyfillPlugin({
-                    manifestPath: this.manifestPath,
-                    browser: this.browser || 'chrome'
-                }).apply(compiler);
-            } else if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(compatibilityPolyfillSkipped('Firefox bundles browser.* APIs', this.browser));
-        } else if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(compatibilityPolyfillDisabled(this.browser));
+    apply(compiler) {
+        const isGeckoFamily = 'firefox' === this.browser || 'gecko-based' === this.browser || 'firefox-based' === this.browser;
+        if (this.polyfill) if (isGeckoFamily) {
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(compatibilityPolyfillSkipped('Firefox bundles browser.* APIs', this.browser));
+        } else {
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(compatibilityPolyfillEnabled(this.browser, 'webextension-polyfill'));
+            new PolyfillPlugin({
+                manifestPath: this.manifestPath,
+                browser: this.browser || 'chrome'
+            }).apply(compiler);
+        }
+        else if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(compatibilityPolyfillDisabled(this.browser));
     }
 }
 class WasmPlugin {
@@ -8496,18 +8461,18 @@ class WasmPlugin {
     }
     buildAssetAliases(projectRoot) {
         const aliases = {};
-        const addAlias = (request, relativePath)=>{
-            const resolved = this.resolveAssetPath(projectRoot, relativePath);
+        const addAlias = (request)=>{
+            const resolved = this.resolveAssetPath(projectRoot, request);
             if (resolved) aliases[request] = resolved;
         };
-        addAlias('@ffmpeg/core/dist/esm/ffmpeg-core.js', '@ffmpeg/core/dist/esm/ffmpeg-core.js');
-        addAlias('@ffmpeg/core/dist/esm/ffmpeg-core.wasm', '@ffmpeg/core/dist/esm/ffmpeg-core.wasm');
-        addAlias('@ffmpeg/core-mt/dist/esm/ffmpeg-core.js', '@ffmpeg/core-mt/dist/esm/ffmpeg-core.js');
-        addAlias('@ffmpeg/core-mt/dist/esm/ffmpeg-core.wasm', '@ffmpeg/core-mt/dist/esm/ffmpeg-core.wasm');
-        addAlias('@ffmpeg/core-mt/dist/esm/ffmpeg-core.worker.js', '@ffmpeg/core-mt/dist/esm/ffmpeg-core.worker.js');
-        addAlias('@imagemagick/magick-wasm/magick.wasm', '@imagemagick/magick-wasm/magick.wasm');
-        addAlias('tesseract-wasm/dist/tesseract-worker.js', 'tesseract-wasm/dist/tesseract-worker.js');
-        addAlias('tesseract-wasm/dist/tesseract-core.wasm', 'tesseract-wasm/dist/tesseract-core.wasm');
+        addAlias('@ffmpeg/core/dist/esm/ffmpeg-core.js');
+        addAlias('@ffmpeg/core/dist/esm/ffmpeg-core.wasm');
+        addAlias('@ffmpeg/core-mt/dist/esm/ffmpeg-core.js');
+        addAlias('@ffmpeg/core-mt/dist/esm/ffmpeg-core.wasm');
+        addAlias('@ffmpeg/core-mt/dist/esm/ffmpeg-core.worker.js');
+        addAlias('@imagemagick/magick-wasm/magick.wasm');
+        addAlias('tesseract-wasm/dist/tesseract-worker.js');
+        addAlias('tesseract-wasm/dist/tesseract-core.wasm');
         return aliases;
     }
     ensureWasmResolution(compiler, projectRoot) {
@@ -8563,9 +8528,9 @@ function categorizeAsset(rawName) {
     return 'ignored';
 }
 const BUDGET_BYTES = {
-    "content-script": 262144,
-    'service-worker': 204800,
-    page: 512000,
+    "content-script": 524288,
+    'service-worker': 524288,
+    page: 1048576,
     ignored: 1 / 0
 };
 function fmtKiB(bytes) {
@@ -8607,7 +8572,7 @@ class PerfBudgetsPlugin {
             ...BUDGET_BYTES,
             ...this.options.budgets || {}
         };
-        compiler.hooks.afterCompile.tap(PerfBudgetsPlugin.name, (compilation)=>{
+        const report = (compilation)=>{
             if (compilation.errors?.length) return;
             const oversized = [];
             const assets = compilation.assets || {};
@@ -8617,7 +8582,7 @@ class PerfBudgetsPlugin {
                 const category = categorizeAsset(name);
                 if ('ignored' === category) continue;
                 const budget = budgets[category];
-                if (isFinite(budget)) {
+                if (Number.isFinite(budget)) {
                     if (!(size <= budget)) oversized.push({
                         name,
                         size,
@@ -8633,6 +8598,13 @@ class PerfBudgetsPlugin {
             warning.name = 'PerfBudgetWarning';
             if (!compilation.warnings) compilation.warnings = [];
             compilation.warnings.push(warning);
+        };
+        const REPORT_STAGE = compiler?.rspack?.Compilation?.PROCESS_ASSETS_STAGE_REPORT ?? 5000;
+        compiler.hooks.thisCompilation.tap(PerfBudgetsPlugin.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: PerfBudgetsPlugin.name,
+                stage: REPORT_STAGE
+            }, ()=>report(compilation));
         });
     }
 }
@@ -8640,7 +8612,13 @@ var rspack_config_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.
 function webpackConfig(projectStructure, devOptions) {
     const { manifestPath } = projectStructure;
     const { packageJsonDir } = getDirs(projectStructure);
-    const manifest = filterKeysForThisBrowser(JSON.parse(__rspack_external_fs.readFileSync(manifestPath, 'utf-8')), devOptions.browser);
+    let rawManifest;
+    try {
+        rawManifest = JSON.parse(__rspack_external_fs.readFileSync(manifestPath, 'utf-8'));
+    } catch (error) {
+        throw new Error(manifestInvalidJson(manifestPath, error));
+    }
+    const manifest = 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,
@@ -8694,15 +8672,21 @@ function webpackConfig(projectStructure, devOptions) {
         new SpecialFoldersPlugin({
             manifestPath
         }),
-        new PerfBudgetsPlugin()
+        new PerfBudgetsPlugin({
+            budgets: devOptions.perfBudgets
+        })
     ];
-    if (devOptions.noBrowser) plugins.push(new PlaywrightPlugin({
+    plugins.push(new PlaywrightPlugin({
         packageJsonDir,
         browser: devOptions.browser,
         mode: devOptions.mode,
         outputPath: primaryExtensionOutputDir,
         manifestPath,
-        port: devOptions.port
+        port: devOptions.port,
+        instanceId: devOptions.instanceId,
+        controlPort: devOptions.controlPort,
+        controlPath: devOptions.controlPath,
+        logsPath: devOptions.logsPath
     }));
     if (devOptions.browsersPlugin) {
         const browsersPlugin = devOptions.browsersPlugin;
@@ -8734,7 +8718,9 @@ function webpackConfig(projectStructure, devOptions) {
         },
         watchOptions: {
             ignored: transpilePackageDirs.length > 0 ? /dist|extension-js\/profiles/ : /node_modules|dist|extension-js\/profiles/,
-            poll: 1000,
+            ...'true' === process.env.EXTENSION_WATCH_POLL ? {
+                poll: parseInt(String(process.env.EXTENSION_WATCH_POLL_INTERVAL || '1000'), 10)
+            } : {},
             aggregateTimeout: 200
         },
         resolve: {