extension-develop 4.1.20 → 4.1.21

package/dist/rspack-config~0.mjs

@@ -1,7 +1,7 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import core, { Compilation as core_Compilation, DefinePlugin, EntryPlugin, LightningCssMinimizerRspackPlugin, ProvidePlugin, SwcJsMinimizerRspackPlugin, WebpackError as core_WebpackError, experiments, javascript as core_javascript, library, rspack, sources as core_sources } from "@rspack/core";
 import { createRequire } from "node:module";
 import pintor from "pintor";
-import core, { Compilation as core_Compilation, DefinePlugin, EntryPlugin, ProvidePlugin, WebpackError as core_WebpackError, javascript as core_javascript, library, rspack, sources as core_sources } from "@rspack/core";
 import case_sensitive_paths_webpack_plugin from "case-sensitive-paths-webpack-plugin";
 import { zipSync } from "fflate";
 import ignore from "ignore";
@@ -14,12 +14,12 @@ import node_path from "node:path";
 import { utils_isUrl, getBaseNode, parseHtml, manifestJsonOutputTarget, getExtname, getBaseHref, isResourceUnderDirs, getAssetsFromHtml, normalizeManifestOutputPath, manifestPageOutputTarget, canonicalizeDir, iconOutputPath, isFromIncludeList, htmlStaticAssetOutputName, isSpecialScheme, resolveStaticAttributeName, getHtmlPageDeclaredAssetPath, themeImageOutputPath, themeIconOutputPath, applyRewrittenStaticUrl, toResourceKey, cleanLeading, getFilePath, resolveAbsoluteFsPath, cleanAssetUrl, isHttpLike, resolveHtmlRefPath } from "./938~0.mjs";
 import { prefix as messaging_prefix, isDebug } from "./852~0.mjs";
 import { isChromiumBasedBrowser, CHROMIUM_FAMILY_ALIASES, GECKO_FAMILY_ALIASES, isWebkitBasedBrowser, isGeckoBasedBrowser } from "./331~0.mjs";
-import { isUsingTypeScript, jsFrameworksIntegrationsEnabled, classifyEntrySurface, ensureTypeScriptConfig, ensureOptionalContractModuleLoaded, resolveDevelopInstallRoot, isUsingCustomLoader, getUserTypeScriptConfigFile, loadOptionalContractModuleWithoutInstall, isUsingIntegration as messages_isUsingIntegration, resolveOptionalContractPackageWithoutInstall, jsFrameworksHmrSummary, humanLine, ensureOptionalContractPackageResolved, jsFrameworksConfigsDetected, recordZipArtifact, hasDependency, resolveDevelopDistFile, defaultSplitChunks } from "./840~0.mjs";
+import { maybeUsePreact, isUsingTypeScript, jsFrameworksIntegrationsEnabled, maybeUseReact, isUsingVue, classifyEntrySurface, ensureTypeScriptConfig, resolveDevelopInstallRoot, loadLoaderOptions, getUserTypeScriptConfigFile, isUsingIntegration as messages_isUsingIntegration, maybeUseVue, maybeUseSolid, jsFrameworksHmrSummary, humanLine, ensureOptionalContractPackageResolved, jsFrameworksConfigsDetected, recordZipArtifact, hasDependency, resolveDevelopDistFile, isUsingJsxFramework, getJsxImportSource, swcParserForFile, isUsingReact, defaultSplitChunks } from "./840~0.mjs";
 import { bundlerFatalError, bundlerRecompiling, browserRunnerDisabled, PlaywrightPlugin, publicFolderShadowed, resolveCompanionExtensionDirs, specialFoldersSetupSummary, noEntrypointsDetected, serverRestartRequiredFromSpecialFolderMessageOnly, specialFolderChangeDetected, spacerLine, messages_ready, getPreloadedEnvKeys, publicMustBeAtProjectRoot, computeExtensionsToLoad, getSpecialFoldersDataForCompiler } from "./832~0.mjs";
 import { renderStatsBlocks, makeSanitizedConsole } from "./stats-handler~0.mjs";
 import { stripBom, findNearestProjectManifestSync, PROJECT_MANIFEST_FILENAMES, parseJsonSafe, readProjectDependencies } from "./731~0.mjs";
 import { EXTENSIONJS_CONTENT_SCRIPT_LAYER, getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, CONTENT_SCRIPT_CSS_PROBE_MARKER_PREFIX, createContentScriptCssProbeMarkerPattern, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName, isCanonicalContentScriptAsset } from "./640~0.mjs";
-import { getURLDependencyMissing, findDroppedVendorKeys, isStaticThemeSource, entrySplitAcrossInitialFiles, isStaticTheme, fetchedFileDependencyMissing, filterKeysForThisBrowser, compiledSourceSpelling, importScriptsDependencyMissing, injectedFileDependencyMissing, injectedCompiledSourceLiteral, staticImportDependencyMissing, runtimeSetSurfaceDependencyMissing } from "./672~0.mjs";
+import { getURLDependencyMissing, findDroppedVendorKeys, isStaticThemeSource, workerStartedFromPageContext, importScriptsDependencyMissing, filterKeysForThisBrowser, findPrefixedManifestVersionKeys, injectedCompiledSourceLiteral, staticImportDependencyMissing, entrySplitAcrossInitialFiles, fetchedFileDependencyMissing, isStaticTheme, compiledSourceSpelling, injectedFileDependencyMissing, isValidManifestVersion, runtimeSetSurfaceDependencyMissing } from "./672~0.mjs";
 import { packagingSourceFiles, debugBrowser, debugExtensionsToLoad, treeWithSourceFiles, debugOutputPath, manifestInvalidJson, getDirs, asAbsolute, treeWithDistFilesBrowser, packagingDistributionFiles, treeWithSourceAndDistFiles, toPosixPath as paths_toPosixPath, debugContextPath, noCompanionExtensionsResolved } from "./950~0.mjs";
 import { cssMinifierDroppedRules, postCssConfigUnreadable, missingSassDependency, deadCssUrlRef, postCssPluginNotResolved, postCssConfigPluginsShape, cssIntegrationsEnabled, cssConfigsDetected, isUsingIntegration } from "./524~0.mjs";
 import { minifierDroppedTokens, restoreVerbatimCssAssets } from "./88~0.mjs";
@@ -1193,6 +1193,24 @@ function vendorPrefixedKeyDropped(key, familyKey, vendor, browser) {
     const vendorName = 'edge' === vendor ? 'Edge' : 'Chrome';
     return `${messaging_prefix('warn')} ${pintor.yellow(key)} now applies only to ${vendorName} builds, so the ${pintor.blue(browser)} build dropped it.\nRename it to ${pintor.yellow(familyKey)} to keep it on every Chromium-based browser. Leave it as is if it's meant for ${vendorName} only.`;
 }
