extension-develop 3.18.4 → 3.18.5-canary.local-b4fd0431

package/dist/0~rspack-config.mjs

@@ -12,13 +12,14 @@ import { getManifestFieldsData } from "browser-extension-manifest-fields";
 import content_security_policy_parser from "content-security-policy-parser";
 import path_0 from "path";
 import fs from "fs";
-import { getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName, EXTENSIONJS_CONTENT_SCRIPT_LAYER } from "./526.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 { getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName, EXTENSIONJS_CONTENT_SCRIPT_LAYER } from "./291.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 "./839.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 "./101.mjs";
 import { scrubBrand, makeSanitizedConsole } from "./0~branding.mjs";
-import { findNearestPackageJsonSync, backgroundIsRequiredMessageOnly } from "./314.mjs";
+import { findNearestPackageJsonSync, backgroundIsRequiredMessageOnly } from "./224.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
+var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 import * as __rspack_external_path from "path";
 import * as __rspack_external_fs from "fs";
 import * as __rspack_external_dotenv from "dotenv";
@@ -29,16 +30,33 @@ __webpack_require__.r(rspack_config_namespaceObject);
 __webpack_require__.d(rspack_config_namespaceObject, {
     default: ()=>webpackConfig
 });
+__rspack_external_path.join(process.cwd(), 'node_modules/extension-develop/dist/certs');
+const CHROMIUM_BASED_BROWSERS = [
+    'chrome',
+    'edge',
+    'brave',
+    'opera',
+    'vivaldi',
+    'yandex'
+];
+const GECKO_BASED_BROWSERS = [
+    'firefox',
+    'waterfox',
+    'librewolf'
+];
+[
+    ...CHROMIUM_BASED_BROWSERS,
+    ...GECKO_BASED_BROWSERS
+];
+function isChromiumBasedBrowser(browser) {
+    return CHROMIUM_BASED_BROWSERS.includes(browser) || String(browser).includes('chromium');
+}
+function isGeckoBasedBrowser(browser) {
+    return GECKO_BASED_BROWSERS.includes(browser) || String(browser).includes('gecko') || String(browser).includes('firefox');
+}
 function filterKeysForThisBrowser(manifest, browser) {
-    const CHROMIUM_BASED_BROWSERS = [
-        'chrome',
-        'edge'
-    ];
-    const GECKO_BASED_BROWSERS = [
-        'firefox'
-    ];
-    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 isChromiumTarget = isChromiumBasedBrowser(String(browser)) || 'safari' === browser || 'webkit-based' === browser || String(browser).includes('webkit');
+    const isGeckoTarget = isGeckoBasedBrowser(String(browser));
     const chromiumPrefixes = new Set([
         'chromium',
         'chrome',
@@ -375,7 +393,9 @@ function getFilename(feature, filePath) {
         '.js',
         '.jsx',
         '.tsx',
-        '.ts'
+        '.ts',
+        '.vue',
+        '.svelte'
     ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.js');
     if ([
         '.html',
@@ -399,10 +419,7 @@ function background_background(manifest) {
             ...manifest.background,
             ...manifest.background.scripts && {
                 scripts: [
-                    ...manifest.background.scripts.map((script)=>(()=>{
-                            const raw = String(script);
-                            return getFilename("background/scripts.js", raw);
-                        })())
+                    ...new Set(manifest.background.scripts.map((script)=>getFilename("background/scripts.js", String(script))))
                 ]
             }
         }
@@ -426,12 +443,12 @@ function browserAction(manifest) {
             ...manifest.browser_action.default_icon && {
                 default_icon: 'string' == typeof manifest.browser_action.default_icon ? (()=>{
                     const raw = String(manifest.browser_action.default_icon);
-                    const isPublic = /^(?:\/.+|(?:\.\/)?public\/)/i.test(raw);
+                    const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
                     const target = isPublic ? normalizeManifestOutputPath(raw) : `icons/${__rspack_external_path.basename(raw)}`;
                     return getFilename(target, raw);
                 })() : Object.fromEntries(Object.entries(manifest.browser_action.default_icon).map(([size, icon])=>{
                     const raw = String(icon);
-                    const isPublic = /^(?:\/.+|(?:\.\/)?public\/)/i.test(raw);
+                    const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
                     const target = isPublic ? normalizeManifestOutputPath(raw) : `icons/${__rspack_external_path.basename(raw)}`;
                     return [
                         size,
@@ -445,7 +462,7 @@ function browserAction(manifest) {
                         ...themeIcon.light && {
                             light: (()=>{
                                 const raw = String(themeIcon.light);
-                                const isPublic = /^(?:\/.+|(?:\.\/)?public\/)/i.test(raw);
+                                const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
                                 const target = isPublic ? normalizeManifestOutputPath(raw) : `browser_action/${__rspack_external_path.basename(raw)}`;
                                 return getFilename(target, raw);
                             })()
@@ -453,7 +470,7 @@ function browserAction(manifest) {
                         ...themeIcon.dark && {
                             dark: (()=>{
                                 const raw = String(themeIcon.dark);
-                                const isPublic = /^(?:\/.+|(?:\.\/)?public\/)/i.test(raw);
+                                const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
                                 const target = isPublic ? normalizeManifestOutputPath(raw) : `browser_action/${__rspack_external_path.basename(raw)}`;
                                 return getFilename(target, raw);
                             })()
@@ -497,12 +514,12 @@ function pageAction(manifest) {
             ...manifest.page_action.default_icon && {
                 default_icon: 'string' == typeof manifest.page_action.default_icon ? (()=>{
                     const raw = String(manifest.page_action.default_icon);
-                    const isPublic = /^(?:\/.+|(?:\.\/)?public\/)/i.test(raw);
+                    const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
                     const target = isPublic ? normalizeManifestOutputPath(raw) : `icons/${__rspack_external_path.basename(raw)}`;
                     return getFilename(target, raw);
                 })() : Object.fromEntries(Object.entries(manifest.page_action.default_icon).map(([size, icon])=>{
                     const raw = String(icon);
-                    const isPublic = /^(?:\/.+|(?:\.\/)?public\/)/i.test(raw);
+                    const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
                     const target = isPublic ? normalizeManifestOutputPath(raw) : `icons/${__rspack_external_path.basename(raw)}`;
                     return [
                         size,
@@ -523,12 +540,12 @@ function sidebarAction(manifest) {
             ...manifest.sidebar_action.default_icon && {
                 default_icon: 'string' == typeof manifest.sidebar_action.default_icon ? (()=>{
                     const raw = String(manifest.sidebar_action.default_icon);
-                    const isPublic = /^(?:\/.+|(?:\.\/)?public\/)/i.test(raw);
+                    const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
                     const target = isPublic ? normalizeManifestOutputPath(raw) : `icons/${__rspack_external_path.basename(raw)}`;
                     return getFilename(target, raw);
                 })() : Object.fromEntries(Object.entries(manifest.sidebar_action.default_icon).map(([size, icon])=>{
                     const raw = String(icon);
-                    const isPublic = /^(?:\/.+|(?:\.\/)?public\/)/i.test(raw);
+                    const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
                     const target = isPublic ? normalizeManifestOutputPath(raw) : `icons/${__rspack_external_path.basename(raw)}`;
                     return [
                         size,
@@ -545,7 +562,7 @@ function themeExperiment(manifest) {
     return te && {
         theme_experiment: {
             ...te,
-            ...te.stylesheet && {
+            ...'string' == typeof te.stylesheet && {
                 stylesheet: getFilename(`theme_experiment/${getBasename(te.stylesheet)}`, te.stylesheet)
             },
             ...Array.isArray(te.stylesheets) && {
@@ -574,12 +591,12 @@ function action_action(manifest) {
             ...manifest.action.default_icon && {
                 default_icon: 'string' == typeof manifest.action.default_icon ? (()=>{
                     const raw = String(manifest.action.default_icon);
-                    const isPublic = /^(?:\/.+|(?:\.\/)?public\/)/i.test(raw);
+                    const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
                     const target = isPublic ? normalizeManifestOutputPath(raw) : `icons/${__rspack_external_path.basename(raw)}`;
                     return getFilename(target, raw);
                 })() : Object.fromEntries(Object.entries(manifest.action.default_icon).map(([size, icon])=>{
                     const raw = String(icon);
-                    const isPublic = /^(?:\/.+|(?:\.\/)?public\/)/i.test(raw);
+                    const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
                     const target = isPublic ? normalizeManifestOutputPath(raw) : `icons/${__rspack_external_path.basename(raw)}`;
                     return [
                         size,
@@ -753,7 +770,7 @@ function icons_icons(manifest) {
     return manifest.icons && {
         icons: Object.fromEntries(Object.entries(manifest.icons).map(([size, icon])=>{
             const raw = String(icon);
-            const isPublic = /^(?:\/.+|(?:\.\/)?public\/)/i.test(raw);
+            const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
             const target = isPublic ? normalizeManifestOutputPath(raw) : `icons/${__rspack_external_path.basename(raw)}`;
             return [
                 size,
@@ -817,6 +834,7 @@ function storage(manifest) {
     };
 }
 const theme_getBasename = (filepath)=>__rspack_external_path.basename(filepath);
+const rewriteThemeImage = (value)=>getFilename(`theme/images/${theme_getBasename(value)}`, value);
 function theme(manifest) {
     return manifest.theme && {
         theme: {
@@ -824,7 +842,7 @@ function theme(manifest) {
             ...manifest.theme.images && {
                 images: Object.fromEntries(Object.entries(manifest.theme.images).map(([key, value])=>[
                         key,
-                        getFilename(`theme/images/${theme_getBasename(value)}`, value)
+                        Array.isArray(value) ? value.map(rewriteThemeImage) : rewriteThemeImage(value)
                     ]))
             }
         }
@@ -851,16 +869,18 @@ function normalizeOutputPath(originalPath) {
 }
 function webAccessibleResources(manifest) {
     if (!manifest.web_accessible_resources || !manifest.web_accessible_resources.length) return;
-    if (Array.isArray(manifest.web_accessible_resources) && 'string' == typeof manifest.web_accessible_resources[0]) return {
-        web_accessible_resources: manifest.web_accessible_resources.map((resource)=>getFilename(normalizeOutputPath(resource), resource))
-    };
-    const v3 = manifest.web_accessible_resources.filter((entry)=>Array.isArray(entry.resources)).map((entry)=>({
+    const mapResource = (resource)=>getFilename(normalizeOutputPath(resource), resource);
+    const entries = manifest.web_accessible_resources.map((entry)=>{
+        if ('string' == typeof entry) return mapResource(entry);
+        if (!entry || !Array.isArray(entry.resources)) return;
+        return {
             ...entry,
-            resources: (entry.resources || []).map((res)=>getFilename(normalizeOutputPath(res), res))
-        }));
-    if (0 === v3.length) return;
+            resources: entry.resources.map(mapResource)
+        };
+    }).filter((entry)=>void 0 !== entry);
+    if (0 === entries.length) return;
     return {
-        web_accessible_resources: v3
+        web_accessible_resources: entries
     };
 }
 function contentSecurityPolicy(manifest) {
@@ -869,12 +889,13 @@ function contentSecurityPolicy(manifest) {
     };
 }
 const omnibox_getBasename = (filepath)=>__rspack_external_path.basename(filepath);
-function omnibox(manifest) {
-    return manifest.omnibox && {
+function omnibox_omnibox(manifest) {
+    const omnibox = manifest.omnibox;
+    return omnibox && {
         omnibox: {
-            ...manifest.omnibox,
-            ...manifest.omnibox.default_icon && {
-                default_icon: 'string' == typeof manifest.omnibox.default_icon ? getFilename(`icons/${omnibox_getBasename(manifest.omnibox.default_icon)}`, manifest.omnibox.default_icon) : Object.fromEntries(Object.entries(manifest.omnibox.default_icon).map(([size, icon])=>[
+            ...omnibox,
+            ...omnibox.default_icon && {
+                default_icon: 'string' == typeof omnibox.default_icon ? getFilename(`icons/${omnibox_getBasename(omnibox.default_icon)}`, omnibox.default_icon) : Object.fromEntries(Object.entries(omnibox.default_icon).map(([size, icon])=>[
                         size,
                         getFilename(`icons/${omnibox_getBasename(icon)}`, icon)
                     ]))
@@ -899,7 +920,7 @@ function manifestCommon(manifest, manifestPath) {
         ...userScripts(manifest),
         ...webAccessibleResources(manifest),
         ...contentSecurityPolicy(manifest),
-        ...omnibox(manifest)
+        ...omnibox_omnibox(manifest)
     };
 }
 function getManifestOverrides(manifestPath, manifest) {
@@ -909,14 +930,18 @@ function getManifestOverrides(manifestPath, manifest) {
         const { [key]: _ignored, ...rest } = obj;
         return rest;
     };
+    const pickBackground = (obj)=>{
+        const value = obj.background;
+        return value && 'object' == typeof value ? value : {};
+    };
     const common = manifestCommon(manifestContent, manifestPath);
     const mv2 = manifestV2(manifestContent);
     const mv3 = manifestV3(manifestContent);
     const backgroundMerged = {
         ...manifestContent.background || {},
-        ...common.background || {},
-        ...mv2.background || {},
-        ...mv3.background || {}
+        ...pickBackground(common),
+        ...pickBackground(mv2),
+        ...pickBackground(mv3)
     };
     const merged = {
         ...manifestContent,
@@ -984,15 +1009,8 @@ function getManifestContent(compilation, manifestPath) {
     }
 }
 function manifest_filterKeysForThisBrowser(manifest, browser) {
-    const CHROMIUM_BASED_BROWSERS = [
-        'chrome',
-        'edge'
-    ];
-    const GECKO_BASED_BROWSERS = [
-        'firefox'
-    ];
-    const isChromiumTarget = CHROMIUM_BASED_BROWSERS.includes(browser) || String(browser).includes('chromium');
-    const isGeckoTarget = GECKO_BASED_BROWSERS.includes(browser) || String(browser).includes('gecko');
+    const isChromiumTarget = isChromiumBasedBrowser(String(browser));
+    const isGeckoTarget = isGeckoBasedBrowser(String(browser));
     const chromiumPrefixes = new Set([
         'chromium',
         'chrome',
@@ -1031,9 +1049,8 @@ 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');
+    const candidate = __rspack_external_path.join(__rspack_import_meta_dirname__, '..', 'runtime', 'process-shim.cjs');
     try {
         return __rspack_external_fs.existsSync(candidate) ? candidate : void 0;
     } catch  {
@@ -2434,7 +2451,7 @@ async function maybeUseReact(projectPath, options = {}) {
         contractId: 'react-refresh',
         projectPath,
         dependencyId: '@rspack/plugin-react-refresh',
-        moduleAdapter: (mod)=>mod && mod.default || mod
+        moduleAdapter: (mod)=>mod && (mod.default || mod.ReactRefreshRspackPlugin) || mod
     });
     const reactPlugins = [
         new ReactRefreshPlugin({
@@ -2910,6 +2927,7 @@ class JsFrameworksPlugin {
                 issuerLayer: {
                     not: EXTENSIONJS_CONTENT_SCRIPT_LAYER
                 },
+                type: "javascript/esm",
                 exclude: [
                     ...swcRuleBase.exclude,
                     (resourcePath)=>isfeatureScriptsContentLike(resourcePath)
@@ -3134,10 +3152,12 @@ class UpdateManifest {
         this.manifestPath = options.manifestPath;
         this.browser = options.browser || 'chrome';
     }
-    applyDevOverrides(overrides) {
-        if (!overrides.content_scripts) return {};
-        return overrides.content_scripts.map((contentObj, index)=>{
-            if (contentObj.css.length && !contentObj.js.length) contentObj.js = [
+    applyDevOverrides(manifest) {
+        if (!manifest.content_scripts) return [];
+        return manifest.content_scripts.map((contentObj, index)=>{
+            const css = contentObj.css ?? [];
+            const js = contentObj.js ?? [];
+            if (css.length && !js.length) contentObj.js = [
                 getFilename(`content_scripts-${index}`, 'dev.js')
             ];
             return contentObj;
@@ -3165,7 +3185,7 @@ class UpdateManifest {
                     if ('development' === compiler.options.mode && Array.isArray(patchedManifest.content_scripts)) for (const cs of patchedManifest.content_scripts)try {
                         const hasCss = Array.isArray(cs.css) && cs.css.length > 0;
                         const hasJs = Array.isArray(cs.js) && cs.js.length > 0;
-                        if (hasCss && hasJs && 1 === cs.js.length) devCssStubsAdded++;
+                        if (hasCss && hasJs && cs.js?.length === 1) devCssStubsAdded++;
                     } catch  {}
                     console.log(manifestOverridesSummary(overrideKeys, devCssStubsAdded));
                 } catch  {}
@@ -3189,6 +3209,18 @@ function getSharedFor(compilation) {
     }
     return shared;
 }
+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 = [];
@@ -3199,6 +3231,10 @@ function warFieldError(filePath, opts) {
         lines.push(`To reference files in ${pintor.yellow('public/')}, use a leading '/' (e.g. ${pintor.yellow('/open-panel.gif')}). These resolve from the built extension root.`);
         lines.push('');
         lines.push(`Fix: Add the file to ${pintor.yellow('public/')} or update the path to the correct '/...' location.`);
+    } else if (opts?.sourceSibling) {
+        lines.push(`Found ${pintor.yellow(opts.sourceSibling)}, but web_accessible_resources entries are copied as-is, not compiled.`);
+        lines.push('');
+        lines.push(`Fix: Import the file from a script so it gets bundled, or move a prebuilt copy to ${pintor.yellow('public/')} and reference it with a leading '/'.`);
     } else {
         lines.push("Relative paths must point to a real source file so the build can emit it.");
         lines.push('');
@@ -3209,6 +3245,16 @@ function warFieldError(filePath, opts) {
     lines.push(`${pintor.red('NOT FOUND')} ${pintor.underline(displayPath)}`);
     return lines.join('\n');
 }
+function warStringEntryInMv3(entry) {
+    const lines = [];
+    lines.push(`Check the ${pintor.yellow('web_accessible_resources')} field in your ${pintor.yellow('manifest.json')} file.`);
+    lines.push(`Manifest V3 requires object entries with ${pintor.yellow('resources')} and ${pintor.yellow('matches')} (or ${pintor.yellow('extension_ids')}). Plain string entries are the Manifest V2 format and Chrome rejects them at load time.`);
+    lines.push('');
+    lines.push(`Fix: Wrap it like ${pintor.yellow(`{"resources": ["${entry}"], "matches": ["<all_urls>"]}`)} with the matches your pages need.`);
+    lines.push('');
+    lines.push(`${pintor.red('INVALID MV3 ENTRY')} ${pintor.underline(entry)}`);
+    return lines.join('\n');
+}
 function warInvalidMatchPattern(pattern) {
     const lines = [];
     lines.push(`Check the ${pintor.yellow('web_accessible_resources')} field in your ${pintor.yellow('manifest.json')} file.`);
@@ -3249,6 +3295,33 @@ function emitFileAsAsset(compilation, absPath) {
     compilation.fileDependencies.add(absPath);
     return unixify(outName);
 }
+function findSourceSibling(absOutputPath) {
+    const candidatesByExt = {
+        '.js': [
+            '.ts',
+            '.tsx',
+            '.jsx',
+            '.vue',
+            '.svelte'
+        ],
+        '.css': [
+            '.scss',
+            '.sass',
+            '.less'
+        ],
+        '.html': [
+            '.njk',
+            '.nunjucks'
+        ]
+    };
+    const ext = __rspack_external_path.extname(absOutputPath);
+    const sourceExts = candidatesByExt[ext];
+    if (!sourceExts) return;
+    for (const sourceExt of sourceExts){
+        const candidate = absOutputPath.slice(0, -ext.length) + sourceExt;
+        if (__rspack_external_fs.existsSync(candidate)) return candidate;
+    }
+}
 function isFirefox(browser) {
     return !!browser && browser.toLowerCase().includes('firefox');
 }
@@ -3284,30 +3357,33 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
         v2,
         v3
     };
-    const isV2 = Array.isArray(war) && 'string' == typeof war[0];
+    const isMv2 = 3 !== manifestObj.manifest_version;
     const manifestDir = __rspack_external_path.dirname(manifestPath);
     const projectPath = compilation.options?.context || manifestDir;
-    const pushResource = (matches, resource)=>{
-        if (2 === manifestObj.manifest_version || isV2) return void v2.add(resource);
+    const pushResource = (matches, resource, extra)=>{
+        if (isMv2) return void v2.add(resource);
         const key = (matches || []).join(',');
         let group = v3.find((g)=>g.matches.join(',') === key);
-        if (!group) {
+        if (group) {
+            if (extra && !group.extra) group.extra = extra;
+        } else {
             group = {
                 matches: matches || [],
-                resources: new Set()
+                resources: new Set(),
+                extra
             };
             v3.push(group);
         }
         group.resources.add(resource);
     };
-    const handleOne = (matches, res)=>{
+    const handleOne = (matches, res, extra)=>{
         compilation.errors = compilation.errors || [];
         compilation.warnings = compilation.warnings || [];
         const normalizedOutput = normalizeManifestOutputPath(res);
         const publicCandidate = __rspack_external_path.join(projectPath, 'public', normalizedOutput);
-        if (__rspack_external_fs.existsSync(publicCandidate)) return void pushResource(matches, normalizedOutput);
+        if (__rspack_external_fs.existsSync(publicCandidate)) return void pushResource(matches, normalizedOutput, extra);
         __rspack_external_path.isAbsolute(res) || __rspack_external_path.join(manifestDir, isPublicRootLike(res) ? toPublicOutput(res) : res);
-        if (/[*?\[\]{}]/.test(res)) return void pushResource(matches, res);
+        if (/[*?\[\]{}]/.test(res)) return void pushResource(matches, res, extra);
         if (isPublicRootLike(res)) {
             const output = normalizeManifestOutputPath(res);
             const publicAbs = __rspack_external_path.join(projectPath, 'public', output);
@@ -3338,7 +3414,7 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
                 err.file = 'manifest.json';
                 compilation.warnings.push(err);
             }
-            pushResource(matches, output);
+            pushResource(matches, output, extra);
             return;
         }
         const abs = __rspack_external_path.isAbsolute(res) ? res : __rspack_external_path.join(manifestDir, res);
@@ -3350,46 +3426,47 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
             const assetEmitted = Boolean(asset2 && asset2.name === res) || __rspack_external_fs.existsSync(builtAbs);
             if (__rspack_external_fs.existsSync(publicAbsMaybe) || assetEmitted) {
                 const output = toPublicOutput('/' + res);
-                pushResource(matches, output);
+                pushResource(matches, output, extra);
                 return;
             }
+            const sourceSibling = findSourceSibling(abs);
             const msg = warFieldError(abs, {
-                relativeRef: res
+                relativeRef: res,
+                sourceSibling: sourceSibling ? __rspack_external_path.relative(manifestDir, sourceSibling) : void 0
             });
             const warn = new core_WebpackError(msg);
             warn.file = 'manifest.json';
             warn.name = 'WARRelativeAssetMissing';
             compilation.warnings.push(warn);
-            pushResource(matches, res);
             return;
         }
         const emitted = emitFileAsAsset(compilation, abs);
-        pushResource(matches, emitted);
+        pushResource(matches, emitted, extra);
     };
-    if (isV2) war.forEach((res)=>handleOne(void 0, res));
-    else war.forEach((group)=>{
-        const matches = group.matches || [];
+    war.forEach((entry)=>{
+        if ('string' == typeof entry) {
+            if (isMv2) return void handleOne(void 0, entry);
+            const msg = warStringEntryInMv3(entry);
+            const err = new core_WebpackError(msg);
+            err.file = 'manifest.json';
+            err.name = 'WARStringEntryInMv3';
+            compilation.errors = compilation.errors || [];
+            compilation.errors.push(err);
+            return;
+        }
+        if (!entry || 'object' != typeof entry) return;
+        const matches = entry.matches || [];
         validateMatchesOrReport(compilation, matches, browser);
-        if (!Array.isArray(group.resources)) return;
-        group.resources.forEach((res)=>handleOne(matches, res));
+        if (!Array.isArray(entry.resources)) return;
+        const { resources: _resources, matches: _matches, ...extra } = entry;
+        const extraFields = Object.keys(extra).length > 0 ? extra : void 0;
+        entry.resources.forEach((res)=>handleOne(matches, res, extraFields));
     });
     return {
         v2,
         v3
     };
 }
-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 getAssetSource(compilation, filename) {
     const byGet = 'function' == typeof compilation.getAsset ? compilation.getAsset(filename) : void 0;
     const byAssets = !byGet && compilation.assets ? compilation.assets[filename] : void 0;
@@ -3454,6 +3531,7 @@ function mergeIntoV3Group(groups, normalizedMatches, resources, options) {
         ].sort()
     });
 }
+const assetScanCache = new WeakMap();
 function isCanonicalContentScriptCss(resource) {
     return /^content_scripts\/content-\d+\.css$/.test(resource);
 }
@@ -3466,6 +3544,7 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
     const canonicalManifest = getManifestContent(compilation, manifestPath);
     const resolved = resolveUserDeclaredWAR(compilation, manifestPath, canonicalManifest, browser);
     const webAccessibleResourcesV3 = 3 === canonicalManifest.manifest_version ? resolved.v3.map((g)=>({
+            ...g.extra || {},
             matches: g.matches,
             resources: Array.from(g.resources)
         })) : [];
@@ -3475,11 +3554,17 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
         const normalizedMatches = cleanMatches(matches);
         const jsFiles = Array.isArray(contentScript.js) ? contentScript.js : [];
         for (const jsFile of jsFiles){
-            const source = getAssetSource(compilation, jsFile);
-            if (!source) continue;
-            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();
+            const assetForCache = 'function' == typeof compilation.getAsset ? compilation.getAsset(jsFile) : void 0;
+            const cacheKey = assetForCache && 'object' == typeof assetForCache.source ? assetForCache.source : void 0;
+            let filtered = cacheKey ? assetScanCache.get(cacheKey) : void 0;
+            if (!filtered) {
+                const source = getAssetSource(compilation, jsFile);
+                if (!source) continue;
+                const re = /assets\/[A-Za-z0-9._-]+/g;
+                const found = source.match(re) || [];
+                filtered = Array.from(new Set(found.filter((r)=>!r.endsWith('.js') && !r.endsWith('.map')))).sort();
+                if (cacheKey) assetScanCache.set(cacheKey, filtered);
+            }
             if (0 !== filtered.length) mergeIntoV3Group(webAccessibleResourcesV3, normalizedMatches, filtered);
         }
     }
@@ -3533,7 +3618,8 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
     const emittedCssUnderContentScripts = assetKeys.filter((k)=>k.startsWith("content_scripts/")).filter((k)=>k.endsWith('.css'));
     const onDiskCssUnderContentScripts = [];
     const outputPath = compilation.options.output?.path;
-    if (outputPath) try {
+    const isDevModeBuild = 'production' !== (compilation.options?.mode || 'development');
+    if (outputPath && isDevModeBuild) try {
         const csDir = __rspack_external_path.join(outputPath, "content_scripts");
         if (__rspack_external_fs.existsSync(csDir)) {
             for (const name of __rspack_external_fs.readdirSync(csDir))if (name.endsWith('.css')) onDiskCssUnderContentScripts.push(`content_scripts/${name}`);
@@ -3562,6 +3648,7 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
     }
     if (3 === canonicalManifest.manifest_version) {
         if (webAccessibleResourcesV3.length > 0) canonicalManifest.web_accessible_resources = webAccessibleResourcesV3.map((entry)=>({
+                ...entry,
                 resources: Array.from(new Set(entry.resources)).sort(),
                 matches: Array.from(new Set(entry.matches)).sort()
             })).sort((a, b)=>a.matches.join(',').localeCompare(b.matches.join(',')));
@@ -3812,10 +3899,19 @@ class ApplyDevDefaults {
                     return;
                 }
                 const canonicalManifest = getManifestContent(compilation, this.manifestPath);
+                const contentScriptMatches = Array.isArray(canonicalManifest.content_scripts) ? canonicalManifest.content_scripts.flatMap((cs)=>Array.isArray(cs?.matches) ? cs.matches : []) : [];
+                const hostPermissionsPatch = 3 === canonicalManifest.manifest_version && contentScriptMatches.length > 0 ? {
+                    host_permissions: [
+                        ...new Set([
+                            ...canonicalManifest.host_permissions || [],
+                            ...contentScriptMatches
+                        ])
+                    ]
+                } : {};
                 const patchedManifest = {
                     ...canonicalManifest,
                     content_security_policy: 3 === canonicalManifest.manifest_version ? patchV3CSP(canonicalManifest) : patchV2CSP(canonicalManifest),
-                    ...3 === canonicalManifest.manifest_version ? canonicalManifest.permissions ? {
+                    ...3 === canonicalManifest.manifest_version ? {
                         permissions: [
                             ...new Set([
                                 "scripting",
@@ -3826,11 +3922,14 @@ class ApplyDevDefaults {
                         ]
                     } : {
                         permissions: [
-                            "scripting",
-                            'tabs',
-                            'management'
+                            ...new Set([
+                                'tabs',
+                                ...contentScriptMatches,
+                                ...canonicalManifest.permissions || []
+                            ])
                         ]
-                    } : {},
+                    },
+                    ...hostPermissionsPatch,
                     ...patchBackground(canonicalManifest, this.browser),
                     ...patchExternallyConnectable(canonicalManifest),
                     web_accessible_resources: 3 === canonicalManifest.manifest_version ? patchWebResourcesV3(canonicalManifest) : patchWebResourcesV2(canonicalManifest)
@@ -4792,7 +4891,25 @@ class AddAssetsToCompilation {
         });
     }
 }
-var dev_server_client_import_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+const WILDCARD_HOSTS = new Set([
+    '0.0.0.0',
+    '::',
+    '[::]',
+    '::0',
+    '0.0.0.0.0',
+    '*',
+    ''
+]);
+function isWildcardHost(host) {
+    return WILDCARD_HOSTS.has(String(host ?? '').trim());
+}
+function resolveConnectableHost(bindHost, publicHost) {
+    const override = String(publicHost ?? '').trim();
+    if (override) return override;
+    const bind = String(bindHost ?? '').trim();
+    if (isWildcardHost(bind)) return '127.0.0.1';
+    return bind || '127.0.0.1';
+}
 const dev_server_client_import_cjsRequire = createRequire(import.meta.url);
 function normalizeBoolean(value, fallback) {
     return String('boolean' == typeof value ? value : fallback);
@@ -4808,7 +4925,7 @@ function resolveHmrClientPath() {
     if (!_resolvedClientPath) try {
         _resolvedClientPath = dev_server_client_import_cjsRequire.resolve('@rspack/dev-server/client/index.js', {
             paths: [
-                dev_server_client_import_dirname
+                __rspack_import_meta_dirname__
             ]
         });
     } catch  {
@@ -4820,7 +4937,7 @@ function resolveHmrHotPath() {
     if (!_resolvedHotPath) try {
         _resolvedHotPath = dev_server_client_import_cjsRequire.resolve('webpack/hot/dev-server', {
             paths: [
-                dev_server_client_import_dirname
+                __rspack_import_meta_dirname__
             ]
         });
     } catch  {
@@ -4838,7 +4955,8 @@ function getDevServerHmrImports(compiler) {
     const clientConfig = devServer?.client && 'object' == typeof devServer.client ? devServer.client : {};
     const webSocketURL = clientConfig.webSocketURL && 'object' == typeof clientConfig.webSocketURL ? clientConfig.webSocketURL : {};
     const protocol = String(webSocketURL.protocol || envProtocol || 'ws');
-    const hostname = String(webSocketURL.hostname || devServer?.host || envHost || '127.0.0.1');
+    const envConnectableHost = process.env.EXTENSION_DEV_SERVER_CONNECTABLE_HOST;
+    const hostname = String(webSocketURL.hostname || envConnectableHost || resolveConnectableHost(devServer?.host || envHost));
     const port = webSocketURL.port ?? devServer?.port ?? envPort ?? process.env.EXTENSION_PUBLIC_PORT ?? 8080;
     const pathname = String(webSocketURL.pathname || envPath || '/ws');
     const logging = String(clientConfig.logging || 'none');
@@ -5242,6 +5360,7 @@ function getScriptEntries(scriptPath) {
     ] : [];
     const fileAssets = scriptEntries.filter((scriptAsset)=>{
         const validFile = __rspack_external_fs.existsSync(scriptAsset);
+        if (/\.d\.[cm]?ts$/i.test(scriptAsset)) return false;
         const assetExtension = __rspack_external_path.extname(scriptAsset);
         return validFile && ('.js' === assetExtension || '.cjs' === assetExtension || '.mjs' === assetExtension || '.jsx' === assetExtension || '.mjsx' === assetExtension || '.ts' === assetExtension || '.mts' === assetExtension || '.mtsx' === assetExtension || '.tsx' === assetExtension);
     });
@@ -5257,7 +5376,6 @@ function getCssEntries(scriptPath) {
     });
     return fileAssets;
 }
-var get_bridge_scripts_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 function findPackageRoot(startDir) {
     let current = startDir;
     for(let i = 0; i < 15; i++){
@@ -5280,7 +5398,7 @@ function resolveExistingFile(candidates) {
     }
 }
 function resolveMainWorldBridgeSourcePath(options) {
-    const lookupDir = options?.lookupDir || get_bridge_scripts_dirname;
+    const lookupDir = options?.lookupDir || __rspack_import_meta_dirname__;
     const packageRoot = options?.packageRoot || findPackageRoot(lookupDir);
     return resolveExistingFile([
         path_0.resolve(lookupDir, 'main-world-bridge'),
@@ -5306,6 +5424,17 @@ function getMainWorldBridgeScripts(manifestPath) {
     } catch  {}
     return bridgeScripts;
 }
+function canonicalizeDir(dir) {
+    try {
+        return __rspack_external_fs.realpathSync.native(dir);
+    } catch  {
+        try {
+            return __rspack_external_fs.realpathSync(dir);
+        } catch  {
+            return dir;
+        }
+    }
+}
 class AddContentScriptWrapper {
     static getBridgeScripts(manifestPath) {
         return getMainWorldBridgeScripts(manifestPath);
@@ -5319,16 +5448,39 @@ class AddContentScriptWrapper {
     resolveLoader() {
         return resolveDevelopDistFile("feature-scripts-content-script-wrapper");
     }
+    resolveConcatLoader() {
+        return resolveDevelopDistFile("feature-scripts-classic-concat-loader");
+    }
     apply(compiler) {
-        const manifestDir = __rspack_external_path.dirname(this.manifestPath);
+        const manifestDir = canonicalizeDir(__rspack_external_path.dirname(this.manifestPath));
         const packageJsonPath = findNearestPackageJsonSync(this.manifestPath);
-        const packageJsonDir = packageJsonPath ? __rspack_external_path.dirname(packageJsonPath) : manifestDir;
+        const packageJsonDir = canonicalizeDir(packageJsonPath ? __rspack_external_path.dirname(packageJsonPath) : manifestDir);
         const includeDirs = packageJsonDir === manifestDir ? [
             manifestDir
         ] : [
             manifestDir,
             packageJsonDir
         ];
+        compiler.options.module.rules.push({
+            test: /\.(js|cjs|mjs|jsx|mjsx|ts|mts|tsx|mtsx)$/,
+            resourceQuery: /__extensionjs_classic_concat__/,
+            include: includeDirs,
+            exclude: [
+                /([\\/])node_modules\1/
+            ],
+            use: [
+                {
+                    loader: this.resolveLoader(),
+                    options: {
+                        manifestPath: this.manifestPath,
+                        mode: compiler.options.mode
+                    }
+                },
+                {
+                    loader: this.resolveConcatLoader()
+                }
+            ]
+        });
         compiler.options.module.rules.push({
             test: /\.(js|cjs|mjs|jsx|mjsx|ts|mts|tsx|mtsx)$/,
             include: includeDirs,
@@ -5350,7 +5502,28 @@ class AddContentScriptWrapper {
 const add_scripts_isRemoteUrl = (entry)=>/^([a-z][a-z0-9+.-]*:)?\/\//i.test(entry);
 const isContentScriptFeature = (feature)=>feature.startsWith("content_scripts/");
 const isScriptsFolderFeature = (feature)=>feature.startsWith("scripts/");
+const isBackgroundScriptsFeature = (feature)=>"background/scripts" === feature;
 function createSequentialEntryModule(feature, entryImports) {
+    const isCss = (p)=>/\.css$/i.test(p);
+    const jsFiles = entryImports.filter((p)=>!isCss(p));
+    const cssFiles = entryImports.filter(isCss);
+    const isClassic = (p)=>{
+        try {
+            const src = __rspack_external_fs.readFileSync(p, 'utf8');
+            return !/^\s*import[\s{('"*]/m.test(src) && !/^\s*export[\s{*( ]/m.test(src);
+        } catch  {
+            return false;
+        }
+    };
+    const concatenateClassic = jsFiles.length > 1 && jsFiles.every(isClassic);
+    if (concatenateClassic) {
+        const queryData = encodeURIComponent(JSON.stringify({
+            feature,
+            js: jsFiles,
+            css: cssFiles
+        }));
+        return `${jsFiles[0]}?__extensionjs_classic_concat__=${queryData}`;
+    }
     const source = [
         `/* extension.js sequential entry: ${feature} */`,
         ...entryImports.map((entryImport)=>`import ${JSON.stringify(String(entryImport))};`)
@@ -5428,7 +5601,7 @@ class AddScripts {
                     ...cssImports
                 ])
             ];
-            const shouldUseSequentialEntryModule = isContentScriptFeature(feature) && scriptImports.length > 1;
+            const shouldUseSequentialEntryModule = (isContentScriptFeature(feature) || isBackgroundScriptsFeature(feature)) && scriptImports.length > 1;
             const finalEntryImports = shouldUseSequentialEntryModule ? [
                 createSequentialEntryModule(feature, entryImports)
             ] : entryImports;
@@ -6311,7 +6484,8 @@ class DevServerConfigPlugin {
             protocol: 'ws'
         });
         setDefault(devServer.client.webSocketURL, 'protocol', 'ws');
-        if (devServer.host) setDefault(devServer.client.webSocketURL, 'hostname', devServer.host);
+        const connectableHost = resolveClientHost(process.env.EXTENSION_DEV_SERVER_CONNECTABLE_HOST, devServer.host);
+        if (connectableHost) setDefault(devServer.client.webSocketURL, 'hostname', connectableHost);
         if (devServer.port) setDefault(devServer.client.webSocketURL, 'port', devServer.port);
         setDefault(devServer, 'allowedHosts', 'all');
         setDefault(devServer, 'headers', {
@@ -6331,6 +6505,21 @@ class DevServerConfigPlugin {
 function setDefault(obj, key, val) {
     if (isObject(obj) && void 0 === obj[key]) obj[key] = val;
 }
+const HMRDevServer_WILDCARD_HOSTS = new Set([
+    '0.0.0.0',
+    '::',
+    '[::]',
+    '::0',
+    '*',
+    ''
+]);
+function resolveClientHost(connectable, bindHost) {
+    const resolved = String(connectable ?? '').trim();
+    if (resolved) return resolved;
+    const bind = 'string' == typeof bindHost ? bindHost.trim() : '';
+    if (!bind) return;
+    return HMRDevServer_WILDCARD_HOSTS.has(bind) ? '127.0.0.1' : bind;
+}
 function isObject(x) {
     return 'object' == typeof x && null !== x;
 }
@@ -6659,6 +6848,10 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
     var PORT = parseInt("__EXTJS_CONTROL_PORT__", 10);
     var INSTANCE_ID = "__EXTJS_INSTANCE_ID__";
     var CONTEXT = "__EXTJS_CONTEXT__";
+    // Connectable host of the dev-server control WS. Baked from the resolved
+    // connectable host (loopback locally; the public host for remote/devcontainer).
+    var HOST = "__EXTJS_CONTROL_HOST__";
+    if (!HOST || HOST.indexOf("__EXTJS") === 0) HOST = "127.0.0.1";
     if (!PORT || PORT < 1) return;
 
     var WS = g.WebSocket;
@@ -6976,6 +7169,158 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
       }
     }
 
+    function noopLastError() { try { void g.chrome.runtime.lastError; } catch (e) {} }
+
+    // Only http(s)/file/ftp tabs can run a content script; skip chrome://, the
+    // extension's own pages, about:blank, etc.
+    function isInjectableUrl(url) {
+      return typeof url === "string" && /^(https?|file|ftp):/i.test(url);
+    }
+
+    // Re-inject a single declared content-script entry's fresh files into every
+    // open tab it matches, in place. The wrapper's reinject runtime tears down
+    // the previous mount (matched by data-extjs-reinject-owner + build hash) and
+    // mounts the new one — so this is the controller-less equivalent of the CDP
+    // controller's reinjection, just driven from inside the extension.
+    function reinjectContentScriptEntry(entry) {
+      var chrome = g.chrome;
+      var matches = (entry && entry.matches) || [];
+      if (!Array.isArray(matches) || !matches.length) return;
+      var jsFiles = ((entry && entry.js) || []).filter(function (f) { return typeof f === "string"; });
+      var cssFiles = ((entry && entry.css) || []).filter(function (f) { return typeof f === "string"; });
+      if (!jsFiles.length && !cssFiles.length) return;
+      var world = entry.world === "MAIN" ? "MAIN" : "ISOLATED";
+      var allFrames = !!entry.all_frames;
+      try {
+        chrome.tabs.query({url: matches}, function (tabs) {
+          var err = null;
+          try { err = chrome.runtime.lastError; } catch (e) {}
+          if (err || !tabs) return;
+          for (var i = 0; i < tabs.length; i++) {
+            (function (tab) {
+              if (!tab || tab.id == null || !isInjectableUrl(tab.url)) return;
+              var target = {tabId: tab.id, allFrames: allFrames};
+              if (cssFiles.length && chrome.scripting.insertCSS) {
+                try { chrome.scripting.insertCSS({target: target, files: cssFiles}, noopLastError); } catch (e) {}
+              }
+              if (jsFiles.length && chrome.scripting.executeScript) {
+                try {
+                  chrome.scripting.executeScript(
+                    {target: target, files: jsFiles, world: world, injectImmediately: true},
+                    noopLastError
+                  );
+                } catch (e) {}
+              }
+            })(tabs[i]);
+          }
+        });
+      } catch (e) {}
+    }
+
+    // Re-inject all content scripts into their open tabs. Reads the manifest
+    // FROM DISK (not chrome.runtime.getManifest(), which is frozen at extension-
+    // registration time) because dev content-script filenames are content-hashed
+    // and change on every edit — disk has the new js/css paths.
+    function reinjectContentScripts() {
+      var chrome = g.chrome;
+      try {
+        if (typeof g.fetch !== "function" || !chrome.scripting) return false;
+        g.fetch(chrome.runtime.getURL("manifest.json"), {cache: "no-store"})
+          .then(function (r) { return r.json(); })
+          .then(function (manifest) {
+            var entries = (manifest && manifest.content_scripts) || [];
+            for (var i = 0; i < entries.length; i++) reinjectContentScriptEntry(entries[i]);
+            reregisterForFutureNavigations(entries);
+          })
+          .catch(function () {});
+        return true;
+      } catch (e) { return false; }
+    }
+
+    function mapRunAt(runAt) {
+      if (runAt === "document_start") return "document_start";
+      if (runAt === "document_end") return "document_end";
+      return "document_idle";
+    }
+
+    // Re-register the content scripts dynamically (chrome.scripting) pointing at
+    // the fresh files, so tabs opened AFTER an edit also get the new build. The
+    // static manifest registration still points at the old content-hashed file
+    // (it only updates on an extension reload) and keeps firing on new
+    // navigations; the dynamic registration injects the new file alongside it,
+    // and the wrapper's reinject runtime converges the mount to the newest build.
+    // Idempotent: update an existing id, else register it.
+    function reregisterForFutureNavigations(entries) {
+      var chrome = g.chrome;
+      if (
+        !chrome.scripting ||
+        !chrome.scripting.registerContentScripts ||
+        !chrome.scripting.getRegisteredContentScripts
+      ) return;
+
+      var scripts = [];
+      for (var i = 0; i < entries.length; i++) {
+        var e = entries[i] || {};
+        if (!Array.isArray(e.matches) || !e.matches.length) continue;
+        var js = (e.js || []).filter(function (f) { return typeof f === "string"; });
+        var css = (e.css || []).filter(function (f) { return typeof f === "string"; });
+        if (!js.length && !css.length) continue;
+        var s = {
+          id: "extjs-dev-cs-" + i,
+          matches: e.matches,
+          runAt: mapRunAt(e.run_at),
+          allFrames: !!e.all_frames,
+          world: e.world === "MAIN" ? "MAIN" : "ISOLATED"
+        };
+        if (js.length) s.js = js;
+        if (css.length) s.css = css;
+        scripts.push(s);
+      }
+      if (!scripts.length) return;
+
+      try {
+        chrome.scripting.getRegisteredContentScripts(function (existing) {
+          try { void chrome.runtime.lastError; } catch (e) {}
+          var have = {};
+          if (existing) for (var k = 0; k < existing.length; k++) have[existing[k].id] = true;
+          var toRegister = [], toUpdate = [];
+          for (var j = 0; j < scripts.length; j++) {
+            (have[scripts[j].id] ? toUpdate : toRegister).push(scripts[j]);
+          }
+          if (toRegister.length) {
+            try { chrome.scripting.registerContentScripts(toRegister, noopLastError); } catch (e) {}
+          }
+          if (toUpdate.length) {
+            try { chrome.scripting.updateContentScripts(toUpdate, noopLastError); } catch (e) {}
+          }
+        });
+      } catch (e) {}
+    }
+
+    // Perform a dev-loop reload without the CDP controller:
+    //   - content-scripts: re-inject the fresh script into open matching tabs in
+    //     place (no extension restart), the controller-less equivalent of CDP
+    //     reinjection. Needs the scripting permission + host access to the tab —
+    //     both injected in dev by ApplyDevDefaults. Falls back to a full reload
+    //     if scripting is unavailable.
+    //   - service-worker / full / manifest: restart the whole extension so it
+    //     re-registers from the fresh manifest.
+    function performDevReload(type) {
+      var chrome = g.chrome;
+      if (!chrome) return;
+
+      var fullReload = function () {
+        // Deferred so any in-flight result/log frame flushes before the SW dies.
+        try { setTimeout(function () { try { chrome.runtime.reload(); } catch (e) {} }, 50); } catch (e) {}
+      };
+
+      if (type === "content-scripts" && chrome.scripting && chrome.tabs && chrome.tabs.query) {
+        if (reinjectContentScripts()) return;
+      }
+
+      fullReload();
+    }
+
     function sanitize(args) {
       var out = [];
       for (var i = 0; i < args.length; i++) {
@@ -7014,7 +7359,7 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
 
     function connect() {
       try {
-        socket = new WS("ws://127.0.0.1:" + PORT + "/extjs-control");
+        socket = new WS("ws://" + HOST + ":" + PORT + "/extjs-control");
       } catch (e) {
         schedule();
         return;
@@ -7033,6 +7378,10 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
         try { frame = JSON.parse(typeof ev.data === "string" ? ev.data : ""); } catch (e) { return; }
         if (frame && frame.type === "command") {
           try { executeCommand(frame); } catch (e) { replyErr(frame.cmdId, "ExecutorError", e); }
+        } else if (frame && frame.type === "reload") {
+          // Dev-loop reload broadcast (no CDP controller — see broker.broadcastReload).
+          // Fire-and-forget: no result frame is expected.
+          try { performDevReload(frame.reloadType || "full"); } catch (e) {}
         }
       };
       socket.onclose = function () {
@@ -7201,17 +7550,19 @@ function buildBridgeRelaySource(opts) {
 }
 function buildBridgeProducerSource(opts) {
     if (!opts.controlPort || opts.controlPort < 1) return '';
-    return BRIDGE_PRODUCER_SOURCE.replace(/__EXTJS_CONTROL_PORT__/g, String(opts.controlPort)).replace(/__EXTJS_INSTANCE_ID__/g, String(opts.instanceId)).replace(/__EXTJS_CONTEXT__/g, String(opts.context || 'background'));
+    return BRIDGE_PRODUCER_SOURCE.replace(/__EXTJS_CONTROL_PORT__/g, String(opts.controlPort)).replace(/__EXTJS_INSTANCE_ID__/g, String(opts.instanceId)).replace(/__EXTJS_CONTEXT__/g, String(opts.context || 'background')).replace(/__EXTJS_CONTROL_HOST__/g, String(opts.host || '127.0.0.1'));
 }
 const inject_bridge_producer_BACKGROUND_ASSET = /(^|\/)background\/(?:service_worker|scripts?)\.js$/i;
 class InjectBridgeProducer {
     apply(compiler) {
         const controlPort = parseInt(String(process.env.EXTENSION_CONTROL_PORT || ''), 10);
         const instanceId = String(process.env.EXTENSION_INSTANCE_ID || '');
+        const host = String(process.env.EXTENSION_DEV_SERVER_CONNECTABLE_HOST || '').trim() || '127.0.0.1';
         const source = buildBridgeProducerSource({
             controlPort: Number.isFinite(controlPort) ? controlPort : null,
             instanceId,
-            context: 'background'
+            context: 'background',
+            host
         });
         if (!source) return;
         compiler.hooks.thisCompilation.tap(InjectBridgeProducer.name, (compilation)=>{
@@ -7608,13 +7959,17 @@ function validateLocales(compiler, compilation, manifestPath) {
                         return false;
                     }
                 }
-            } catch  {}
+            } catch (error) {
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(localesValidationDetected(`could not scan __MSG__ placeholders in _locales/${defaultLocale}/messages.json: ${String(error?.message || error)}`));
+            }
         } else if (hasLocalesRoot) {
             if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(localesValidationDetected('_locales present but no default_locale'));
             pushCompilationError(compiler, compilation, 'LocalesValidationError', localesPresentButNoDefaultLocale(), 'manifest.json');
             return false;
         }
-    } catch  {}
+    } catch (error) {
+        if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(localesValidationDetected(`manifest.json could not be read for locale validation, deferring to manifest validation: ${String(error?.message || error)}`));
+    }
     try {
         const localesRoot = resolveLocalesFolder(manifestPath, projectRoot);
         if (localesRoot && __rspack_external_fs.existsSync(localesRoot)) {
@@ -7631,7 +7986,9 @@ function validateLocales(compiler, compilation, manifestPath) {
                 }
             }
         }
-    } catch  {}
+    } catch (error) {
+        if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(localesValidationDetected(`could not scan _locales for JSON validity: ${String(error?.message || error)}`));
+    }
     return true;
 }
 function processLocaleAssets(compiler, compilation, manifestPath) {
@@ -8073,6 +8430,7 @@ class EmitFile {
                         let outputDir = group;
                         if (('action' === group || 'browser_action' === group || 'page_action' === group || 'sidebar_action' === group) && 'default_icon' === sub) outputDir = 'icons';
                         else if ('browser_action' === group && 'theme_icons' === sub) outputDir = 'browser_action';
+                        else if ('theme' === group && 'images' === sub) outputDir = 'theme/images';
                         const filename = `${outputDir}/${basename}`;
                         compilation.emitAsset(filename, rawSource);
                         emittedCount++;
@@ -8476,7 +8834,10 @@ class plugin_web_extension_WebExtensionPlugin {
         }).apply(compiler);
         new IconsPlugin({
             manifestPath,
-            includeList: manifestFieldsData.icons,
+            includeList: {
+                ...manifestFieldsData.icons,
+                ...manifestFieldsData.theme
+            },
             browser: this.browser
         }).apply(compiler);
         new WebResourcesPlugin({
@@ -8521,7 +8882,6 @@ function compatibilityPolyfillSkipped(reason, browser) {
 function compatibilityPolyfillDisabled(browser) {
     return `${pintor.gray('⏵⏵⏵')} Compatibility: Polyfill ${pintor.gray('disabled')} for ${capitalizedBrowserName(browser)}`;
 }
-var feature_polyfill_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const feature_polyfill_cjsRequire = createRequire(import.meta.url);
 class PolyfillPlugin {
     browser;
@@ -8533,7 +8893,7 @@ class PolyfillPlugin {
             const polyfillPath = feature_polyfill_cjsRequire.resolve('webextension-polyfill/dist/browser-polyfill.js', {
                 paths: [
                     compiler.options.context,
-                    feature_polyfill_dirname
+                    __rspack_import_meta_dirname__
                 ].filter(Boolean)
             });
             const currentResolve = compiler.options.resolve || {};
@@ -8743,7 +9103,6 @@ class PerfBudgetsPlugin {
         });
     }
 }
-var rspack_config_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 function webpackConfig(projectStructure, devOptions) {
     const { manifestPath } = projectStructure;
     const { packageJsonDir } = getDirs(projectStructure);
@@ -8759,7 +9118,7 @@ function webpackConfig(projectStructure, devOptions) {
         projectRoot: packageJsonDir,
         config: devOptions.extensions
     });
-    const unpackedExtensionDirsToLoad = computeExtensionsToLoad(__rspack_external_path.resolve(rspack_config_dirname, '..'), devOptions.mode, devOptions.browser, primaryExtensionOutputDir, companionUnpackedExtensionDirs, manifestPath);
+    const unpackedExtensionDirsToLoad = computeExtensionsToLoad(__rspack_external_path.resolve(__rspack_import_meta_dirname__, '..'), devOptions.mode, devOptions.browser, primaryExtensionOutputDir, companionUnpackedExtensionDirs, manifestPath);
     const debug = 'true' === process.env.EXTENSION_AUTHOR_MODE;
     const transpilePackageDirs = resolveTranspilePackageDirs(packageJsonDir, devOptions.transpilePackages);
     if (debug) {
@@ -8769,6 +9128,7 @@ function webpackConfig(projectStructure, devOptions) {
         console.log(debugExtensionsToLoad(unpackedExtensionDirsToLoad));
         if (void 0 !== devOptions.extensions && 0 === companionUnpackedExtensionDirs.length) console.warn(noCompanionExtensionsResolved());
     }
+    const missingCssAssets = new Set();
     const plugins = [
         new CompilationPlugin({
             manifestPath,
@@ -8809,7 +9169,47 @@ function webpackConfig(projectStructure, devOptions) {
         }),
         new PerfBudgetsPlugin({
             budgets: devOptions.perfBudgets
-        })
+        }),
+        {
+            apply (compiler) {
+                compiler.hooks.afterCompile.tap('warn-missing-css-assets', (compilation)=>{
+                    if (0 === missingCssAssets.size) return;
+                    const ErrorCtor = compiler.rspack?.WebpackError || Error;
+                    for (const request of missingCssAssets){
+                        const warning = new ErrorCtor(`CSS asset "${request}" was not found on disk; the url() is left unresolved. The browser requests it at runtime and loads the extension regardless. Fix the path if it's a typo, or add the asset if it should ship.`);
+                        warning.name = 'MissingCssAssetWarning';
+                        compilation.warnings.push(warning);
+                    }
+                    missingCssAssets.clear();
+                });
+            }
+        },
+        {
+            apply (compiler) {
+                const target = String(devOptions.browser);
+                const isChromiumTarget = [
+                    'chrome',
+                    'edge'
+                ].includes(target) || target.includes('chromium');
+                if (manifest?.manifest_version !== 2 || !isChromiumTarget) return;
+                compiler.hooks.thisCompilation.tap('warn-mv2-on-chromium', (compilation)=>{
+                    const ErrorCtor = compiler.rspack?.WebpackError || Error;
+                    const usesBlockingWebRequest = Array.isArray(manifest.permissions) && manifest.permissions.includes('webRequestBlocking');
+                    const warning = new ErrorCtor([
+                        "This extension declares Manifest V2, which Chrome and Edge no longer load — ",
+                        `the ${target} build will not install. Options:`,
+                        "",
+                        "  • Build for Firefox (still supports MV2):  extension build --browser firefox",
+                        "  • Migrate the manifest to MV3 (action, background.service_worker, host_permissions)",
+                        "  • Or ship both from one source with browser-prefixed keys",
+                        "    (chromium:manifest_version: 3, firefox:manifest_version: 2, …)",
+                        usesBlockingWebRequest ? `\n  Note: this extension uses webRequestBlocking, which MV3 replaces with\n  declarativeNetRequest — a code change, not just a manifest edit.` : ''
+                    ].filter((line)=>'' !== line).join('\n'));
+                    warning.name = 'ManifestV2OnChromiumWarning';
+                    compilation.warnings.push(warning);
+                });
+            }
+        }
     ];
     plugins.push(new PlaywrightPlugin({
         packageJsonDir,
@@ -8818,6 +9218,7 @@ function webpackConfig(projectStructure, devOptions) {
         outputPath: primaryExtensionOutputDir,
         manifestPath,
         port: devOptions.port,
+        host: process.env.EXTENSION_DEV_SERVER_CONNECTABLE_HOST || devOptions.host,
         instanceId: devOptions.instanceId,
         controlPort: devOptions.controlPort,
         controlPath: devOptions.controlPath,
@@ -8832,6 +9233,22 @@ function webpackConfig(projectStructure, devOptions) {
         mode: devOptions.mode || 'development',
         entry: {},
         target: 'web',
+        externals: [
+            ({ request, dependencyType, context }, callback)=>{
+                if ('string' != typeof request) return callback();
+                if (/^(chrome|moz)-extension:/i.test(request)) return callback(null, request, 'asset');
+                if ('url' === dependencyType && context && !/^[a-z][\w+.-]*:/i.test(request) && !/^[/#]/.test(request) && !request.startsWith('//')) {
+                    const assetPath = request.split(/[?#]/)[0];
+                    try {
+                        if (assetPath && !__rspack_external_fs.existsSync(__rspack_external_path.resolve(context, assetPath))) {
+                            missingCssAssets.add(request);
+                            return callback(null, request, 'asset');
+                        }
+                    } catch  {}
+                }
+                callback();
+            }
+        ],
         context: packageJsonDir,
         cache: false,
         devtool: 'production' === (devOptions.mode || 'development') ? false : 3 === manifest.manifest_version ? 'cheap-source-map' : 'eval-cheap-source-map',
@@ -8971,4 +9388,4 @@ function webpackConfig(projectStructure, devOptions) {
         }
     };
 }
-export { rspack_config_namespaceObject, setupCompilerLifecycleHooks, setupNoBrowserBannerOnFirstDone, webpackConfig };
+export { resolveConnectableHost, rspack_config_namespaceObject, setupCompilerLifecycleHooks, setupNoBrowserBannerOnFirstDone, webpackConfig };