extension-develop 3.16.1 → 3.17.0-canary.312.672c4f2

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);
@@ -4109,12 +3838,6 @@ function normalizeManifestFile(filePath) {
     if (/[*?[\]{}]/.test(normalized)) return;
     return normalized;
 }
-function compilationHasAsset(compilation, filename) {
-    if ('function' == typeof compilation.getAsset) {
-        if (compilation.getAsset(filename)) return true;
-    }
-    return Boolean(compilation.assets?.[filename]);
-}
 function collectRequiredManifestFiles(manifest) {
     const required = new Set();
     const addFile = (filePath)=>{
@@ -4133,12 +3856,10 @@ function collectRequiredManifestFiles(manifest) {
         ...required
     ];
 }
-function isFinalManifestReadyForDisk(compilation, manifestSource) {
-    const manifest = readJsonSafe(manifestSource);
-    if (!manifest) return false;
-    const requiredFiles = collectRequiredManifestFiles(manifest);
-    if (0 === requiredFiles.length) return true;
-    return requiredFiles.every((filename)=>compilationHasAsset(compilation, filename));
+function findMissingFilesOnDisk(outputPath, required) {
+    const missing = [];
+    for (const relativeFile of required)if (!__rspack_external_fs.existsSync(__rspack_external_path.join(outputPath, relativeFile))) missing.push(relativeFile);
+    return missing;
 }
 function writeFileAtomically(targetPath, content) {
     const directory = __rspack_external_path.dirname(targetPath);
@@ -4146,37 +3867,72 @@ 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) {
-        compiler.hooks.thisCompilation.tap('manifest:persist-manifest', (compilation)=>{
+        let pendingManifestSource;
+        let pendingOutputPath;
+        let pendingHadErrors = false;
+        compiler.hooks.thisCompilation.tap('manifest:persist-manifest:capture', (compilation)=>{
             compilation.hooks.processAssets.tap({
-                name: 'manifest:persist-manifest',
+                name: 'manifest:persist-manifest:capture',
                 stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 1000
             }, ()=>{
-                if (compilation.errors.length > 0) return;
-                const outputPath = compilation.outputOptions.path || compiler.options.output?.path;
-                if (!outputPath) return;
+                pendingHadErrors = compilation.errors.length > 0;
+                pendingOutputPath = compilation.outputOptions.path || compiler.options.output?.path;
                 const manifestAsset = compilation.getAsset('manifest.json');
                 const manifestSource = getCurrentManifestContent(compilation) || manifestAsset?.source?.source?.().toString();
-                if (!manifestSource) return;
-                if (!isFinalManifestReadyForDisk(compilation, manifestSource)) return;
-                const manifestOutputPath = __rspack_external_path.join(outputPath, 'manifest.json');
-                try {
-                    try {
-                        const currentOnDisk = __rspack_external_fs.readFileSync(manifestOutputPath, 'utf-8');
-                        if (currentOnDisk === manifestSource) return;
-                    } catch  {}
-                    writeFileAtomically(manifestOutputPath, manifestSource);
-                } catch (error) {
-                    const err = new core.WebpackError(`Failed to persist manifest.json to disk: ${error.message}`);
-                    err.file = 'manifest.json';
-                    compilation.errors.push(err);
-                }
+                pendingManifestSource = 'string' == typeof manifestSource ? manifestSource : void 0;
             });
         });
+        compiler.hooks.afterEmit.tap('manifest:persist-manifest:flush', (compilation)=>{
+            const outputPath = pendingOutputPath;
+            const manifestSource = pendingManifestSource;
+            const hadErrors = pendingHadErrors;
+            pendingManifestSource = void 0;
+            pendingOutputPath = void 0;
+            pendingHadErrors = false;
+            if (hadErrors || !outputPath || !manifestSource) return;
+            const manifest = readJsonSafe(manifestSource);
+            if (!manifest) return;
+            const requiredFiles = collectRequiredManifestFiles(manifest);
+            const missingFiles = findMissingFilesOnDisk(outputPath, requiredFiles);
+            if (missingFiles.length > 0) {
+                const sample = missingFiles.slice(0, 5).join('\n  - ');
+                const more = missingFiles.length > 5 ? `\n  ... and ${missingFiles.length - 5} more` : '';
+                const err = new core.WebpackError([
+                    'manifest.json references files that were not emitted to disk for this build:',
+                    `  - ${sample}${more}`,
+                    '',
+                    'The previous manifest.json was kept to avoid loading a broken extension.',
+                    'This usually means the bundler skipped a chunk during an incremental rebuild.',
+                    'Try saving any source file again, or restart `extension dev` if it persists.'
+                ].join('\n'));
+                err.file = 'manifest.json';
+                compilation.errors.push(err);
+                return;
+            }
+            const manifestOutputPath = __rspack_external_path.join(outputPath, 'manifest.json');
+            try {
+                try {
+                    const currentOnDisk = __rspack_external_fs.readFileSync(manifestOutputPath, 'utf-8');
+                    if (currentOnDisk === manifestSource) return;
+                } catch  {}
+                writeFileAtomically(manifestOutputPath, manifestSource);
+            } catch (error) {
+                const err = new core.WebpackError(`Failed to persist manifest.json to disk: ${error.message}`);
+                err.file = 'manifest.json';
+                compilation.errors.push(err);
+            }
+        });
     }
 }
 class AddDependencies {
@@ -4190,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;
@@ -4372,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 ? {
@@ -4418,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);
@@ -4453,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: [],
@@ -4460,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'
@@ -4493,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}`;
@@ -4615,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);
                     }
                 }
             };
@@ -4693,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'
@@ -4768,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);
@@ -5488,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;
@@ -5503,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) {
@@ -5518,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();
@@ -6599,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);
 }
@@ -6671,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;
@@ -6984,10 +6487,6 @@ class SetupReloadStrategy {
                 };
             }
         } catch  {}
-        new ApplyManifestDevDefaults({
-            manifestPath: this.manifestPath,
-            browser: this.browser
-        }).apply(compiler);
         new SetupBackgroundEntry({
             manifestPath: this.manifestPath,
             browser: this.browser
@@ -7143,6 +6642,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);
@@ -7192,7 +6694,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)=>{
@@ -7201,10 +6703,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);
+                    }
                 }
             });
         });
@@ -7419,17 +6928,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;
@@ -7480,8 +6989,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;
@@ -7730,13 +7239,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++;
             }
         }
     }
@@ -7758,13 +7263,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 || {});
             });
         });
@@ -7798,6 +7296,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);
@@ -7827,25 +7349,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;
@@ -7954,34 +7458,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));
@@ -7989,15 +7469,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;
@@ -8166,7 +7637,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;
@@ -8445,16 +7916,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 {
@@ -8475,18 +7948,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) {
@@ -8586,7 +8059,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 || {};
@@ -8596,7 +8069,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,
@@ -8612,6 +8085,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));
         });
     }
 }
@@ -8619,7 +8099,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,
@@ -8673,7 +8159,9 @@ function webpackConfig(projectStructure, devOptions) {
         new SpecialFoldersPlugin({
             manifestPath
         }),
-        new PerfBudgetsPlugin()
+        new PerfBudgetsPlugin({
+            budgets: devOptions.perfBudgets
+        })
     ];
     if (devOptions.noBrowser) plugins.push(new PlaywrightPlugin({
         packageJsonDir,
@@ -8699,9 +8187,9 @@ function webpackConfig(projectStructure, devOptions) {
             clean: devOptions.output.clean,
             path: primaryExtensionOutputDir,
             publicPath: '/',
-            filename: 'development' === (devOptions.mode || 'development') ? (pathData)=>{
+            filename: 'development' === (devOptions.mode || 'development') && false !== devOptions.hashContentScripts ? (pathData)=>{
                 const chunkName = pathData.chunk?.name;
-                if ('string' == typeof chunkName && /^content_scripts\/content-\d+$/.test(chunkName)) return `${chunkName}.[fullhash:8].js`;
+                if ('string' == typeof chunkName && /^content_scripts\/content-\d+$/.test(chunkName)) return `${chunkName}.[contenthash:8].js`;
                 return '[name].js';
             } : '[name].js',
             hotUpdateChunkFilename: 'hot/[id].[fullhash].hot-update.js',
@@ -8713,7 +8201,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: {