+function prefixScope(prefix) {
+    if ('chrome' === prefix) return 'Chrome';
+    if ('edge' === prefix) return 'Edge';
+    if ('chromium' === prefix) return 'Chromium-based';
+    if ('firefox' === prefix || 'gecko' === prefix) return 'Firefox-based';
+    if ('safari' === prefix || 'webkit' === prefix) return 'Safari';
+    return prefix;
+}
+function manifestVersionLostForBrowser(browser, prefixedKeys, resolved) {
+    const target = pintor.blue(browser);
+    const field = pintor.yellow('manifest_version');
+    const scoped = prefixedKeys.map((key)=>{
+        const scope = prefixScope(key.substring(0, key.indexOf(':')));
+        return `${pintor.yellow(key)} applies only to ${scope} builds`;
+    });
+    const lead = void 0 === resolved ? scoped.length ? `${scoped.join(', ')}, so the ${target} build has no ${field}.` : `The ${target} build has no ${field}.` : `The ${target} build resolved ${field} to ${pintor.yellow(JSON.stringify(resolved))}, and browsers load only 2 or 3.`;
+    return `${messaging_prefix('error')} ${lead}\nNo browser loads a manifest without it, so the build was refused. Add a plain ${field}, or scope one to this browser: ${pintor.yellow('chromium:manifest_version')} for every Chromium-based browser, ${pintor.yellow('firefox:manifest_version')} for Firefox.`;
+}
 function edgeStoreKeyDropped(browser) {
     return `${messaging_prefix('warn')} Edge Add-ons refuses a package whose manifest carries ${pintor.yellow('key')}, so the ${pintor.blue(browser)} production build dropped it.\nPartner Center assigns the id that ${pintor.yellow('key')} pins everywhere else, so the field has no use in this package. Write it as ${pintor.yellow('chrome:key')} if it is meant for the Chrome Web Store build only.`;
 }
@@ -1516,6 +1534,13 @@ function buildCanonicalManifest(manifestPath, manifest, browser, projectPath) {
     return webkit.manifest;
 }
 const IMPORT_META_URL_RUNTIME = '(function(){var h=typeof document!=="undefined"&&document.baseURI||self.location.href;try{var g=globalThis,r=(g.browser||g.chrome).runtime.getURL("/");return h.indexOf(r)===0?h:r}catch(_){return h}})()';
+function importMetaUrlForEmitPath(emitPath) {
+    const request = emitPath.replace(/\\/g, '/').replace(/^\/+/, '');
+    return `(function(){try{var g=globalThis;return (g.browser||g.chrome).runtime.getURL(${toJsStringLiteral(request)})}catch(_){return ${IMPORT_META_URL_RUNTIME}}})()`;
+}
+function toJsStringLiteral(value) {
+    return JSON.stringify(value).replace(/[<>\u007f-\uffff]/g, (char)=>`\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}
 function resolveProcessShim() {
     const candidate = __rspack_external_node_path_806ed179.join(__rspack_import_meta_dirname__, '..', 'runtime', 'process-shim.cjs');
     try {
@@ -1628,7 +1653,6 @@ class EnvPlugin {
         filteredEnvVars['import.meta.dirname'] = 'undefined';
         filteredEnvVars['import.meta.filename'] = 'undefined';
         filteredEnvVars.global = 'globalThis';
-        filteredEnvVars['import.meta.url'] = IMPORT_META_URL_RUNTIME;
         const injectedCount = Object.keys(filteredEnvVars).filter((k)=>k.startsWith('process.env.EXTENSION_PUBLIC_')).length;
         if (isDebug()) console.log(envInjectedPublicVars(injectedCount));
         const processShim = resolveProcessShim();
@@ -1637,6 +1661,11 @@ class EnvPlugin {
             filteredEnvVars.process = '({env:{},argv:[],platform:"browser",browser:true,versions:{},nextTick:function(cb){Promise.resolve().then(function(){cb()})}})';
         }
         new DefinePlugin(filteredEnvVars).apply(compiler);
+        const importMetaUrl = new DefinePlugin({
+            'import.meta.url': IMPORT_META_URL_RUNTIME
+        });
+        importMetaUrl.affectedHooks = 'thisCompilation';
+        importMetaUrl.apply(compiler);
         if (processShim) new ProvidePlugin({
             process: processShim
         }).apply(compiler);
@@ -2902,294 +2931,8 @@ function getResolvedManifestFieldsData(options) {
         return data;
     }
 }
-let preact_userMessageDelivered = false;
-function isUsingPreact(projectPath) {
-    if (hasDependency(projectPath, 'preact')) {
-        if (!preact_userMessageDelivered) {
-            if (isDebug()) console.log(`${messaging_prefix('debug')} ${messages_isUsingIntegration('Preact')}`);
-            preact_userMessageDelivered = true;
-        }
-        return true;
-    }
-    return false;
-}
-async function maybeUsePreact(projectPath) {
-    if (!isUsingPreact(projectPath)) return;
-    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
-    const resolveFromProject = (id)=>{
-        try {
-            return requireFromProject.resolve(id);
-        } catch  {
-            return;
-        }
-    };
-    const preactPkgJson = resolveFromProject('preact/package.json');
-    const preactDir = preactPkgJson ? __rspack_external_node_path_806ed179.dirname(preactPkgJson) : void 0;
-    const preactCompat = resolveFromProject('preact/compat');
-    const preactTestUtils = resolveFromProject('preact/test-utils');
-    const preactJsxRuntime = resolveFromProject('preact/jsx-runtime');
-    const preactJsxDevRuntime = resolveFromProject('preact/jsx-dev-runtime');
-    const alias = {};
-    if (preactJsxRuntime) alias['preact/jsx-runtime'] = preactJsxRuntime;
-    if (preactJsxDevRuntime) alias['preact/jsx-dev-runtime'] = preactJsxDevRuntime;
-    if (preactDir) alias.preact = preactDir;
-    if (preactCompat) {
-        alias.react = preactCompat;
-        alias['react-dom'] = preactCompat;
-    }
-    if (preactTestUtils) alias['react-dom/test-utils'] = preactTestUtils;
-    if (preactJsxRuntime) alias['react/jsx-runtime'] = preactJsxRuntime;
-    if (preactJsxDevRuntime) alias['react/jsx-dev-runtime'] = preactJsxDevRuntime;
-    return {
-        plugins: [],
-        loaders: void 0,
-        alias
-    };
-}
-let react_userMessageDelivered = false;
-function isUsingReact(projectPath) {
-    if (hasDependency(projectPath, 'react')) {
-        if (!react_userMessageDelivered) {
-            if (isDebug()) console.log(`${messaging_prefix('debug')} ${messages_isUsingIntegration('React')}`);
-            react_userMessageDelivered = true;
-        }
-        return true;
-    }
-    return false;
-}
-async function maybeUseReact(projectPath, options = {}) {
-    if (!isUsingReact(projectPath)) return;
-    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
-    let reactPath;
-    let reactDomPath;
-    let reactDomClientPath;
-    let jsxRuntimePath;
-    let jsxDevRuntimePath;
-    try {
-        reactPath = requireFromProject.resolve('react');
-    } catch  {}
-    try {
-        reactDomPath = requireFromProject.resolve('react-dom');
-    } catch  {}
-    try {
-        reactDomClientPath = requireFromProject.resolve('react-dom/client');
-    } catch  {}
-    try {
-        jsxRuntimePath = requireFromProject.resolve('react/jsx-runtime');
-    } catch  {}
-    try {
-        jsxDevRuntimePath = requireFromProject.resolve('react/jsx-dev-runtime');
-    } catch  {}
-    const alias = {};
-    if (reactPath) alias.react$ = reactPath;
-    if (reactDomPath) alias['react-dom$'] = reactDomPath;
-    if (reactDomClientPath) alias['react-dom/client'] = reactDomClientPath;
-    if (jsxRuntimePath) alias['react/jsx-runtime'] = jsxRuntimePath;
-    if (jsxDevRuntimePath) alias['react/jsx-dev-runtime'] = jsxDevRuntimePath;
-    if (true === options.disableRefresh) return {
-        plugins: [],
-        loaders: void 0,
-        alias
-    };
-    resolveOptionalContractPackageWithoutInstall({
-        contractId: 'react-refresh',
-        projectPath,
-        dependencyId: 'react-refresh'
-    });
-    const ReactRefreshPlugin = loadOptionalContractModuleWithoutInstall({
-        contractId: 'react-refresh',
-        projectPath,
-        dependencyId: '@rspack/plugin-react-refresh',
-        moduleAdapter: (mod)=>mod && (mod.default || mod.ReactRefreshRspackPlugin) || mod
-    });
-    const reactPlugins = [
-        new ReactRefreshPlugin({
-            overlay: false,
-            ...void 0 === options.refreshExclude ? {} : {
-                exclude: options.refreshExclude
-            }
-        })
-    ];
-    return {
-        plugins: reactPlugins,
-        loaders: void 0,
-        alias
-    };
-}
-let solid_userMessageDelivered = false;
-function isUsingSolid(projectPath) {
-    if (hasDependency(projectPath, 'solid-js')) {
-        if (!solid_userMessageDelivered) {
-            if (isDebug()) console.log(`${messaging_prefix('debug')} ${messages_isUsingIntegration('Solid')}`);
-            solid_userMessageDelivered = true;
-        }
-        return true;
-    }
-    return false;
-}
-async function maybeUseSolid(projectPath) {
-    if (!isUsingSolid(projectPath)) return;
-    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
-    const resolveFromProject = (id)=>{
-        try {
-            return requireFromProject.resolve(id);
-        } catch  {
-            return;
-        }
-    };
-    const adapter = resolveDevelopDistFile('solid-jsx-runtime');
-    const hyperscript = resolveFromProject('solid-js/h');
-    const alias = {
-        'solid-js/jsx-runtime$': adapter,
-        'solid-js/jsx-dev-runtime$': adapter
-    };
-    if (hyperscript) alias['solid-js/h$'] = hyperscript;
-    return {
-        plugins: [],
-        loaders: void 0,
-        alias
-    };
-}
-let load_loader_options_userMessageDelivered = false;
-function resolveLoaderConfigPath(projectPath, framework) {
-    const candidates = [
-        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.ts`),
-        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.mts`),
-        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.js`),
-        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.mjs`)
-    ];
-    return candidates.find((p)=>__rspack_external_node_fs_1b05aee1.existsSync(p)) || null;
-}
-async function loadLoaderOptions(projectPath, framework) {
-    const configPath = resolveLoaderConfigPath(projectPath, framework);
-    if (configPath) {
-        if (!load_loader_options_userMessageDelivered && isDebug()) {
-            const display = __rspack_external_node_path_806ed179.basename(configPath);
-            console.log(isUsingCustomLoader(display));
-            load_loader_options_userMessageDelivered = true;
-        }
-        try {
-            const module = await import(pathToFileURL(configPath).href);
-            return module.default || module;
-        } catch (err) {
-            const error = err;
-            console.error(`Error loading ${framework} loader options: ${error.message}`);
-            throw err;
-        }
-    }
-    return null;
-}
-let vue_userMessageDelivered = false;
-function isUsingVue(projectPath) {
-    const using = hasDependency(projectPath, 'vue');
-    if (using && !vue_userMessageDelivered) {
-        if (isDebug()) console.log(`${messaging_prefix('debug')} ${messages_isUsingIntegration('Vue')}`);
-        vue_userMessageDelivered = true;
-    }
-    return using;
-}
-function resolveVueBundlerEntry(requireFromProject, id) {
-    try {
-        const manifestPath = requireFromProject.resolve(`${id}/package.json`);
-        const manifest = JSON.parse(__rspack_external_node_fs_1b05aee1.readFileSync(manifestPath, 'utf8'));
-        if ('string' == typeof manifest.module && manifest.module) {
-            const entry = __rspack_external_node_path_806ed179.join(__rspack_external_node_path_806ed179.dirname(manifestPath), manifest.module);
-            if (__rspack_external_node_fs_1b05aee1.existsSync(entry)) return entry;
-        }
-    } catch  {}
-    try {
-        return requireFromProject.resolve(id);
-    } catch  {
-        return;
-    }
-}
-async function maybeUseVue(projectPath, mode = 'development') {
-    if (!isUsingVue(projectPath)) return;
-    const vueLoaderPath = await ensureOptionalContractPackageResolved({
-        contractId: 'vue',
-        projectPath,
-        dependencyId: 'vue-loader'
-    });
-    const VueLoaderPlugin = await ensureOptionalContractModuleLoaded({
-        contractId: 'vue',
-        projectPath,
-        dependencyId: 'vue-loader',
-        moduleAdapter: (mod)=>mod?.VueLoaderPlugin || mod?.default?.VueLoaderPlugin
-    });
-    const customOptions = await loadLoaderOptions(projectPath, 'vue');
-    const defaultLoaders = [
-        {
-            test: /\.vue$/,
-            loader: vueLoaderPath,
-            options: {
-                experimentalInlineMatchResource: true,
-                ...customOptions || {}
-            },
-            include: projectPath,
-            exclude: /node_modules/
-        }
-    ];
-    const isProd = 'production' === mode;
-    const defaultPlugins = [
-        new VueLoaderPlugin(),
-        new DefinePlugin({
-            __VUE_OPTIONS_API__: JSON.stringify(true),
-            __VUE_PROD_DEVTOOLS__: JSON.stringify(!isProd),
-            __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: JSON.stringify(!isProd)
-        })
-    ];
-    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
-    const resolveFromProject = (id)=>resolveVueBundlerEntry(requireFromProject, id);
-    const alias = {};
-    const vuePath = resolveFromProject('vue');
-    const vueRuntimeDom = resolveFromProject('@vue/runtime-dom');
-    const vueRuntimeCore = resolveFromProject('@vue/runtime-core');
-    const vueShared = resolveFromProject('@vue/shared');
-    if (vuePath) alias.vue$ = vuePath;
-    if (vueRuntimeDom) alias['@vue/runtime-dom'] = vueRuntimeDom;
-    if (vueRuntimeCore) alias['@vue/runtime-core'] = vueRuntimeCore;
-    if (vueShared) alias['@vue/shared'] = vueShared;
-    return {
-        plugins: defaultPlugins,
-        loaders: defaultLoaders,
-        alias
-    };
-}
-function isUsingJsxFramework(projectPath) {
-    return isUsingReact(projectPath) || isUsingPreact(projectPath) || isUsingSolid(projectPath) || isUsingVue(projectPath);
-}
-function getJsxImportSource(projectPath) {
-    if (isUsingSolid(projectPath)) return 'solid-js';
-    if (isUsingPreact(projectPath) && !isUsingReact(projectPath)) return 'preact';
-    if (isUsingVue(projectPath) && !isUsingReact(projectPath) && !isUsingPreact(projectPath)) return 'vue';
-    return 'react';
-}
-function swcParserForFile(resourcePath, jsxInPlainJs) {
-    const clean = String(resourcePath || '').split('?')[0];
-    const ext = __rspack_external_node_path_806ed179.extname(clean).toLowerCase();
-    if ('.tsx' === ext || '.mtsx' === ext) return {
-        syntax: "typescript",
-        tsx: true,
-        dynamicImport: true
-    };
-    if ('.ts' === ext || '.mts' === ext || '.cts' === ext) return {
-        syntax: "typescript",
-        tsx: false,
-        dynamicImport: true
-    };
-    if ('.jsx' === ext || '.mjsx' === ext) return {
-        syntax: "ecmascript",
-        jsx: true,
-        dynamicImport: true
-    };
-    return {
-        syntax: "ecmascript",
-        jsx: jsxInPlainJs,
-        dynamicImport: true
-    };
-}
 let svelte_userMessageDelivered = false;
-function svelte_resolveFromProject(id, projectPath) {
+function resolveFromProject(id, projectPath) {
     for (const base of [
         projectPath,
         process.cwd()
@@ -3246,10 +2989,10 @@ async function maybeUseSvelte(projectPath, mode) {
             }
         }
     ];
-    const sveltePackageJson = svelte_resolveFromProject('svelte/package.json', projectPath);
+    const sveltePackageJson = resolveFromProject('svelte/package.json', projectPath);
     const sveltePackageRoot = sveltePackageJson ? __rspack_external_node_path_806ed179.dirname(sveltePackageJson) : void 0;
     const resolveClientSubpath = (relative)=>{
-        const direct = svelte_resolveFromProject(`svelte/${relative}`, projectPath);
+        const direct = resolveFromProject(`svelte/${relative}`, projectPath);
         if (direct) return direct;
         if (!sveltePackageRoot) return;
         const fromRoot = __rspack_external_node_path_806ed179.join(sveltePackageRoot, relative);
@@ -7179,16 +6922,10 @@ class TraceRun {
 async function compileRuntimeLoadedFiles(compilation, compiler, requests) {
     if (0 === requests.length) return [];
     const before = new Set(compilation.getAssets().map((asset)=>asset.name));
-    for (const format of [
-        'module',
-        'classic'
-    ]){
-        const group = requests.filter((request)=>request.format === format);
-        if (0 !== group.length) await compileTracedFiles({
-            compilation,
-            compiler
-        }, format, group);
-    }
+    for (const request of requests)await compileTracedFile({
+        compilation,
+        compiler
+    }, request);
     return compilation.getAssets().map((asset)=>asset.name).filter((name)=>!before.has(name));
 }
 function planTracedFile(opts) {
@@ -7272,21 +7009,24 @@ function isFile(candidate) {
         return false;
     }
 }
-async function compileTracedFiles(host, format, requests) {
+async function compileTracedFile(host, request) {
     const { compilation, compiler } = host;
-    const isModule = 'module' === format;
-    const chunkLoadingFor = (context)=>isModule ? 'import' : 'importScripts' === context ? "import-scripts" : 'jsonp';
-    const entries = requests.map((request)=>new EntryPlugin(compiler.context, request.sourcePath, {
-            name: request.emitPath.replace(/\.[^./]+$/, ''),
-            filename: request.emitPath,
-            chunkLoading: chunkLoadingFor(request.context),
-            ...isModule ? {
-                library: {
-                    type: 'module'
-                }
-            } : {}
-        }));
-    const child = compilation.createChildCompiler(`${TraceRuntimeLoadedFiles.name}:${format}`, {
+    const isModule = 'module' === request.format;
+    const chunkLoading = isModule ? 'import' : 'importScripts' === request.context ? "import-scripts" : 'jsonp';
+    const entry = new EntryPlugin(compiler.context, request.sourcePath, {
+        name: request.emitPath.replace(/\.[^./]+$/, ''),
+        filename: request.emitPath,
+        chunkLoading,
+        ...isModule ? {
+            library: {
+                type: 'module'
+            }
+        } : {}
+    });
+    const importMetaUrl = new DefinePlugin({
+        'import.meta.url': importMetaUrlForEmitPath(request.emitPath)
+    });
+    const child = compilation.createChildCompiler(`${TraceRuntimeLoadedFiles.name}:${request.format}`, {
         filename: '[name].js',
         module: isModule,
         iife: false,
@@ -7296,8 +7036,11 @@ async function compileTracedFiles(host, format, requests) {
             type: 'module'
         } : void 0,
         clean: false
-    }, entries);
-    for (const type of new Set(requests.map((request)=>chunkLoadingFor(request.context))))new core_javascript.EnableChunkLoadingPlugin(type).apply(child);
+    }, [
+        entry,
+        importMetaUrl
+    ]);
+    new core_javascript.EnableChunkLoadingPlugin(chunkLoading).apply(child);
     if (isModule) new library.EnableLibraryPlugin('module').apply(child);
     child.options.entry = {};
     child.options.optimization = {
@@ -7313,7 +7056,7 @@ async function compileTracedFiles(host, format, requests) {
     await new Promise((resolve)=>{
         child.runAsChild((error, _entries, childCompilation)=>{
             if (error) {
-                const failure = new core_WebpackError(`Compiling runtime-loaded ${requests.map((request)=>request.emitPath).join(', ')} failed: ${error.message}`);
+                const failure = new core_WebpackError(`Compiling runtime-loaded ${request.emitPath} failed: ${error.message}`);
                 failure.name = 'RuntimeLoadedFileCompileFailed';
                 compilation.errors.push(failure);
             }
@@ -10663,6 +10406,71 @@ function partiallyGatedWarning(api, relative) {
     if (!note) return null;
     return `manifest.json does not declare the "${api}" permission, but ${relative} uses chrome.${api}. The dev build injects "${api}" so the same code may behave differently once packaged: ${note}. Add "${api}" to permissions in manifest.json if you read those fields.`;
 }
+const EMITTED_SCRIPT_RE = /\.[cm]?js$/;
+const MAX_SOURCE_BYTES = 1048576;
+const MAX_ASSET_BYTES = 16777216;
+const MAX_COMPRESS_BYTES = 4194304;
+function shippableText(text) {
+    if (text.length > MAX_COMPRESS_BYTES) return text;
+    try {
+        const compressed = experiments?.swc?.minifySync(text, {
+            compress: true,
+            mangle: false
+        });
+        return 'string' == typeof compressed?.code ? compressed.code : text;
+    } catch  {
+        return text;
+    }
+}
+function readEmittedScripts(compilation) {
+    const scripts = new Map();
+    let assets;
+    try {
+        assets = compilation.getAssets?.() || [];
+    } catch  {
+        return scripts;
+    }
+    for (const asset of assets)if (EMITTED_SCRIPT_RE.test(asset.name)) try {
+        const raw = asset.source.source();
+        const text = 'string' == typeof raw ? raw : raw.toString('utf-8');
+        if (text.length > MAX_ASSET_BYTES) continue;
+        scripts.set(asset.name, text);
+    } catch  {}
+    return scripts;
+}
+function readProjectSource(resource) {
+    try {
+        if (__rspack_external_node_fs_1b05aee1.statSync(resource).size > MAX_SOURCE_BYTES) return;
+        return __rspack_external_node_fs_1b05aee1.readFileSync(resource, 'utf-8');
+    } catch  {
+        return;
+    }
+}
+function emittedFilesOf(compilation, module) {
+    if (!compilation.chunkGraph) return;
+    try {
+        const files = [];
+        for (const chunk of compilation.chunkGraph.getModuleChunksIterable(module))for (const file of chunk.files || [])files.push(file);
+        return files;
+    } catch  {
+        return;
+    }
+}
+function patchWebkitBackground(manifest, browser) {
+    if (!isWebkitBasedBrowser(String(browser))) return manifest;
+    const background = manifest.background;
+    if (!background || !background.service_worker || background.scripts) return manifest;
+    const { service_worker, type, ...rest } = background;
+    return {
+        ...manifest,
+        background: {
+            ...rest,
+            scripts: [
+                service_worker
+            ]
+        }
+    };
+}
 function persistentPatchFor(manifest) {
     return 3 === manifest.manifest_version ? {} : {
         persistent: true
@@ -10690,12 +10498,16 @@ function patchBackground(manifest, browser) {
                 ...persistentPatchFor(manifest)
             }
         };
-        return {
+        const injected = {
+            ...manifest,
             background: {
                 ...manifest.background || {},
                 service_worker: 'background/service_worker.js'
             }
         };
+        return {
+            background: patchWebkitBackground(injected, browser).background
+        };
     }
     return {
         background: {
@@ -10841,87 +10653,88 @@ function patchExternallyConnectable(manifest) {
     };
     return {};
 }
+function cleanMatches(matches) {
+    return matches.map((match)=>{
+        try {
+            const url = new URL(match.replace(/^\*:\/\//, 'https://'));
+            if (match.endsWith(url.pathname)) return `${match.substring(0, match.length - url.pathname.length)}/*`;
+            if ('/' === url.pathname) return `${match}/*`;
+            return match;
+        } catch  {
+            return match;
+        }
+    });
+}
+const DEV_RUNTIME_RESOURCES = [
+    'hot/*',
+    'extension-js-control.json'
+];
+function patch_web_resources_contentScriptMatches(manifest) {
+    const scripts = manifest.content_scripts || [];
+    return Array.from(new Set(cleanMatches(scripts.flatMap((script)=>script.matches || [])))).sort();
+}
 function patchWebResourcesV2(manifest) {
-    const defaultResources = [
-        '/*.json',
-        '/*.js',
-        '/*.css',
-        '/*.scss',
-        '/*.sass',
-        '/*.less',
-        '*.styl',
-        "/scripts/*.js",
-        "/scripts/*.css",
-        '/hot/*',
-        '/*.png',
-        '/*.jpg',
-        '/*.jpeg',
-        '/*.svg',
-        '/*.gif',
-        '/*.webp',
-        '/*.ico',
-        '/*.avif',
-        '/*.wasm',
-        '/*.bin'
-    ];
     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);
+    const webResources = new Set(resources || []);
+    if (0 === patch_web_resources_contentScriptMatches(manifest).length) return Array.from(webResources);
+    for (const resource of DEV_RUNTIME_RESOURCES)webResources.add(resource);
     return Array.from(webResources);
 }
 function patchWebResourcesV3(manifest) {
-    const defaultResources = [
-        '/*.json',
-        '/*.js',
-        '/*.css',
-        '/*.scss',
-        '/*.sass',
-        '/*.less',
-        '*.styl',
-        "/scripts/*.js",
-        "/scripts/*.css",
-        '/hot/*',
-        '/*.png',
-        '/*.jpg',
-        '/*.jpeg',
-        '/*.svg',
-        '/*.gif',
-        '/*.webp',
-        '/*.ico',
-        '/*.avif',
-        '/*.wasm',
-        '/*.bin'
-    ];
+    const existing = manifest.web_accessible_resources || [];
+    const matches = patch_web_resources_contentScriptMatches(manifest);
+    if (0 === matches.length) return existing;
     return [
-        ...manifest.web_accessible_resources || [],
+        ...existing,
         {
-            resources: defaultResources,
-            matches: [
-                '<all_urls>'
-            ]
+            resources: [
+                ...DEV_RUNTIME_RESOURCES
+            ],
+            matches
         }
     ];
 }
+function patchWebResources(manifest) {
+    const patched = 3 === manifest.manifest_version ? patchWebResourcesV3(manifest) : patchWebResourcesV2(manifest);
+    if (!patched.length) return {};
+    return {
+        web_accessible_resources: patched
+    };
+}
 function findInjectedOnlyPermissionUses(compilation, declared, injected) {
     const firstOffenderByApi = new Map();
     const candidates = injected.filter((api)=>!declared.has(api));
     if (!candidates.length) return firstOffenderByApi;
-    for (const module of compilation.modules){
-        const resource = scannableSourcePath(module.resource);
-        if (!resource) continue;
-        let source;
-        try {
-            const stat = __rspack_external_node_fs_1b05aee1.statSync(resource);
-            if (stat.size > 1048576) continue;
-            source = __rspack_external_node_fs_1b05aee1.readFileSync(resource, 'utf-8');
-        } catch  {
-            continue;
-        }
-        for (const api of candidates){
-            if (firstOffenderByApi.has(api)) continue;
-            const useRe = new RegExp(`\\b(?:chrome|browser)\\s*\\.\\s*${api}\\b`);
-            if (useRe.test(source)) firstOffenderByApi.set(api, resource);
+    const emitted = readEmittedScripts(compilation);
+    const shipped = new Map();
+    const shippedText = (file)=>{
+        if (shipped.has(file)) return shipped.get(file);
+        const text = emitted.get(file);
+        if (void 0 === text) return;
+        const compressed = shippableText(text);
+        shipped.set(file, compressed);
+        return compressed;
+    };
+    for (const outer of compilation.modules){
+        const inner = outer.modules ? [
+            ...outer.modules
+        ] : [
+            outer
+        ];
+        for (const module of inner){
+            const resource = scannableSourcePath(module.resource);
+            if (!resource) continue;
+            const source = readProjectSource(resource);
+            if (void 0 !== source) for (const api of candidates){
+                if (firstOffenderByApi.has(api)) continue;
+                const useRe = new RegExp(`\\b(?:chrome|browser)\\s*\\.\\s*${api}\\b`);
+                if (!useRe.test(source)) continue;
+                const files = emittedFilesOf(compilation, outer);
+                if (!files || files.some((file)=>{
+                    const text = shippedText(file);
+                    return void 0 !== text && useRe.test(text);
+                })) firstOffenderByApi.set(api, resource);
+            }
         }
         if (firstOffenderByApi.size === candidates.length) break;
     }
@@ -11002,7 +10815,7 @@ class ApplyDevDefaults {
                     ...hostPermissionsPatch,
                     ...patchBackground(canonicalManifest, this.browser),
                     ...patchExternallyConnectable(canonicalManifest),
-                    web_accessible_resources: 3 === canonicalManifest.manifest_version ? patchWebResourcesV3(canonicalManifest) : patchWebResourcesV2(canonicalManifest)
+                    ...patchWebResources(canonicalManifest)
                 };
                 try {
                     const declared = new Set(canonicalManifest.permissions || []);
@@ -11242,6 +11055,17 @@ function collectContentScriptAsyncChunkFiles(compilation) {
     });
     return result;
 }
+function collectPageContextEntryFiles(compilation) {
+    const result = {};
+    if ('function' != typeof compilation.entrypoints?.forEach) return result;
+    compilation.entrypoints.forEach((entry, entryName)=>{
+        if (!isPageContextEntry(String(entryName))) return;
+        const files = new Set();
+        for (const chunk of toFileArray(entry.chunks))for (const file of toFileArray(chunk.files))if (file.endsWith('.js')) files.add(unixify(file));
+        if (files.size > 0) result[String(entryName)] = Array.from(files).sort();
+    });
+    return result;
+}
 function collectContentScriptEntryImports(compilation, includeList) {
     const entryImports = {};
     const contentEntryNames = new Set(Object.keys(includeList || {}).filter((k)=>isPageContextEntry(k)));
@@ -11312,18 +11136,6 @@ function collectContentScriptEntryImports(compilation, includeList) {
     }
     return entryImports;
 }
-function cleanMatches(matches) {
-    return matches.map((match)=>{
-        try {
-            const url = new URL(match.replace(/^\*:\/\//, 'https://'));
-            if (match.endsWith(url.pathname)) return `${match.substring(0, match.length - url.pathname.length)}/*`;
-            if ('/' === url.pathname) return `${match}/*`;
-            return match;
-        } catch  {
-            return match;
-        }
-    });
-}
 function warFieldError(filePath, opts) {
     const displayPath = opts?.overrideNotFoundPath || filePath;
     const lines = [];
@@ -11366,6 +11178,14 @@ function warInvalidMatchPattern(pattern) {
     lines.push(`Update the pattern in your ${pintor.blue('manifest.json')} file. See ${pintor.underline('https://developer.chrome.com/docs/extensions/reference/manifest/web-accessible-resources#manifest_declaration')} for the format.`);
     return lines.join('\n');
 }
+function warUnreachableResource(resource, entryName) {
+    const lines = [];
+    lines.push(`${pintor.underline(entryName)} asks the extension for ${pintor.blue(resource)}, but ${pintor.blue('web_accessible_resources')} does not list it.`);
+    lines.push("The browser refuses it with a SecurityError because a content script reads extension files with the page's origin.");
+    lines.push(`Add it to ${pintor.blue('web_accessible_resources')} in ${pintor.blue('manifest.json')}, scoped to the matches that need it.`);
+    lines.push(`Learn more: ${pintor.underline('https://extension.js.org/docs/development/web-accessible-resources')}`);
+    return lines.join('\n');
+}
 function entryImportsSummary(entryCount, totalResources) {
     return `${messaging_prefix('debug')} war      entryImports entries=${String(entryCount)} resources=${String(totalResources)}`;
 }
@@ -11609,6 +11429,54 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
         v3
     };
 }
+function normalizeResourcePath(value) {
+    return String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '');
+}
+function escapeRegex(value) {
+    return value.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+}
+function globToRegex(pattern) {
+    const escaped = pattern.split('*').map((segment)=>escapeRegex(segment)).join('.*');
+    return new RegExp(`^${escaped}$`);
+}
+function isResourceCovered(declared, candidate) {
+    const target = normalizeResourcePath(candidate);
+    for (const entry of declared){
+        const pattern = normalizeResourcePath(entry);
+        if (pattern === target) return true;
+        if (pattern.includes('*')) try {
+            if (globToRegex(pattern).test(target)) return true;
+        } catch  {}
+    }
+    return false;
+}
+const GET_URL_LITERAL_PATTERN = /getURL\s*\(\s*["'`]([^"'`\n)]+)["'`]\s*\)/g;
+const MAX_SCANNED_SOURCE_BYTES = 4194304;
+function collectGetUrlLiterals(source) {
+    if (!source || source.length > MAX_SCANNED_SOURCE_BYTES) return [];
+    const found = new Set();
+    const pattern = new RegExp(GET_URL_LITERAL_PATTERN.source, 'g');
+    let match = pattern.exec(source);
+    while(match){
+        const name = normalizeResourcePath(match[1]);
+        if (name && !name.includes('${')) found.add(name);
+        match = pattern.exec(source);
+    }
+    return Array.from(found).sort();
+}
+const TOOLING_RESOURCES = new Set([
+    'manifest.json',
+    'extension-js-control.json'
+]);
+function findUnreachableRuntimeResources(options) {
+    const emitted = new Set(options.emittedAssetNames.map((name)=>normalizeResourcePath(name)));
+    return collectGetUrlLiterals(options.source).filter((name)=>{
+        if (TOOLING_RESOURCES.has(name)) return false;
+        if (name.startsWith('hot/')) return false;
+        if (!emitted.has(name)) return false;
+        return !isResourceCovered(options.declaredResources, name);
+    });
+}
 function generate_manifest_getAssetSource(compilation, filename) {
     const byGet = 'function' == typeof compilation.getAsset ? compilation.getAsset(filename) : void 0;
     const byAssets = !byGet && compilation.assets ? compilation.assets[filename] : void 0;
@@ -11636,16 +11504,16 @@ function generate_manifest_getAssetSource(compilation, filename) {
 function hasWildcardPattern(pattern) {
     return /[*?[\]]/.test(pattern);
 }
-function escapeRegex(s) {
+function generate_manifest_escapeRegex(s) {
     return s.replace(/[.+^${}()|\\]/g, '\\$&');
 }
-function globToRegex(pattern) {
-    const escaped = pattern.split('*').map((seg)=>escapeRegex(seg)).join('.*');
+function generate_manifest_globToRegex(pattern) {
+    const escaped = pattern.split('*').map((seg)=>generate_manifest_escapeRegex(seg)).join('.*');
     return new RegExp(`^${escaped}$`);
 }
 function isCoveredByExistingGlobs(existingPatterns, candidate) {
     for (const existingPattern of existingPatterns)if (hasWildcardPattern(existingPattern)) try {
-        const re = globToRegex(existingPattern);
+        const re = generate_manifest_globToRegex(existingPattern);
         if (re.test(candidate)) return true;
     } catch  {}
     return false;
@@ -11686,6 +11554,42 @@ function toCanonicalContentScriptCss(jsFile) {
     if (!/^content_scripts\/content-\d+\.js$/.test(normalized)) return;
     return normalized.replace(/\.js$/, '.css');
 }
+function declaredWarResources(manifest) {
+    const war = manifest.web_accessible_resources;
+    if (!Array.isArray(war)) return [];
+    return war.flatMap((entry)=>{
+        if ('string' == typeof entry) return [
+            entry
+        ];
+        const resources = entry.resources;
+        return Array.isArray(resources) ? resources.map((r)=>String(r)) : [];
+    });
+}
+function warnOnUnreachableResources(compilation, manifest) {
+    try {
+        const declared = declaredWarResources(manifest);
+        const emittedAssetNames = listEmittedAssetNames(compilation);
+        const entryFiles = collectPageContextEntryFiles(compilation);
+        const reported = new Set();
+        for (const [entryName, files] of Object.entries(entryFiles))for (const file of files){
+            const unreachable = findUnreachableRuntimeResources({
+                source: generate_manifest_getAssetSource(compilation, file),
+                emittedAssetNames,
+                declaredResources: declared
+            });
+            for (const resource of unreachable){
+                const key = `${entryName}:${resource}`;
+                if (reported.has(key)) continue;
+                reported.add(key);
+                compilation.warnings = compilation.warnings || [];
+                const warning = new core_WebpackError(warUnreachableResource(resource, entryName));
+                warning.name = 'UnreachableWebAccessibleResourceWarning';
+                warning.file = file;
+                compilation.warnings.push(warning);
+            }
+        }
+    } catch  {}
+}
 function generateManifestPatches(compilation, manifestPath, entryImports, browser) {
     const canonicalManifest = getManifestContent(compilation, manifestPath);
     const resolved = resolveUserDeclaredWAR(compilation, manifestPath, canonicalManifest, browser);
@@ -11825,6 +11729,7 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
                 matches: Array.from(new Set(entry.matches)).sort()
             })).sort((a, b)=>a.matches.join(',').localeCompare(b.matches.join(',')));
     } else if (webAccessibleResourcesV2.length > 0) canonicalManifest.web_accessible_resources = Array.from(new Set(webAccessibleResourcesV2)).sort();
+    warnOnUnreachableResources(compilation, canonicalManifest);
     const source = JSON.stringify(canonicalManifest, null, 2);
     const rawSource = new core_sources.RawSource(source);
     setCurrentManifestContent(compilation, source);
@@ -13130,21 +13035,6 @@ function patchGeckoBackground(manifest, browser) {
         }
     };
 }
-function patchWebkitBackground(manifest, browser) {
-    if (!isWebkitBasedBrowser(String(browser))) return manifest;
-    const background = manifest.background;
-    if (!background || !background.service_worker || background.scripts) return manifest;
-    const { service_worker, type, ...rest } = background;
-    return {
-        ...manifest,
-        background: {
-            ...rest,
-            scripts: [
-                service_worker
-            ]
-        }
-    };
-}
 const webkitUnsupportedApis = {
     sidePanel: safariSidePanelUnsupported,
     offscreen: safariOffscreenUnsupported,
@@ -13305,48 +13195,26 @@ function scanTargets(manifestVersion, engine) {
     });
     return targets;
 }
-const EMITTED_SCRIPT_RE = /\.[cm]?js$/;
-const MAX_SOURCE_BYTES = 1048576;
-const MAX_ASSET_BYTES = 16777216;
-function readEmittedScripts(compilation) {
-    const scripts = new Map();
-    let assets;
-    try {
-        assets = compilation.getAssets?.() || [];
-    } catch  {
-        return scripts;
-    }
-    for (const asset of assets)if (EMITTED_SCRIPT_RE.test(asset.name)) try {
-        const raw = asset.source.source();
-        const text = 'string' == typeof raw ? raw : raw.toString('utf-8');
-        if (text.length > MAX_ASSET_BYTES) continue;
-        scripts.set(asset.name, text);
-    } catch  {}
-    return scripts;
-}
-function readProjectSource(resource) {
-    try {
-        if (__rspack_external_node_fs_1b05aee1.statSync(resource).size > MAX_SOURCE_BYTES) return;
-        return __rspack_external_node_fs_1b05aee1.readFileSync(resource, 'utf-8');
-    } catch  {
-        return;
-    }
-}
-function emittedFilesOf(compilation, module) {
-    if (!compilation.chunkGraph) return;
-    try {
-        const files = [];
-        for (const chunk of compilation.chunkGraph.getModuleChunksIterable(module))for (const file of chunk.files || [])files.push(file);
-        return files;
-    } catch  {
-        return;
-    }
-}
 function findGeckoUnsupportedApiUses(compilation, manifestVersion, engine = 'gecko', requireEmittedEvidence = false) {
     const targets = scanTargets(manifestVersion, engine);
     const emitted = readEmittedScripts(compilation);
     const explained = new Set();
     const uses = new Map();
+    const shipped = new Map();
+    const shippedText = (file)=>{
+        if (shipped.has(file)) return shipped.get(file);
+        const text = emitted.get(file);
+        if (void 0 === text) return;
+        const compressed = requireEmittedEvidence ? shippableText(text) : text;
+        shipped.set(file, compressed);
+        return compressed;
+    };
+    const carries = (file, target)=>{
+        const raw = emitted.get(file);
+        if (void 0 === raw || !target.test(raw)) return false;
+        const text = shippedText(file);
+        return void 0 !== text && target.test(text);
+    };
     for (const outer of compilation.modules){
         const inner = outer.modules ? [
             ...outer.modules
@@ -13362,10 +13230,7 @@ function findGeckoUnsupportedApiUses(compilation, manifestVersion, engine = 'gec
                 if (uses.has(key) || !target.test(source)) continue;
                 const files = emittedFilesOf(compilation, outer);
                 if (files) {
-                    const carrying = files.filter((file)=>{
-                        const text = emitted.get(file);
-                        return void 0 !== text && target.test(text);
-                    });
+                    const carrying = files.filter((file)=>carries(file, target));
                     if (!carrying.length) continue;
                     for (const file of carrying)explained.add(`${target.key}\0${file}`);
                 } else if (requireEmittedEvidence) continue;
@@ -13383,9 +13248,9 @@ function findGeckoUnsupportedApiUses(compilation, manifestVersion, engine = 'gec
     if (!compilation.chunkGraph) return [
         ...uses.values()
     ];
-    for (const [name, text] of emitted)for (const target of targets){
+    for (const name of emitted.keys())for (const target of targets){
         const key = `${target.key}\0${name}`;
-        if (!explained.has(key) && target.test(text)) uses.set(key, {
+        if (!explained.has(key) && carries(name, target)) uses.set(key, {
             api: target.api,
             ...target.member ? {
                 member: target.member
@@ -13471,6 +13336,7 @@ class UpdateManifest {
                 if (dropReason) reportToCompilation(compilation, compiler, 'conflicts' === dropReason ? pageActionDroppedForBrowserAction(String(this.browser)) : pageActionNotSupportedByBrowser(String(this.browser)), 'warning', 'manifest.json');
                 if (hasMv2SandboxPolicy(forBrowser)) reportToCompilation(compilation, compiler, mv2SandboxPolicyDropped(String(this.browser)), 'warning', 'manifest.json');
                 for (const dropped of findDroppedVendorKeys(manifest, this.browser))if (dropped.appliedBefore) reportToCompilation(compilation, compiler, vendorPrefixedKeyDropped(dropped.path, dropped.familyPath, dropped.vendor, String(this.browser)), 'warning', 'manifest.json');
+                if (!isValidManifestVersion(forBrowser.manifest_version)) reportToCompilation(compilation, compiler, manifestVersionLostForBrowser(String(this.browser), findPrefixedManifestVersionKeys(manifest), forBrowser.manifest_version), 'error', 'manifest.json');
                 const projectPath = compiler.options.context || __rspack_external_node_path_806ed179.dirname(this.manifestPath);
                 let patchedManifest = buildCanonicalManifest(this.manifestPath, manifest, this.browser, projectPath);
                 if ('production' === compiler.options.mode) {
@@ -14029,6 +13895,100 @@ function parsesAsModule(source) {
         return false;
     }
 }
+const WORKER_FROM_URL = /new\s+Worker\s*\(\s*(?:\/\*[\s\S]*?\*\/\s*)?new\s+URL\s*\(/;
+const EXTENSION_BASES = [
+    /^import\.meta\.url$/,
+    /^[A-Za-z_$][\w$]*\.b$/,
+    /^(?:chrome|browser)\.runtime\.getURL\(/,
+    /^["'`](?:chrome-extension|moz-extension|safari-web-extension):\/\//
+];
+const JS_ASSET = /\.m?js$/i;
+function readCallArguments(source, from) {
+    const args = [];
+    let depth = 0;
+    let start = from;
+    for(let i = from; i < source.length; i++){
+        const char = source[i];
+        if ('"' === char || "'" === char || '`' === char) {
+            i = skipQuoted(source, i, char);
+            continue;
+        }
+        if ('/' === char && '*' === source[i + 1]) {
+            const end = source.indexOf('*/', i + 2);
+            i = -1 === end ? source.length : end + 1;
+            continue;
+        }
+        if ('/' === char && '/' === source[i + 1]) {
+            const end = source.indexOf('\n', i + 2);
+            i = -1 === end ? source.length : end;
+            continue;
+        }
+        if ('(' === char || '[' === char || '{' === char) {
+            depth++;
+            continue;
+        }
+        if (')' === char || ']' === char || '}' === char) {
+            if (0 === depth) {
+                args.push(source.slice(start, i));
+                return args;
+            }
+            depth--;
+            continue;
+        }
+        if (',' === char && 0 === depth) {
+            args.push(source.slice(start, i));
+            start = i + 1;
+        }
+    }
+}
+function skipQuoted(source, from, quote) {
+    for(let i = from + 1; i < source.length; i++){
+        if ('\\' === source[i]) {
+            i++;
+            continue;
+        }
+        if (source[i] === quote) return i;
+    }
+    return source.length;
+}
+function resolvesAgainstExtension(base) {
+    const text = (base ?? '').replace(/\s+/g, '');
+    if (!text) return true;
+    return EXTENSION_BASES.some((shape)=>shape.test(text));
+}
+function startsWorkerFromExtensionUrl(source) {
+    const call = new RegExp(WORKER_FROM_URL.source, 'g');
+    let match = call.exec(source);
+    while(match){
+        const args = readCallArguments(source, match.index + match[0].length);
+        if (args && resolvesAgainstExtension(args[1])) return true;
+        match = call.exec(source);
+    }
+    return false;
+}
+class WarnPageContextWorker {
+    apply(compiler) {
+        if (!compiler?.hooks?.thisCompilation?.tap) return;
+        compiler.hooks.thisCompilation.tap("scripts:warn-page-context-worker", (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: "scripts:warn-page-context-worker",
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT
+            }, ()=>{
+                for (const asset of compilation.getAssets()){
+                    const name = String(asset.name || '');
+                    if (!JS_ASSET.test(name)) continue;
+                    const surface = classifyEntrySurface(name);
+                    if ("content_script" !== surface && "script" !== surface) continue;
+                    const source = String(asset.source?.source() || '');
+                    if (!startsWorkerFromExtensionUrl(source)) continue;
+                    const warning = new core_WebpackError(workerStartedFromPageContext(name, surface));
+                    warning.file = name;
+                    compilation.warnings.push(warning);
+                }
+            });
+        });
+    }
+}
 class WarnSplitInitialChunks {
     apply(compiler) {
         if (!compiler?.hooks?.thisCompilation?.tap) return;
@@ -14085,6 +14045,7 @@ class ScriptsPlugin {
         if ('production' === compiler.options.mode) new AddPublicPathRuntimeModule().apply(compiler);
         new ValidateEmittedScriptSyntax().apply(compiler);
         new WarnSplitInitialChunks().apply(compiler);
+        new WarnPageContextWorker().apply(compiler);
     }
 }
 class CollectContentEntryImports {
@@ -14883,6 +14844,12 @@ function webpackConfig(projectStructure, devOptions) {
         optimization: {
             emitOnErrors: false,
             minimize: 'production' === devOptions.mode,
+            minimizer: [
+                new SwcJsMinimizerRspackPlugin(),
+                new LightningCssMinimizerRspackPlugin({
+                    removeUnusedLocalIdents: false
+                })
+            ],
             sideEffects: true,
             usedExports: 'global',
             concatenateModules: 'production' === devOptions.mode,