extension-develop 4.1.12 → 4.1.13

package/dist/0~rspack-config.mjs

@@ -12,17 +12,20 @@ import { filterKeysForThisBrowser as external_browser_extension_manifest_fields_
 import content_security_policy_parser from "content-security-policy-parser";
 import node_fs from "node:fs";
 import node_path from "node:path";
-import { debugExtensionsToLoad, package_namespaceObject, getDirs, asAbsolute, browserRunnerDisabled, treeWithDistFilesBrowser, packagingDistributionFiles, toPosixPath as paths_toPosixPath, resolveCompanionExtensionDirs, debugContextPath, specialFoldersSetupSummary, isGeckoBasedBrowser, spacerLine, isWebkitBasedBrowser, PlaywrightPlugin, messages_ready, CHROMIUM_FAMILY_ALIASES, treeWithSourceAndDistFiles, computeExtensionsToLoad, noCompanionExtensionsResolved, treeWithSourceFiles, bundlerFatalError, bundlerRecompiling, serverRestartRequiredFromSpecialFolderMessageOnly, noEntrypointsDetected, GECKO_FAMILY_ALIASES, packagingSourceFiles, getPreloadedEnvKeys, debugBrowser, debugOutputPath, manifestInvalidJson, specialFolderChangeDetected, isChromiumBasedBrowser, getSpecialFoldersDataForCompiler } from "./101.mjs";
+import { package_namespaceObject, bundlerFatalError, bundlerRecompiling, browserRunnerDisabled, PlaywrightPlugin, publicFolderShadowed, resolveCompanionExtensionDirs, specialFoldersSetupSummary, noEntrypointsDetected, GECKO_FAMILY_ALIASES, isGeckoBasedBrowser, spacerLine, messages_ready, getPreloadedEnvKeys, isWebkitBasedBrowser, specialFolderChangeDetected, publicMustBeAtProjectRoot, isChromiumBasedBrowser, CHROMIUM_FAMILY_ALIASES, serverRestartRequiredFromSpecialFolderMessageOnly, computeExtensionsToLoad, getSpecialFoldersDataForCompiler } from "./101.mjs";
 import { stripBom, parseJsonSafe } from "./23.mjs";
 import { isResourceUnderDirs, canonicalizeDir, toResourceKey } from "./93.mjs";
 import { prefix as messaging_prefix, isDebug } from "./349.mjs";
 import { jsFrameworksHmrSummary, isUsingTypeScript, resolvePackageManager, humanLine, jsFrameworksIntegrationsEnabled, jsFrameworksConfigsDetected, recordZipArtifact, hasDependency, resolveDevelopInstallRoot, resolveDevelopDistFile, isUsingCustomLoader, ensureTypeScriptConfig, isUsingIntegration as messages_isUsingIntegration, getUserTypeScriptConfigFile } from "./839.mjs";
 import { renderStatsBlocks, makeSanitizedConsole } from "./0~stats-handler.mjs";
+import { utils_isUrl, getBaseNode, manifestJsonOutputTarget, getExtname, getBaseHref, toPosixPath, getAssetsFromHtml, normalizeManifestOutputPath, isFromIncludeList, htmlStaticAssetOutputName, manifestPageOutputTarget, iconOutputPath, isSpecialScheme, resolveStaticAttributeName, getHtmlPageDeclaredAssetPath, themeImageOutputPath, themeIconOutputPath, applyRewrittenStaticUrl, cleanLeading, getFilePath, parseHtml, resolveAbsoluteFsPath, cleanAssetUrl, isHttpLike, resolveHtmlRefPath } from "./518.mjs";
 import { EXTENSIONJS_CONTENT_SCRIPT_LAYER, getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, CONTENT_SCRIPT_CSS_PROBE_MARKER_PREFIX, createContentScriptCssProbeMarkerPattern, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName, isCanonicalContentScriptAsset } from "./291.mjs";
+import { packagingSourceFiles, debugBrowser, debugExtensionsToLoad, treeWithSourceFiles, debugOutputPath, manifestInvalidJson, getDirs, asAbsolute, treeWithDistFilesBrowser, packagingDistributionFiles, treeWithSourceAndDistFiles, toPosixPath as paths_toPosixPath, debugContextPath, noCompanionExtensionsResolved } from "./77.mjs";
 import { hasProjectDependency, findNearestProjectManifestSync, PROJECT_MANIFEST_FILENAMES, readProjectDependencies } from "./80.mjs";
-import { cssIntegrationsEnabled, cssConfigsDetected, deadCssUrlRef, missingSassDependency, isUsingIntegration, postCssPluginNotResolved } from "./845.mjs";
-import { toPosixPath } from "./86.mjs";
+import { cssMinifierDroppedRules, postCssConfigUnreadable, missingSassDependency, deadCssUrlRef, postCssPluginNotResolved, postCssConfigPluginsShape, cssIntegrationsEnabled, cssConfigsDetected, isUsingIntegration } from "./845.mjs";
+import { minifierDroppedTokens, restoreVerbatimCssAssets } from "./129.mjs";
 import { injectedFileDependencyMissing, importScriptsDependencyMissing, getURLDependencyMissing, staticImportDependencyMissing, fetchedFileDependencyMissing, runtimeSetSurfaceDependencyMissing } from "./266.mjs";
+import { inspectPublicFolders, publicResolveRoots, rememberPublicRoots } from "./278.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));
@@ -497,6 +500,90 @@ function countFilesRecursively(dir) {
         return 0;
     }
 }
+const ACTION_HTML_FEATURE = 'action/index';
+const PAGE_ACTION_HTML_FEATURE = 'page_action/index';
+const ACTION_HTML_OUTPUT = 'action/index.html';
+const PAGE_ACTION_HTML_OUTPUT = 'page_action/index.html';
+function readDefaultPopup(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return;
+    const popup = value.default_popup;
+    if ('string' != typeof popup) return;
+    const trimmed = popup.trim();
+    return trimmed || void 0;
+}
+function normalizePopupRef(ref) {
+    return String(ref || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '');
+}
+function popupRefsShareSource(a, b) {
+    if ('string' != typeof a || 'string' != typeof b) return false;
+    const left = normalizePopupRef(a);
+    const right = normalizePopupRef(b);
+    return Boolean(left) && left === right;
+}
+function resolveManifestHtmlPath(context, relativePath) {
+    const unix = relativePath.replace(/\\/g, '/');
+    if (/^\/public\//i.test(unix)) return __rspack_external_node_path_c5b9b54f.join(context, 'public', unix.replace(/^\/public\//i, ''));
+    if (/^(?:\.\/)?public\//i.test(unix)) return __rspack_external_node_path_c5b9b54f.join(context, 'public', unix.replace(/^(?:\.\/)?public\//i, ''));
+    if (/^\//.test(unix)) return __rspack_external_node_path_c5b9b54f.join(context, unix.slice(1));
+    return __rspack_external_node_path_c5b9b54f.join(context, unix);
+}
+function actionPopupRef(manifest) {
+    if (!manifest) return;
+    return readDefaultPopup(manifest.action) || readDefaultPopup(manifest.browser_action);
+}
+function pageActionPopupRef(manifest) {
+    if (!manifest) return;
+    return readDefaultPopup(manifest.page_action);
+}
+function isPageActionLiveSurface(manifest, browser) {
+    if (isGeckoBasedBrowser(String(browser || ''))) return true;
+    const version = Number(manifest?.manifest_version);
+    return Number.isFinite(version) && version < 3;
+}
+function pageActionDropReason(manifest, browser) {
+    if (!manifest || 'object' != typeof manifest) return;
+    if (!('page_action' in manifest) || null == manifest.page_action) return;
+    if (!isPageActionLiveSurface(manifest, browser)) return 'unsupported';
+    if (isChromiumBasedBrowser(String(browser || '')) && null != manifest.browser_action) return 'conflicts';
+}
+function shouldDropPageAction(manifest, browser) {
+    return void 0 !== pageActionDropReason(manifest, browser);
+}
+function dropPageAction(manifest) {
+    if (!manifest || !('page_action' in manifest)) return manifest;
+    const rest = {
+        ...manifest
+    };
+    delete rest.page_action;
+    return rest;
+}
+function pageActionOutputTarget(manifest) {
+    const actionRef = actionPopupRef(manifest);
+    const pageRef = pageActionPopupRef(manifest);
+    if (actionRef && pageRef && popupRefsShareSource(actionRef, pageRef)) return ACTION_HTML_OUTPUT;
+    return PAGE_ACTION_HTML_OUTPUT;
+}
+function applyIndependentHtmlSurfaces(html, manifest, context, browser) {
+    const next = {
+        ...html || {}
+    };
+    const actionRef = actionPopupRef(manifest);
+    const pageRef = pageActionPopupRef(manifest);
+    const actionAbs = actionRef ? resolveManifestHtmlPath(context, actionRef) : void 0;
+    const pageAbs = pageRef ? resolveManifestHtmlPath(context, pageRef) : void 0;
+    if (actionAbs) next[ACTION_HTML_FEATURE] = actionAbs;
+    else delete next[ACTION_HTML_FEATURE];
+    if (!pageAbs || pageActionDropReason(manifest, browser)) {
+        delete next[PAGE_ACTION_HTML_FEATURE];
+        return next;
+    }
+    if (actionAbs && popupRefsShareSource(actionRef, pageRef)) {
+        delete next[PAGE_ACTION_HTML_FEATURE];
+        return next;
+    }
+    next[PAGE_ACTION_HTML_FEATURE] = pageAbs;
+    return next;
+}
 function isFromFilepathList(filePath, filepathList) {
     return Object.values(filepathList || {}).some((value)=>value === filePath);
 }
@@ -549,6 +636,11 @@ function collectRootAbsoluteRefs(source) {
     while(m = urlRe.exec(source))refs.add(m[1]);
     return refs;
 }
+function isManifestAddress(value) {
+    if ('string' != typeof value) return false;
+    const trimmed = value.trim();
+    return /^[a-z][a-z0-9+.-]+:/i.test(trimmed) || trimmed.startsWith('//');
+}
 function backgroundPage(manifest) {
     return manifest.background?.page && {
         background: {
@@ -559,35 +651,6 @@ function backgroundPage(manifest) {
         }
     };
 }
-function normalizeManifestOutputPath(originalPath) {
-    if (!originalPath) return originalPath;
-    const unixPath = originalPath.replace(/\\/g, '/');
-    if (/^\/public\//i.test(unixPath)) return unixPath.replace(/^\/public\//i, '');
-    if (/^(?:\.\/)?public\//i.test(unixPath)) return unixPath.replace(/^(?:\.\/)?public\//i, '');
-    if (/^\//.test(unixPath)) return unixPath.replace(/^\//, '');
-    return unixPath;
-}
-function manifestPageOutputTarget(raw, compiledTarget, manifestPath) {
-    const unixPath = raw.replace(/\\/g, '/');
-    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(unixPath)) return normalizeManifestOutputPath(unixPath);
-    if (/^\//.test(unixPath)) {
-        const rest = unixPath.replace(/^\/+/, '');
-        if (manifestPath && rest) {
-            const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
-            const inPublic = __rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(manifestDir, 'public', rest));
-            const inRoot = __rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(manifestDir, rest));
-            if (inRoot && !inPublic) return compiledTarget;
-        }
-        return normalizeManifestOutputPath(unixPath);
-    }
-    return compiledTarget;
-}
-function iconOutputPath(raw) {
-    if (/^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw)) return normalizeManifestOutputPath(raw);
-    const normalized = normalizeManifestOutputPath(raw).replace(/^\.\//, '');
-    const escapes = !normalized || normalized.split('/').includes('..') || /^[A-Za-z]:/.test(normalized);
-    return escapes ? `icons/${normalized.split('/').pop() || ''}` : normalized;
-}
 function chromeUrlOverrides(manifest, manifestPath) {
     return manifest.chrome_url_overrides && {
         chrome_url_overrides: {
@@ -696,16 +759,15 @@ function icons_icons(manifest) {
         }))
     };
 }
-const getBasename = (filepath)=>__rspack_external_node_path_c5b9b54f.basename(filepath);
 function omnibox_omnibox(manifest) {
     const omnibox = manifest.omnibox;
     return omnibox && {
         omnibox: {
             ...omnibox,
             ...omnibox.default_icon && {
-                default_icon: 'string' == typeof omnibox.default_icon ? getFilename(`icons/${getBasename(omnibox.default_icon)}`, omnibox.default_icon) : Object.fromEntries(Object.entries(omnibox.default_icon).map(([size, icon])=>[
+                default_icon: 'string' == typeof omnibox.default_icon ? getFilename(iconOutputPath(omnibox.default_icon), omnibox.default_icon) : Object.fromEntries(Object.entries(omnibox.default_icon).map(([size, icon])=>[
                         size,
-                        getFilename(`icons/${getBasename(icon)}`, icon)
+                        getFilename(iconOutputPath(icon), icon)
                     ]))
             }
         }
@@ -737,38 +799,37 @@ function permissions(manifest) {
         permissions: manifest.permissions
     };
 }
-function sandbox(manifest) {
+function sandbox(manifest, manifestPath) {
     return manifest.sandbox && {
         sandbox: {
             ...manifest.sandbox,
             ...manifest.sandbox.pages && {
-                pages: manifest.sandbox.pages.map((page, index)=>getFilename(`sandbox/page-${index}.html`, page))
+                pages: manifest.sandbox.pages.map((page, index)=>getFilename(manifestPageOutputTarget(page, `sandbox/page-${index}.html`, manifestPath), page))
             }
         }
     };
 }
-function storage(manifest, manifestPath) {
+function storage(manifest, manifestPath, projectPath) {
     return manifest.storage && {
         storage: {
             ...manifest.storage.managed_schema && {
                 managed_schema: (()=>{
                     const raw = String(manifest.storage.managed_schema);
-                    return getFilename(manifestPageOutputTarget(raw, 'storage/managed_schema.json', manifestPath), raw);
+                    return getFilename(manifestJsonOutputTarget(raw, 'storage/managed_schema.json', manifestPath, projectPath), raw);
                 })()
             }
         }
     };
 }
-const theme_getBasename = (filepath)=>__rspack_external_node_path_c5b9b54f.basename(filepath);
-const rewriteThemeImage = (value)=>getFilename(`theme/images/${theme_getBasename(value)}`, value);
-function theme_theme(manifest) {
+const rewriteThemeImage = (value, manifestPath)=>getFilename(manifestPageOutputTarget(value, themeImageOutputPath(value), manifestPath), value);
+function theme_theme(manifest, manifestPath) {
     return manifest.theme && {
         theme: {
             ...manifest.theme,
             ...manifest.theme.images && {
                 images: Object.fromEntries(Object.entries(manifest.theme.images).map(([key, value])=>[
                         key,
-                        Array.isArray(value) ? value.map(rewriteThemeImage) : rewriteThemeImage(value)
+                        Array.isArray(value) ? value.map((entry)=>rewriteThemeImage(entry, manifestPath)) : rewriteThemeImage(value, manifestPath)
                     ]))
             }
         }
@@ -809,7 +870,7 @@ function webAccessibleResources(manifest) {
         web_accessible_resources: entries
     };
 }
-function manifestCommon(manifest, manifestPath) {
+function manifestCommon(manifest, manifestPath, projectPath) {
     return {
         ...backgroundPage(manifest),
         ...chromeUrlOverrides(manifest, manifestPath),
@@ -820,9 +881,9 @@ function manifestCommon(manifest, manifestPath) {
         ...permissions(manifest),
         ...optionsPage(manifest, manifestPath),
         ...optionsUi(manifest, manifestPath),
-        ...sandbox(manifest),
-        ...storage(manifest, manifestPath),
-        ...theme_theme(manifest),
+        ...sandbox(manifest, manifestPath),
+        ...storage(manifest, manifestPath, projectPath),
+        ...theme_theme(manifest, manifestPath),
         ...userScripts(manifest),
         ...webAccessibleResources(manifest),
         ...contentSecurityPolicy(manifest),
@@ -834,7 +895,7 @@ function pageAction(manifest) {
         page_action: {
             ...manifest.page_action,
             ...manifest.page_action.default_popup && {
-                default_popup: getFilename('action/index.html', manifest.page_action.default_popup)
+                default_popup: getFilename(pageActionOutputTarget(manifest), manifest.page_action.default_popup)
             },
             ...manifest.page_action.default_icon && {
                 default_icon: 'string' == typeof manifest.page_action.default_icon ? (()=>{
@@ -905,73 +966,61 @@ function browserAction(manifest) {
                 theme_icons: manifest.browser_action.theme_icons.map((themeIcon)=>({
                         ...themeIcon,
                         ...themeIcon.light && {
-                            light: (()=>{
-                                const raw = String(themeIcon.light);
-                                const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
-                                const target = isPublic ? normalizeManifestOutputPath(raw) : `browser_action/${__rspack_external_node_path_c5b9b54f.basename(raw)}`;
-                                return getFilename(target, raw);
-                            })()
+                            light: getFilename(themeIconOutputPath(String(themeIcon.light), 'browser_action'), String(themeIcon.light))
                         },
                         ...themeIcon.dark && {
-                            dark: (()=>{
-                                const raw = String(themeIcon.dark);
-                                const isPublic = /^(?:\/public\/|(?:\.\/)?public\/)/i.test(raw);
-                                const target = isPublic ? normalizeManifestOutputPath(raw) : `browser_action/${__rspack_external_node_path_c5b9b54f.basename(raw)}`;
-                                return getFilename(target, raw);
-                            })()
+                            dark: getFilename(themeIconOutputPath(String(themeIcon.dark), 'browser_action'), String(themeIcon.dark))
                         }
                     }))
             }
         }
     };
 }
-function chromeSettingsOverrides(manifest) {
-    return manifest.chrome_settings_overrides && {
+function chromeSettingsOverrides(manifest, manifestPath) {
+    const overrides = manifest.chrome_settings_overrides;
+    return overrides && {
         chrome_settings_overrides: {
-            ...manifest.chrome_settings_overrides.homepage && {
-                homepage: manifest.chrome_settings_overrides.homepage
+            ...overrides.homepage && {
+                homepage: overrides.homepage
             },
-            ...manifest.chrome_settings_overrides.search_provider && {
+            ...overrides.search_provider && {
                 search_provider: {
-                    ...manifest.chrome_settings_overrides.search_provider,
-                    ...manifest.chrome_settings_overrides.search_provider.favicon_url && {
+                    ...overrides.search_provider,
+                    ...overrides.search_provider.favicon_url && {
                         favicon_url: (()=>{
-                            const fav = manifest.chrome_settings_overrides.search_provider.favicon_url;
-                            const isUrl = /^(?:[a-z]+:)?\/\//i.test(fav);
-                            return isUrl ? fav : getFilename(`chrome_settings_overrides/${fav.split('/').pop()}`, fav);
+                            const fav = String(overrides.search_provider.favicon_url);
+                            if (isManifestAddress(fav)) return fav;
+                            return getFilename(manifestPageOutputTarget(fav, `chrome_settings_overrides/${__rspack_external_node_path_c5b9b54f.basename(fav)}`, manifestPath), fav);
                         })()
                     }
                 }
             },
-            ...manifest.chrome_settings_overrides.startup_pages && {
-                startup_pages: manifest.chrome_settings_overrides.startup_pages.map((page, index)=>getFilename(`chrome_settings_overrides/startup-${index}.html`, page))
+            ...overrides.startup_pages && {
+                startup_pages: overrides.startup_pages.map((page, index)=>isManifestAddress(page) ? page : getFilename(manifestPageOutputTarget(page, `chrome_settings_overrides/startup-${index}.html`, manifestPath), page))
             }
         }
     };
 }
-const theme_experiment_getBasename = (filepath)=>__rspack_external_node_path_c5b9b54f.basename(filepath);
-function themeExperiment(manifest) {
+const getBasename = (filepath)=>__rspack_external_node_path_c5b9b54f.basename(filepath);
+function themeExperiment(manifest, manifestPath) {
     const te = manifest.theme_experiment;
     return te && {
         theme_experiment: {
             ...te,
             ...'string' == typeof te.stylesheet && {
-                stylesheet: getFilename(`theme_experiment/${theme_experiment_getBasename(te.stylesheet)}`, te.stylesheet)
-            },
-            ...Array.isArray(te.stylesheets) && {
-                stylesheets: te.stylesheets.map((s, i)=>getFilename(`theme_experiment/stylesheet-${i}.css`, s))
+                stylesheet: getFilename(manifestPageOutputTarget(te.stylesheet, `theme_experiment/${getBasename(te.stylesheet)}`, manifestPath), te.stylesheet)
             }
         }
     };
 }
-function manifestV2(manifest) {
+function manifestV2(manifest, manifestPath) {
     return {
         ...background_background(manifest),
         ...browserAction(manifest),
         ...pageAction(manifest),
         ...sidebarAction(manifest),
-        ...chromeSettingsOverrides(manifest),
-        ...themeExperiment(manifest)
+        ...chromeSettingsOverrides(manifest, manifestPath),
+        ...themeExperiment(manifest, manifestPath)
     };
 }
 function action_action(manifest) {
@@ -992,6 +1041,17 @@ function action_action(manifest) {
                         getFilename(iconOutputPath(raw), raw)
                     ];
                 }))
+            },
+            ...manifest.action.theme_icons && {
+                theme_icons: manifest.action.theme_icons.map((themeIcon)=>({
+                        ...themeIcon,
+                        ...themeIcon.light && {
+                            light: getFilename(themeIconOutputPath(String(themeIcon.light), 'action'), String(themeIcon.light))
+                        },
+                        ...themeIcon.dark && {
+                            dark: getFilename(themeIconOutputPath(String(themeIcon.dark), 'action'), String(themeIcon.dark))
+                        }
+                    }))
             }
         }
     };
@@ -1006,14 +1066,14 @@ function backgroundServiceWorker(manifest) {
         }
     };
 }
-function declarativeNetRequest(manifest, manifestPath) {
+function declarativeNetRequest(manifest, manifestPath, projectPath) {
     return manifest.declarative_net_request && {
         declarative_net_request: {
             ...manifest.declarative_net_request,
             ...Array.isArray(manifest.declarative_net_request.rule_resources) && {
                 rule_resources: manifest.declarative_net_request.rule_resources.map((resourceObj)=>({
                         ...resourceObj,
-                        path: resourceObj.path && getFilename(manifestPageOutputTarget(resourceObj.path, `declarative_net_request/${resourceObj.id}.json`, manifestPath), resourceObj.path)
+                        path: resourceObj.path && getFilename(manifestJsonOutputTarget(resourceObj.path, `declarative_net_request/${resourceObj.id}.json`, manifestPath, projectPath), resourceObj.path)
                     }))
             }
         }
@@ -1037,16 +1097,17 @@ function sidePanel(manifest) {
         }
     };
 }
-function manifestV3(manifest, manifestPath) {
+function manifestV3(manifest, manifestPath, projectPath) {
     return {
         ...action_action(manifest),
+        ...pageAction(manifest),
         ...backgroundServiceWorker(manifest),
-        ...declarativeNetRequest(manifest, manifestPath),
+        ...declarativeNetRequest(manifest, manifestPath, projectPath),
         ...hostPermissions(manifest),
         ...sidePanel(manifest)
     };
 }
-function getManifestOverrides(manifestPath, manifest) {
+function getManifestOverrides(manifestPath, manifest, projectPath) {
     const manifestContent = manifest || JSON.parse(stripBom(__rspack_external_node_fs_5ea92f0c.readFileSync(manifestPath, 'utf8')));
     const omit = (obj, key)=>{
         if (!obj) return {};
@@ -1057,9 +1118,9 @@ function getManifestOverrides(manifestPath, manifest) {
         const value = obj.background;
         return value && 'object' == typeof value ? value : {};
     };
-    const common = manifestCommon(manifestContent, manifestPath);
-    const mv2 = manifestV2(manifestContent);
-    const mv3 = manifestV3(manifestContent, manifestPath);
+    const common = manifestCommon(manifestContent, manifestPath, projectPath);
+    const mv2 = manifestV2(manifestContent, manifestPath);
+    const mv3 = manifestV3(manifestContent, manifestPath, projectPath);
     const backgroundMerged = {
         ...manifestContent.background || {},
         ...pickBackground(common),
@@ -1138,11 +1199,12 @@ function getManifestContent(compilation, manifestPath) {
         return manifest_cjsRequire(manifestPath);
     }
 }
-function buildCanonicalManifest(manifestPath, manifest, browser) {
+function buildCanonicalManifest(manifestPath, manifest, browser, projectPath) {
     const filteredManifest = filterKeysForThisBrowser(manifest, browser);
+    const forOverrides = shouldDropPageAction(filteredManifest, browser) ? dropPageAction(filteredManifest) : filteredManifest;
     return {
-        ...filteredManifest,
-        ...JSON.parse(getManifestOverrides(manifestPath, filteredManifest))
+        ...forOverrides,
+        ...JSON.parse(getManifestOverrides(manifestPath, forOverrides, projectPath))
     };
 }
 function resolveProcessShim() {
@@ -1452,7 +1514,7 @@ class ZipPlugin {
                     if (isDebug()) console.log(packagingDistributionFiles(distPath));
                     writeZipFile(distPath, listFilesUnder(outPath, new Set([
                         toPosix(zipName)
-                    ])).map((file)=>({
+                    ])).filter((file)=>!file.endsWith('.map')).map((file)=>({
                             name: file,
                             absPath: __rspack_external_node_path_c5b9b54f.join(outPath, file)
                         })));
@@ -1547,7 +1609,7 @@ class CompilationPlugin {
                 'process.env.NODE_ENV': JSON.stringify(compiler.options.mode || 'development')
             }).apply(compiler);
         } catch  {}
-        if ((this.zip || this.zipSource) && 'production' === compiler.options.mode) new ZipPlugin({
+        if ((this.zip || this.zipSource) && 'dev' !== this.command) new ZipPlugin({
             manifestPath: this.manifestPath,
             browser: this.browser || 'chrome',
             zipData: {
@@ -1557,7 +1619,7 @@ class CompilationPlugin {
             }
         }).apply(compiler);
         else if (isDebug()) {
-            const reason = 'production' !== compiler.options.mode ? 'not production mode' : 'zip disabled';
+            const reason = 'dev' === this.command ? 'a dev session never packages' : 'zip disabled';
             console.log(zipPackagingSkipped(reason));
         }
         new BoringPlugin({
@@ -1716,6 +1778,10 @@ function getOptionalDependencyContract(contractId) {
     if (!contract) throw new Error(`Unknown optional dependency contract: ${contractId}`);
     return contract;
 }
+function debugSwallowed(step, error) {
+    if (!isVerboseMode()) return;
+    console.log(`${messaging_prefix('debug')} optional-deps ${step}: ${String(error?.message || error)}`);
+}
 function isVerboseMode() {
     return '1' === String(process.env.EXTENSION_VERBOSE || '').trim();
 }
@@ -1773,7 +1839,8 @@ function tryResolveWithBase(dependencyId, basePath) {
     try {
         const req = createRequire(optional_deps_resolver_packageJsonPath(basePath));
         return req.resolve(dependencyId);
-    } catch  {
+    } catch (error) {
+        debugSwallowed(`resolve ${dependencyId} from ${basePath}`, error);
         return;
     }
 }
@@ -1794,7 +1861,8 @@ function resolveDependency(dependencyId, projectPath) {
             resolvedPath,
             basePath: projectPath
         };
-    } catch  {
+    } catch (error) {
+        debugSwallowed(`resolve ${dependencyId} from the project bases`, error);
         return;
     }
 }
@@ -1806,7 +1874,8 @@ function resolveFromKnownLocations(dependencyId, projectPath) {
 function declaresDependency(projectPath, dependencyId) {
     try {
         return hasProjectDependency(projectPath, dependencyId);
-    } catch  {
+    } catch (error) {
+        debugSwallowed(`read the project manifest for ${dependencyId}`, error);
         return false;
     }
 }
@@ -1816,7 +1885,8 @@ function dedupeFailures(packageIds) {
 function resolveRealPathSafe(targetPath) {
     try {
         return __rspack_external_node_fs_5ea92f0c.realpathSync(targetPath);
-    } catch  {
+    } catch (error) {
+        debugSwallowed(`realpath ${targetPath}`, error);
         return __rspack_external_node_path_c5b9b54f.resolve(targetPath);
     }
 }
@@ -1843,7 +1913,8 @@ function evaluateModuleContextRule(rule, fromPackagePath, options) {
         if (options?.expectedInstalledPath && !isSameInstalledPackage(resolvedPeer, options.expectedInstalledPath)) return rule.packageId;
         if ('module-context-load' === rule.type) req(rule.packageId);
         return;
-    } catch  {
+    } catch (error) {
+        debugSwallowed(`verify ${rule.packageId}`, error);
         return rule.packageId;
     }
 }
@@ -2204,14 +2275,20 @@ async function loadUserPostCssConfigObject(configPath, projectPath, mode) {
     try {
         if (configPath.endsWith('.postcssrc') || configPath.endsWith('.json')) loaded = JSON.parse(__rspack_external_node_fs_5ea92f0c.readFileSync(configPath, 'utf8'));
         else if (configPath.endsWith('.yaml') || configPath.endsWith('.yml')) return;
-        else if (configPath.endsWith('.cjs')) loaded = tryLoadCjsConfig(configPath);
+        else if (configPath.endsWith('.cjs')) loaded = tryLoadCjsConfig(configPath, {
+            report: true
+        });
         else try {
             const mod = await import(pathToFileURL(configPath).href);
             loaded = mod?.default ?? mod;
-        } catch  {
-            loaded = tryLoadCjsConfig(configPath);
+        } catch (importError) {
+            loaded = tryLoadCjsConfig(configPath, {
+                report: false
+            });
+            if (void 0 === loaded) return void console.warn(postCssConfigUnreadable(configPath, importError));
         }
-    } catch  {
+    } catch (error) {
+        console.warn(postCssConfigUnreadable(configPath, error));
         return;
     }
     if ('function' == typeof loaded) try {
@@ -2220,10 +2297,14 @@ async function loadUserPostCssConfigObject(configPath, projectPath, mode) {
             mode,
             cwd: projectPath
         });
-    } catch  {
+    } catch (error) {
+        console.warn(postCssConfigUnreadable(configPath, error));
         return;
     }
-    return loaded && 'object' == typeof loaded ? loaded : void 0;
+    if (!loaded || 'object' != typeof loaded) return;
+    const plugins = loaded.plugins;
+    if (null != plugins && !Array.isArray(plugins) && 'object' != typeof plugins) return void console.warn(postCssConfigPluginsShape(configPath, typeof plugins));
+    return loaded;
 }
 function unwrapDefaultExport(mod) {
     return mod && 'object' == typeof mod && 'default' in mod ? mod.default : mod;
@@ -2304,7 +2385,9 @@ function resolveConfigPluginList(rawPlugins, ctx) {
         unresolved
     };
 }
-function tryLoadCjsConfig(configPath) {
+function tryLoadCjsConfig(configPath, options = {
+    report: true
+}) {
     try {
         const source = __rspack_external_node_fs_5ea92f0c.readFileSync(configPath, 'utf8');
         const moduleObj = {
@@ -2315,7 +2398,8 @@ function tryLoadCjsConfig(configPath) {
         const fn = new Function('require', 'module', 'exports', '__filename', '__dirname', source);
         fn(req, moduleObj, exportsObj, configPath, __rspack_external_node_path_c5b9b54f.dirname(configPath));
         return moduleObj.exports;
-    } catch  {
+    } catch (error) {
+        if (options.report) console.warn(postCssConfigUnreadable(configPath, error));
         return;
     }
 }
@@ -2726,22 +2810,51 @@ async function buildCssRules(projectPath, mode, usage, opts) {
         if (missingTool) use.push({
             loader: resolveDevelopDistFile('preprocessor-passthrough-loader')
         });
-        if ('css' === type || 'css/module' === type) use.unshift({
-            loader: resolveDevelopDistFile('late-css-import-loader')
-        });
-        if ('asset/inline' === type && manifestPath) use.unshift({
-            loader: resolveDevelopDistFile('dead-css-url-loader'),
-            options: {
-                manifestPath,
-                projectPath
-            }
-        });
+        if ('css' === type || 'css/module' === type) {
+            const guard = resolveDevelopDistFile('css-parse-guard-loader');
+            const list = use;
+            if (!list.some((entry)=>entry?.loader === guard)) list.unshift({
+                loader: guard
+            });
+            list.unshift({
+                loader: resolveDevelopDistFile('late-css-import-loader')
+            });
+        }
+        let ruleType = type;
+        let parser;
+        if ('asset/inline' === type && manifestPath) {
+            use.unshift({
+                loader: resolveDevelopDistFile('dead-css-url-loader'),
+                options: {
+                    manifestPath,
+                    projectPath,
+                    sheet: 'inline'
+                }
+            });
+            ruleType = "javascript/auto";
+        }
+        if ('css/module' === type && 'asset/inline' === nonModuleType && manifestPath) {
+            use.unshift({
+                loader: resolveDevelopDistFile('dead-css-url-loader'),
+                options: {
+                    manifestPath,
+                    projectPath,
+                    sheet: 'chunk'
+                }
+            });
+            parser = {
+                url: false
+            };
+        }
         return {
             test,
             exclude,
-            type,
+            type: ruleType,
             issuer,
-            use
+            use,
+            ...parser ? {
+                parser
+            } : {}
         };
     }));
 }
@@ -2757,10 +2870,10 @@ function getContentScriptIndex(manifestPath, projectPath) {
     const manifest = parseJsonSafe(__rspack_external_node_fs_5ea92f0c.readFileSync(manifestPath, 'utf8'));
     const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
     const contentPaths = new Set();
-    for (const content of manifest.content_scripts || [])if (content.js?.length) for (const js of content.js)contentPaths.add(__rspack_external_node_path_c5b9b54f.resolve(manifestDir, js));
+    for (const content of manifest.content_scripts || [])if (content.js?.length) for (const js of content.js)contentPaths.add(toResourceKey(__rspack_external_node_path_c5b9b54f.resolve(manifestDir, js)));
     const index = {
         mtimeMs,
-        scriptsDir: __rspack_external_node_path_c5b9b54f.resolve(projectPath, "scripts"),
+        scriptsDir: canonicalizeDir(__rspack_external_node_path_c5b9b54f.resolve(projectPath, "scripts")),
         contentPaths
     };
     indexCache.set(cacheKey, index);
@@ -2770,7 +2883,7 @@ function isContentScriptEntry(absolutePath, manifestPath, projectPath) {
     if (!absolutePath || !manifestPath || !projectPath) return false;
     if (!__rspack_external_node_fs_5ea92f0c.existsSync(manifestPath)) return false;
     const { scriptsDir, contentPaths } = getContentScriptIndex(manifestPath, projectPath);
-    const absPathNormalized = __rspack_external_node_path_c5b9b54f.resolve(absolutePath);
+    const absPathNormalized = toResourceKey(absolutePath);
     const relToScripts = __rspack_external_node_path_c5b9b54f.relative(scriptsDir, absPathNormalized);
     const isScriptsFolderScript = relToScripts && !relToScripts.startsWith('..') && !__rspack_external_node_path_c5b9b54f.isAbsolute(relToScripts);
     if (isScriptsFolderScript) return true;
@@ -2839,6 +2952,38 @@ class CssPlugin {
             console.log(cssConfigsDetected(postcssConfig, tailwindConfig, browserslistSource));
         }
     }
+    keepCssParityInProduction(compiler) {
+        if (!compiler.hooks?.thisCompilation?.tap) return;
+        compiler.hooks.thisCompilation.tap(`${CssPlugin.name}:parity`, (c)=>{
+            if (!c?.hooks?.processAssets?.tap) return;
+            const beforeMinify = new Map();
+            c.hooks.processAssets.tap({
+                name: `${CssPlugin.name}:parity-snapshot`,
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE - 1
+            }, ()=>{
+                for (const asset of c.getAssets())if (asset.name.endsWith('.css')) beforeMinify.set(asset.name, asset.source.source().toString());
+            });
+            c.hooks.processAssets.tap({
+                name: `${CssPlugin.name}:parity-restore`,
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1
+            }, ()=>{
+                const restored = new Set(restoreVerbatimCssAssets(c));
+                for (const asset of c.getAssets()){
+                    if (!asset.name.endsWith('.css') || restored.has(asset.name)) continue;
+                    const before = beforeMinify.get(asset.name);
+                    if (void 0 === before) continue;
+                    const after = asset.source.source().toString();
+                    if (after === before) continue;
+                    const dropped = minifierDroppedTokens(before, after);
+                    if (0 === dropped.length) continue;
+                    c.updateAsset(asset.name, new core_sources.RawSource(before));
+                    const warning = new core_WebpackError(cssMinifierDroppedRules(asset.name, dropped));
+                    warning.file = asset.name;
+                    c.warnings.push(warning);
+                }
+            });
+        });
+    }
     tolerateDeadUrlRefs(compiler) {
         const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(this.manifestPath);
         const projectPath = compiler.options.context || process.cwd();
@@ -2886,10 +3031,12 @@ class CssPlugin {
         });
     }
     async apply(compiler) {
+        this.keepCssParityInProduction(compiler);
         this.tolerateDeadUrlRefs(compiler);
         const mode = compiler.options.mode || 'development';
         if ('production' === mode) return void compiler.hooks.beforeRun.tapPromise(CssPlugin.name, ()=>this.configureOptions(compiler));
         const configuring = this.configureOptions(compiler);
+        compiler.hooks.beforeRun.tapPromise(CssPlugin.name, ()=>configuring);
         compiler.hooks.watchRun.tapPromise(CssPlugin.name, ()=>configuring);
         await configuring;
     }
@@ -2915,299 +3062,19 @@ function findBrowserslistSource(projectPath) {
         if (__rspack_external_node_fs_5ea92f0c.existsSync(p)) return p;
     }
 }
-function parse_html_isUrl(src) {
-    try {
-        new URL(src);
-        return true;
-    } catch (err) {
-        return false;
-    }
-}
-function emitSrcsetCandidates(srcset, node, assetType, attributeName, onResourceFound) {
-    for (const candidate of srcset.split(',')){
-        const url = candidate.trim().split(/\s+/)[0];
-        if (!url) continue;
-        const { cleanPath } = cleanAssetUrl(url);
-        if (cleanPath && !parse_html_isUrl(cleanPath)) onResourceFound({
-            filePath: url,
-            childNode: node,
-            assetType,
-            attributeName
-        });
-    }
-}
-function parseHtml(node, onResourceFound) {
-    if ('#comment' === node.nodeName || '#text' === node.nodeName) return;
-    if ("script" === node.nodeName) {
-        const src = node.attrs?.find((attr)=>'src' === attr.name)?.value;
-        if (!src) return;
-        if (parse_html_isUrl(src)) return;
-        onResourceFound({
-            filePath: src,
-            childNode: node,
-            assetType: "script"
-        });
-    } else if ('link' === node.nodeName) {
-        const href = node.attrs?.find((attr)=>'href' === attr.name)?.value;
-        const rel = node.attrs?.find((attr)=>'rel' === attr.name)?.value;
-        const imagesrcset = node.attrs?.find((attr)=>'imagesrcset' === attr.name)?.value;
-        if (imagesrcset) emitSrcsetCandidates(imagesrcset, node, 'staticHref', 'imagesrcset', onResourceFound);
-        if (!href) return;
-        if (parse_html_isUrl(href)) return;
-        const nonStylesheetRelTokens = [
-            'dns-prefetch',
-            'icon',
-            'apple-touch-icon',
-            'apple-touch-icon-precomposed',
-            'mask-icon',
-            'manifest',
-            'modulepreload',
-            'preconnect',
-            'prefetch',
-            'preload',
-            'prerender'
-        ];
-        const relTokens = rel ? rel.toLowerCase().split(/\s+/) : [];
-        onResourceFound(relTokens.some((token)=>nonStylesheetRelTokens.includes(token)) ? {
-            filePath: href,
-            childNode: node,
-            assetType: 'staticHref',
-            attributeName: 'href'
-        } : {
-            filePath: href,
-            childNode: node,
-            assetType: 'css'
-        });
-    } else if ('audio' === node.nodeName || 'embed' === node.nodeName || 'iframe' === node.nodeName || 'img' === node.nodeName || 'input' === node.nodeName || 'source' === node.nodeName || 'track' === node.nodeName || 'video' === node.nodeName) {
-        const src = node.attrs?.find((attr)=>'src' === attr.name)?.value;
-        if (src && !parse_html_isUrl(src)) onResourceFound({
-            filePath: src,
-            childNode: node,
-            assetType: 'staticSrc',
-            attributeName: 'src'
-        });
-        const srcset = node.attrs?.find((attr)=>'srcset' === attr.name)?.value;
-        if (srcset) emitSrcsetCandidates(srcset, node, 'staticSrc', 'srcset', onResourceFound);
-        if ('video' === node.nodeName) {
-            const poster = node.attrs?.find((attr)=>'poster' === attr.name)?.value;
-            if (poster && !parse_html_isUrl(poster)) onResourceFound({
-                filePath: poster,
-                childNode: node,
-                assetType: 'staticSrc',
-                attributeName: 'poster'
-            });
-        }
-    }
-    const { childNodes = [] } = node;
-    for (const childNode of childNodes)if ('#comment' !== childNode.nodeName && '#text' !== childNode.nodeName) parseHtml(childNode, onResourceFound);
-}
-const cloneParsedHtmlAsset = (assets)=>({
-        css: [
-            ...assets.css || []
-        ],
-        js: [
-            ...assets.js || []
-        ],
-        moduleJs: [
-            ...assets.moduleJs || []
-        ],
-        static: [
-            ...assets.static || []
-        ]
+function getResolvedManifestFieldsData(options) {
+    const data = getManifestFieldsData({
+        manifestPath: options.manifestPath,
+        browser: options.browser
     });
-const assetsFromHtmlCache = new Map();
-function getAssetsFromHtml(htmlFilePath, htmlContent) {
-    const assets = {
-        css: [],
-        js: [],
-        moduleJs: [],
-        static: []
-    };
-    if (!htmlFilePath) return assets;
-    let cacheKey;
-    if (void 0 === htmlContent) try {
-        const stat = __rspack_external_node_fs_5ea92f0c.statSync(htmlFilePath);
-        cacheKey = `${stat.mtimeMs}:${stat.size}`;
-        const cached = assetsFromHtmlCache.get(htmlFilePath);
-        if (cached && cached.key === cacheKey) return cloneParsedHtmlAsset(cached.assets);
-    } catch  {
-        cacheKey = void 0;
-    }
     try {
-        const htmlString = htmlContent || __rspack_external_node_fs_5ea92f0c.readFileSync(htmlFilePath, {
-            encoding: 'utf8'
-        });
-        if (!htmlString) return assets;
-        const htmlDocument = __rspack_external_parse5_utilities_78b19c6a.parse(htmlString);
-        const baseHref = getBaseHref(htmlDocument);
-        const getAbsolutePath = (htmlFilePath, filePathWithParts)=>{
-            const { cleanPath } = cleanAssetUrl(filePathWithParts);
-            if (utils_isUrl(cleanPath)) return cleanPath;
-            if (cleanPath.startsWith('/')) return cleanPath;
-            const isBaseUrl = utils_isUrl(baseHref || '');
-            const baseJoin = baseHref && !isBaseUrl ? __rspack_external_node_path_c5b9b54f.join(__rspack_external_node_path_c5b9b54f.dirname(htmlFilePath), baseHref) : __rspack_external_node_path_c5b9b54f.dirname(htmlFilePath);
-            return __rspack_external_node_path_c5b9b54f.join(baseJoin, cleanPath);
+        const manifest = filterKeysForThisBrowser(parseJsonSafe(__rspack_external_node_fs_5ea92f0c.readFileSync(options.manifestPath, 'utf-8')), options.browser || 'chrome');
+        return {
+            ...data,
+            html: applyIndependentHtmlSurfaces(data.html || {}, manifest, __rspack_external_node_path_c5b9b54f.dirname(options.manifestPath), options.browser)
         };
-        parseHtml(htmlDocument, ({ filePath, childNode, assetType })=>{
-            const fileAbsolutePath = getAbsolutePath(htmlFilePath, filePath);
-            switch(assetType){
-                case "script":
-                    {
-                        assets.js?.push(fileAbsolutePath);
-                        const scriptType = childNode?.attrs?.find((attr)=>'type' === attr.name)?.value;
-                        if ('module' === String(scriptType || '').toLowerCase()) assets.moduleJs?.push(fileAbsolutePath);
-                        break;
-                    }
-                case 'css':
-                    assets.css?.push(fileAbsolutePath);
-                    break;
-                case 'staticSrc':
-                case 'staticHref':
-                    if (filePath.startsWith('#')) break;
-                    assets.static?.push(fileAbsolutePath);
-                    break;
-                default:
-                    break;
-            }
-        });
-    } catch (error) {
-        const code = error?.code;
-        if (void 0 === htmlContent && 'ENOENT' === code) {
-            assetsFromHtmlCache.delete(htmlFilePath);
-            throw error;
-        }
-        return assets;
-    }
-    if (cacheKey) assetsFromHtmlCache.set(htmlFilePath, {
-        key: cacheKey,
-        assets: cloneParsedHtmlAsset(assets)
-    });
-    return assets;
-}
-function getHtmlPageDeclaredAssetPath(filepathList, filePath, extension) {
-    const entryname = Object.keys(filepathList).find((key)=>{
-        const includePath = filepathList[key];
-        if (includePath === filePath) return true;
-        if (!includePath || !__rspack_external_node_fs_5ea92f0c.existsSync(includePath)) return false;
-        const assets = getAssetsFromHtml(includePath);
-        return Boolean(assets?.js?.includes(filePath) || assets?.css?.includes(filePath));
-    }) || '';
-    const extname = getExtname(filePath);
-    if (!entryname) return `${filePath.replace(extname, '')}${extension}`;
-    return `/${entryname.replace(extname, '')}${extension}`;
-}
-function getExtname(filePath) {
-    return __rspack_external_node_path_c5b9b54f.extname(filePath);
-}
-function getFilePath(filePath, extension, isPublic) {
-    if (isPublic) return `/${filePath}${extension}`;
-    return `${filePath}${extension}`;
-}
-function isFromIncludeList(filePath, includeList) {
-    return Object.values(includeList || {}).some((value)=>value === filePath);
-}
-function utils_isUrl(src) {
-    try {
-        new URL(src);
-        return true;
-    } catch (err) {
-        return false;
-    }
-}
-function resolveStaticAttributeName(assetType, attributeName) {
-    if (attributeName) return attributeName;
-    return 'staticSrc' === assetType ? 'src' : 'href';
-}
-function rewriteSrcsetCandidate(srcset, fromCleanPath, toUrl) {
-    return srcset.split(',').map((candidate)=>{
-        const match = candidate.match(/^(\s*)(\S+)(.*)$/);
-        if (!match) return candidate;
-        const [, lead, url, rest] = match;
-        const { cleanPath } = cleanAssetUrl(url);
-        if (cleanPath !== fromCleanPath && url !== fromCleanPath) return candidate;
-        return `${lead}${toUrl}${rest}`;
-    }).join(',');
-}
-function applyRewrittenStaticUrl(node, attributeName, cleanPath, value) {
-    if ('srcset' === attributeName || 'imagesrcset' === attributeName) {
-        const current = __rspack_external_parse5_utilities_78b19c6a.getAttribute(node, attributeName) || '';
-        return __rspack_external_parse5_utilities_78b19c6a.setAttribute(node, attributeName, rewriteSrcsetCandidate(current, cleanPath, value));
-    }
-    return __rspack_external_parse5_utilities_78b19c6a.setAttribute(node, attributeName, value);
-}
-function cleanAssetUrl(url) {
-    const hashIndex = url.indexOf('#');
-    const queryIndex = url.indexOf('?');
-    let endIndex = url.length;
-    if (-1 !== hashIndex && -1 !== queryIndex) endIndex = Math.min(hashIndex, queryIndex);
-    else if (-1 !== hashIndex) endIndex = hashIndex;
-    else if (-1 !== queryIndex) endIndex = queryIndex;
-    const cleanPath = url.slice(0, endIndex);
-    const hash = -1 !== hashIndex ? url.slice(hashIndex) : '';
-    const search = -1 !== queryIndex ? url.slice(queryIndex, -1 !== hashIndex ? hashIndex : void 0) : '';
-    return {
-        cleanPath,
-        hash,
-        search
-    };
-}
-function isHttpLike(inputUrl) {
-    return /^https?:\/\//i.test(inputUrl) || inputUrl.startsWith('//');
-}
-function isSpecialScheme(u) {
-    return /^(data:|blob:|chrome-extension:|javascript:|about:)/i.test(u);
-}
-function cleanLeading(s) {
-    return s.replace(/^\/+/, '').replace(/^\.\//, '').replace(/^\./, '');
-}
-function joinEmittedAssetName(prefix, rel) {
-    const parts = __rspack_external_node_path_c5b9b54f.posix.join(prefix, rel).split('/');
-    let i = 0;
-    while(i < parts.length && ('..' === parts[i] || '.' === parts[i]))i++;
-    return parts.slice(i).join('/') || __rspack_external_node_path_c5b9b54f.posix.basename(rel);
-}
-function computePosixRelative(fromPath, toPath) {
-    const fromRoot = __rspack_external_node_path_c5b9b54f.parse(fromPath).root;
-    const toRoot = __rspack_external_node_path_c5b9b54f.parse(toPath).root;
-    if (fromRoot && toRoot && String(fromRoot).toLowerCase() !== String(toRoot).toLowerCase()) {
-        const base = __rspack_external_node_path_c5b9b54f.basename(toPath);
-        return base.split(__rspack_external_node_path_c5b9b54f.sep).join('/');
-    }
-    const rel = __rspack_external_node_path_c5b9b54f.relative(__rspack_external_node_path_c5b9b54f.dirname(fromPath), toPath) || toPath;
-    return rel.split(__rspack_external_node_path_c5b9b54f.sep).join('/');
-}
-function resolveAbsoluteFsPath(params) {
-    const { asset, projectRoot, publicRootForResource, outputRoot, manifestRoot } = params;
-    const isRootUrl = asset.startsWith('/') && !(asset.startsWith(projectRoot) || asset.startsWith(publicRootForResource) || asset.startsWith(outputRoot));
-    const isDotPublic = asset.startsWith('./public/');
-    const isPlainPublic = asset.startsWith('public/');
-    const absoluteFsPath = isRootUrl ? (()=>{
-        const rootRelative = asset.slice(1);
-        const normalized = cleanLeading(rootRelative);
-        const withoutPublicPrefix = normalized.replace(/^public\//, '');
-        const candidate = __rspack_external_node_path_c5b9b54f.join(publicRootForResource, withoutPublicPrefix);
-        if (__rspack_external_node_fs_5ea92f0c.existsSync(candidate)) return candidate;
-        const manifestCandidate = manifestRoot ? __rspack_external_node_path_c5b9b54f.join(manifestRoot, normalized) : '';
-        if (manifestCandidate && __rspack_external_node_fs_5ea92f0c.existsSync(manifestCandidate)) return manifestCandidate;
-        return manifestCandidate || candidate;
-    })() : isDotPublic ? __rspack_external_node_path_c5b9b54f.join(projectRoot, cleanLeading(asset)) : isPlainPublic ? __rspack_external_node_path_c5b9b54f.join(projectRoot, asset.replace(/^\./, '')) : __rspack_external_node_path_c5b9b54f.isAbsolute(asset) ? asset : __rspack_external_node_path_c5b9b54f.join(projectRoot, asset);
-    const relToPublic = __rspack_external_node_path_c5b9b54f.relative(publicRootForResource, absoluteFsPath);
-    const isUnderPublicRoot = relToPublic && !relToPublic.startsWith('..') && !__rspack_external_node_path_c5b9b54f.isAbsolute(relToPublic);
-    return {
-        absoluteFsPath,
-        isUnderPublicRoot: Boolean(isUnderPublicRoot),
-        isRootUrl
-    };
-}
-function getBaseHref(htmlDocument) {
-    const htmlChildren = htmlDocument.childNodes || [];
-    for (const node of htmlChildren)if (node?.nodeName === 'html') {
-        for (const child of node.childNodes || [])if (child?.nodeName === 'head') {
-            for (const headChild of child.childNodes || [])if (headChild?.nodeName === 'base') {
-                const href = headChild.attrs?.find((a)=>'href' === a.name)?.value;
-                if (href) return href;
-            }
-        }
+    } catch  {
+        return data;
     }
 }
 let preact_userMessageDelivered = false;
@@ -3322,6 +3189,40 @@ async function maybeUseReact(projectPath, options = {}) {
         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_c5b9b54f.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 = [
@@ -3351,6 +3252,106 @@ async function loadLoaderOptions(projectPath, framework) {
     }
     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;
+}
+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(!isProd),
+            __VUE_PROD_DEVTOOLS__: JSON.stringify(!isProd),
+            __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: JSON.stringify(!isProd)
+        })
+    ];
+    const requireFromProject = createRequire(__rspack_external_node_path_c5b9b54f.join(projectPath, 'package.json'));
+    const resolveFromProject = (id)=>{
+        try {
+            return requireFromProject.resolve(id);
+        } catch  {
+            return;
+        }
+    };
+    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_c5b9b54f.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) {
     for (const base of [
@@ -3457,72 +3458,30 @@ async function maybeUseSvelte(projectPath, mode) {
         alias: Object.keys(alias).length > 0 ? alias : void 0
     };
 }
-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;
+const DEFAULT_SWC_TARGETS = [
+    'chrome >= 100'
+];
+function resolveSwcTargets(rawManifest, browser) {
+    if (!rawManifest || 'object' != typeof rawManifest) return [
+        ...DEFAULT_SWC_TARGETS
+    ];
+    const name = String(browser || 'chrome');
+    const manifest = filterKeysForThisBrowser(rawManifest, name);
+    if (isGeckoBasedBrowser(name)) {
+        const geckoMin = manifest.browser_specific_settings?.gecko?.strict_min_version || manifest.applications?.gecko?.strict_min_version;
+        const major = parseInt(String(geckoMin ?? '').split('.')[0], 10);
+        return Number.isNaN(major) ? [
+            ...DEFAULT_SWC_TARGETS
+        ] : [
+            `firefox >= ${major}`
+        ];
     }
-    return using;
-}
-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/
-        }
+    if (isChromiumBasedBrowser(name) && manifest.minimum_chrome_version) return [
+        `chrome >= ${manifest.minimum_chrome_version}`
     ];
-    const isProd = 'production' === mode;
-    const defaultPlugins = [
-        new VueLoaderPlugin(),
-        new DefinePlugin({
-            __VUE_OPTIONS_API__: JSON.stringify(!isProd),
-            __VUE_PROD_DEVTOOLS__: JSON.stringify(!isProd),
-            __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: JSON.stringify(!isProd)
-        })
+    return [
+        ...DEFAULT_SWC_TARGETS
     ];
-    const requireFromProject = createRequire(__rspack_external_node_path_c5b9b54f.join(projectPath, 'package.json'));
-    const resolveFromProject = (id)=>{
-        try {
-            return requireFromProject.resolve(id);
-        } catch  {
-            return;
-        }
-    };
-    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
-    };
 }
 class JsFrameworksPlugin {
     static name = 'plugin-js-frameworks';
@@ -3598,7 +3557,7 @@ class JsFrameworksPlugin {
                     loader: rule.loader
                 }
             ] : [];
-            const hasReactRefreshLoader = uses.some((useEntry)=>String(useEntry?.loader || '').includes('react-refresh-loader'));
+            const hasReactRefreshLoader = uses.some((useEntry)=>'object' == typeof useEntry && String(useEntry?.loader || '').includes('react-refresh-loader'));
             if (hasReactRefreshLoader) rule.issuerLayer = {
                 not: EXTENSIONJS_CONTENT_SCRIPT_LAYER
             };
@@ -3661,7 +3620,7 @@ class JsFrameworksPlugin {
             const background = browserManifest?.background;
             if (background?.type === 'module' && 'string' == typeof background?.service_worker) addBothPathForms(platformModulePaths, __rspack_external_node_path_c5b9b54f.resolve(manifestDir, background.service_worker));
             const htmlPages = {
-                ...getManifestFieldsData({
+                ...getResolvedManifestFieldsData({
                     manifestPath: this.manifestPath,
                     browser: this.browser
                 }).html,
@@ -3675,26 +3634,18 @@ class JsFrameworksPlugin {
         });
         const maybeInstallPreact = await maybeUsePreact(projectPath);
         const maybeInstallVue = await maybeUseVue(projectPath, mode);
+        const maybeInstallSolid = await maybeUseSolid(projectPath);
         const maybeInstallSvelte = await maybeUseSvelte(projectPath, mode);
         const tsConfigPath = getUserTypeScriptConfigFile(projectPath);
         const tsRoot = tsConfigPath ? __rspack_external_node_path_c5b9b54f.dirname(tsConfigPath) : manifestDir;
         const transpilePackageDirs = swcIncludeDirs.filter((dir)=>dir !== projectPath && dir !== manifestDir);
         const preferTypeScript = !!tsConfigPath;
-        let targets = [
-            'chrome >= 100'
-        ];
-        if (manifest?.minimum_chrome_version) targets = [
-            `chrome >= ${manifest.minimum_chrome_version}`
-        ];
-        const geckoMin = manifest?.browser_specific_settings?.gecko?.strict_min_version || manifest?.applications?.gecko?.strict_min_version;
-        if (geckoMin) {
-            const major = parseInt(String(geckoMin).split('.')[0], 10);
-            if (!Number.isNaN(major)) targets.push(`firefox >= ${major}`);
-        }
+        const targets = resolveSwcTargets(manifest, this.browser);
         compiler.options.resolve.alias = {
             ...maybeInstallReact?.alias || {},
             ...maybeInstallPreact?.alias || {},
             ...maybeInstallVue?.alias || {},
+            ...maybeInstallSolid?.alias || {},
             ...maybeInstallSvelte?.alias || {},
             ...compiler.options.resolve.alias
         };
@@ -3726,42 +3677,52 @@ class JsFrameworksPlugin {
                 }
             ]
         };
-        const swcLoaderBase = {
-            loader: 'builtin:swc-loader',
-            options: {
-                sync: true,
-                module: {
-                    type: 'es6'
-                },
-                minify: false,
-                isModule: 'unknown',
-                sourceMap: wantsSourceMaps,
-                env: {
-                    targets
-                },
-                jsc: {
-                    parser: {
-                        syntax: preferTypeScript ? "typescript" : "ecmascript",
-                        tsx: preferTypeScript ? true : isUsingTypeScript(projectPath) && (isUsingReact(projectPath) || isUsingPreact(projectPath)),
-                        jsx: !preferTypeScript && (isUsingReact(projectPath) || isUsingPreact(projectPath)),
-                        dynamicImport: true
+        const jsxInPlainJs = isUsingJsxFramework(projectPath);
+        const jsxImportSource = getJsxImportSource(projectPath);
+        const isPlatformModule = (resourcePath)=>platformModulePaths.has(toResourceKey(resourcePath));
+        const swcLoaderFor = (resourcePath, options)=>({
+                loader: 'builtin:swc-loader',
+                options: {
+                    sync: true,
+                    module: {
+                        type: 'es6'
+                    },
+                    minify: false,
+                    isModule: options.module ? true : 'unknown',
+                    sourceMap: wantsSourceMaps,
+                    env: {
+                        targets
                     },
-                    transform: {
-                        react: {
-                            development: 'development' === mode,
-                            runtime: 'automatic',
-                            importSource: 'react',
-                            ...isUsingPreact(projectPath) ? {
-                                pragma: 'h',
-                                pragmaFrag: 'Fragment',
-                                throwIfNamespace: true,
-                                useBuiltins: false
-                            } : {}
+                    jsc: {
+                        parser: swcParserForFile(resourcePath, jsxInPlainJs),
+                        transform: {
+                            react: {
+                                development: 'development' === mode,
+                                runtime: 'automatic',
+                                importSource: jsxImportSource,
+                                refresh: options.refresh
+                            }
                         }
                     }
                 }
-            }
-        };
+            });
+        const parserVariants = (options)=>[
+                {
+                    test: /\.(tsx|mtsx)$/,
+                    use: swcLoaderFor('file.tsx', options)
+                },
+                {
+                    test: /\.(ts|mts|cts)$/,
+                    use: swcLoaderFor('file.ts', options)
+                },
+                {
+                    test: /\.(jsx|mjsx)$/,
+                    use: swcLoaderFor('file.jsx', options)
+                },
+                {
+                    use: swcLoaderFor('file.js', options)
+                }
+            ];
         const swcRules = [
             {
                 ...swcRuleBase,
@@ -3770,43 +3731,19 @@ class JsFrameworksPlugin {
                         tsRoot,
                         ...swcIncludeDirs
                     ]))).some((dir)=>isSubPath(resourcePath, dir)) && isfeatureScriptsContentLike(resourcePath),
-                use: {
-                    ...swcLoaderBase,
-                    options: {
-                        ...swcLoaderBase.options,
-                        jsc: {
-                            ...swcLoaderBase.options.jsc,
-                            transform: {
-                                ...swcLoaderBase.options.jsc.transform,
-                                react: {
-                                    ...swcLoaderBase.options.jsc.transform.react,
-                                    refresh: false
-                                }
-                            }
-                        }
-                    }
-                }
+                oneOf: parserVariants({
+                    refresh: false,
+                    module: false
+                })
             },
             {
                 ...swcRuleBase,
                 issuerLayer: EXTENSIONJS_CONTENT_SCRIPT_LAYER,
                 layer: EXTENSIONJS_CONTENT_SCRIPT_LAYER,
-                use: {
-                    ...swcLoaderBase,
-                    options: {
-                        ...swcLoaderBase.options,
-                        jsc: {
-                            ...swcLoaderBase.options.jsc,
-                            transform: {
-                                ...swcLoaderBase.options.jsc.transform,
-                                react: {
-                                    ...swcLoaderBase.options.jsc.transform.react,
-                                    refresh: false
-                                }
-                            }
-                        }
-                    }
-                }
+                oneOf: parserVariants({
+                    refresh: false,
+                    module: false
+                })
             },
             {
                 ...swcRuleBase,
@@ -3818,36 +3755,32 @@ class JsFrameworksPlugin {
                 },
                 exclude: [
                     ...swcRuleBase.exclude,
-                    (resourcePath)=>isfeatureScriptsContentLike(resourcePath)
+                    (resourcePath)=>isfeatureScriptsContentLike(resourcePath),
+                    (resourcePath)=>isPlatformModule(resourcePath)
                 ],
-                use: {
-                    ...swcLoaderBase,
-                    options: {
-                        ...swcLoaderBase.options,
-                        jsc: {
-                            ...swcLoaderBase.options.jsc,
-                            transform: {
-                                ...swcLoaderBase.options.jsc.transform,
-                                react: {
-                                    ...swcLoaderBase.options.jsc.transform.react,
-                                    refresh: 'development' === mode
-                                }
-                            }
-                        }
-                    }
-                }
+                oneOf: parserVariants({
+                    refresh: 'development' === mode,
+                    module: false
+                })
             },
             ...platformModulePaths.size > 0 ? [
                 {
                     test: swcRuleBase.test,
-                    include: (resourcePath)=>platformModulePaths.has(toResourceKey(resourcePath)),
+                    issuerLayer: {
+                        not: EXTENSIONJS_CONTENT_SCRIPT_LAYER
+                    },
+                    include: (resourcePath)=>isPlatformModule(resourcePath),
                     exclude: [
                         (resourcePath)=>isfeatureScriptsContentLike(resourcePath)
                     ],
                     resourceQuery: {
                         not: /__extensionjs_classic_concat__/
                     },
-                    type: "javascript/esm"
+                    type: "javascript/esm",
+                    oneOf: parserVariants({
+                        refresh: 'development' === mode,
+                        module: true
+                    })
                 }
             ] : []
         ];
@@ -3880,6 +3813,7 @@ class JsFrameworksPlugin {
             if (maybeInstallReact) integrations.push('React');
             if (maybeInstallPreact) integrations.push('Preact');
             if (maybeInstallVue) integrations.push('Vue');
+            if (maybeInstallSolid) integrations.push('Solid');
             if (maybeInstallSvelte) integrations.push('Svelte');
             if (preferTypeScript) integrations.push('TypeScript');
             console.log(jsFrameworksIntegrationsEnabled(integrations));
@@ -3894,6 +3828,7 @@ class JsFrameworksPlugin {
         const mode = compiler.options.mode || 'development';
         if ('production' === mode) return void compiler.hooks.beforeRun.tapPromise(JsFrameworksPlugin.name, ()=>this.configureOptions(compiler));
         const configuring = this.configureOptions(compiler);
+        compiler.hooks.beforeRun.tapPromise(JsFrameworksPlugin.name, ()=>configuring);
         compiler.hooks.watchRun.tapPromise(JsFrameworksPlugin.name, ()=>configuring);
         await configuring;
     }
@@ -4786,6 +4721,22 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
       }
     }
 
+    // The scripts-replay shim (plugin-reload) keeps the SW's own
+    // executeScript registry; the replay is fire-and-forget by design.
+    function replayProgrammaticScripts(changedScriptFiles) {
+      if (!Array.isArray(changedScriptFiles) || changedScriptFiles.length === 0) return;
+      var replay = g.__extjsScriptsReplay;
+      if (typeof replay !== "function") return;
+      try {
+        var outcome = replay(changedScriptFiles);
+        if (outcome && typeof outcome.then === "function") {
+          outcome.then(null, function () {});
+        }
+      } catch (e) {
+        // Ignore
+      }
+    }
+
     function handleDevReloadFrame(frame) {
       var kind = frame.reloadType || "full";
       var label = typeof frame.label === "string" ? frame.label : "";
@@ -4798,6 +4749,10 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
 
       notifyDevtoolsCompanion("reloading", label, kind);
 
+      // A scripts/ bundle edit: re-run the executeScript calls that named it
+      // on their recorded tabs, before any reload decision below.
+      replayProgrammaticScripts(frame.changedScriptFiles);
+
       if (kind === "page") {
         // Notify-only: rspack-dev-server's livereload refreshes the open
         // surface; reloading the extension here would race it.
@@ -5333,6 +5288,21 @@ function buildBridgeProducerSource(opts) {
     if (!opts.controlPort || opts.controlPort < 1) return '';
     return BRIDGE_PRODUCER_SOURCE.replace(/__EXTJS_CONTROL_PORT__/g, String(opts.controlPort)).replace(/__EXTJS_INSTANCE_ID__/g, String(opts.instanceId)).replace(/__EXTJS_CONTEXT__/g, String(opts.context || 'background')).replace(/__EXTJS_CONTROL_HOST__/g, String(opts.host || '127.0.0.1'));
 }
+function prependToEmittedAsset(compilation, asset, prefix) {
+    const assetName = asset.name;
+    const original = asset.source.source().toString();
+    compilation.updateAsset(assetName, new core_sources.RawSource(`${prefix}${original}`));
+    const mapAsset = 'function' == typeof compilation.getAsset ? compilation.getAsset(`${assetName}.map`) : void 0;
+    if (!mapAsset) return;
+    const prefixLines = prefix.split('\n').length - 1;
+    if (prefixLines <= 0) return;
+    try {
+        const map = JSON.parse(mapAsset.source.source().toString());
+        if ('string' != typeof map.mappings) return;
+        map.mappings = `${';'.repeat(prefixLines)}${map.mappings}`;
+        compilation.updateAsset(`${assetName}.map`, new core_sources.RawSource(JSON.stringify(map)));
+    } catch  {}
+}
 const BACKGROUND_ASSET = /(^|\/)background\/(?:service_worker|scripts?)\.js$/i;
 class InjectBridgeProducer {
     apply(compiler) {
@@ -5358,9 +5328,7 @@ class InjectBridgeProducer {
                 for (const asset of compilation.getAssets()){
                     if (!BACKGROUND_ASSET.test(asset.name)) continue;
                     const original = asset.source.source().toString();
-                    if (-1 !== original.indexOf('__extjsBridgeProducerInstalled')) continue;
-                    const next = `${source}\n${original}`;
-                    compilation.updateAsset(asset.name, new core_sources.RawSource(next));
+                    if (-1 === original.indexOf('__extjsBridgeProducerInstalled')) prependToEmittedAsset(compilation, asset, `${source}\n`);
                 }
             });
         });
@@ -5417,9 +5385,7 @@ class InjectBridgeRelay {
                     const target = RELAY_TARGETS.find((t)=>t.re.test(asset.name));
                     if (!target) continue;
                     const original = asset.source.source().toString();
-                    if (-1 !== original.indexOf('__extjsBridgeRelayInstalled')) continue;
-                    const next = `${sourceFor.get(target.context)}\n${original}`;
-                    compilation.updateAsset(asset.name, new core_sources.RawSource(next));
+                    if (-1 === original.indexOf('__extjsBridgeRelayInstalled')) prependToEmittedAsset(compilation, asset, `${sourceFor.get(target.context)}\n`);
                 }
             });
         });
@@ -5549,9 +5515,7 @@ class InjectScriptsReplayShim {
                 for (const asset of compilation.getAssets()){
                     if (!inject_scripts_replay_shim_BACKGROUND_ASSET.test(asset.name)) continue;
                     const original = asset.source.source().toString();
-                    if (-1 !== original.indexOf('__extjsScriptsReplayInstalled')) continue;
-                    const next = `${SCRIPTS_REPLAY_SHIM_SOURCE}\n${original}`;
-                    compilation.updateAsset(asset.name, new core_sources.RawSource(next));
+                    if (-1 === original.indexOf('__extjsScriptsReplayInstalled')) prependToEmittedAsset(compilation, asset, `${SCRIPTS_REPLAY_SHIM_SOURCE}\n`);
                 }
             });
         });
@@ -6853,12 +6817,14 @@ class ReloadPlugin {
     static name = 'plugin-reload';
     manifestPath;
     browser;
+    devSession;
     constructor(options){
         this.manifestPath = options.manifestPath;
         this.browser = options.browser || 'chrome';
+        this.devSession = options.devSession;
     }
     apply(compiler) {
-        if ('production' === compiler.options.mode || 'true' === process.env.EXTENSION_NO_RELOAD) return;
+        if ('production' === compiler.options.mode || false === this.devSession || 'true' === process.env.EXTENSION_NO_RELOAD) return;
         const hasValidManifest = !!this.manifestPath && __rspack_external_node_fs_5ea92f0c.existsSync(this.manifestPath) && __rspack_external_node_fs_5ea92f0c.lstatSync(this.manifestPath).isFile();
         if (!hasValidManifest) return;
         new StripContentScriptDevServerRuntime().apply(compiler);
@@ -7543,6 +7509,74 @@ function emitRootAbsoluteRefs(compilation, context, publicDir) {
         if (0 === emitted) return;
     }
 }
+const DEV_SESSION_RESTART_DEBOUNCE_MS = 300;
+class DevSessionRestartScheduler {
+    debounceMs;
+    handler = null;
+    timer;
+    latest = null;
+    inFlight = false;
+    constructor(debounceMs = DEV_SESSION_RESTART_DEBOUNCE_MS){
+        this.debounceMs = Math.max(0, debounceMs);
+    }
+    setHandler(handler) {
+        this.handler = handler;
+    }
+    request(request) {
+        this.latest = request;
+        if (this.inFlight) return;
+        this.schedule();
+    }
+    isPending() {
+        return null != this.latest || this.inFlight;
+    }
+    dispose() {
+        if (this.timer) clearTimeout(this.timer);
+        this.timer = void 0;
+        this.latest = null;
+        this.handler = null;
+    }
+    schedule() {
+        if (this.timer) clearTimeout(this.timer);
+        if (0 === this.debounceMs) return void this.flush();
+        this.timer = setTimeout(()=>{
+            this.timer = void 0;
+            this.flush();
+        }, this.debounceMs);
+        this.timer.unref?.();
+    }
+    async flush() {
+        if (this.inFlight) return;
+        const request = this.latest;
+        const handler = this.handler;
+        if (!request || !handler) return;
+        this.latest = null;
+        this.inFlight = true;
+        try {
+            await handler(request);
+        } catch  {} finally{
+            this.inFlight = false;
+            if (this.latest) this.schedule();
+        }
+    }
+}
+let boundScheduler = null;
+const restartingCompilers = new WeakSet();
+function bindDevSessionRestart(scheduler) {
+    boundScheduler = scheduler;
+}
+function unbindDevSessionRestart() {
+    boundScheduler = null;
+}
+function requestDevSessionRestart(compiler, request) {
+    if (!boundScheduler) return false;
+    if (compiler) restartingCompilers.add(compiler);
+    boundScheduler.request(request);
+    return true;
+}
+function isCompilerRestarting(compiler) {
+    return null != compiler && restartingCompilers.has(compiler);
+}
 class WarnUponFolderChanges {
     pendingChanges = [];
     knownFolderFiles = new Set();
@@ -7600,6 +7634,10 @@ class WarnUponFolderChanges {
         const typeOfAsset = 'pages' === folder ? 'HTML pages' : "script files";
         const errorMessage = serverRestartRequiredFromSpecialFolderMessageOnly(addingOrRemoving, folder, typeOfAsset);
         if (isAddition) {
+            if (requestDevSessionRestart(compilation.compiler, {
+                reason: 'pages' === folder ? 'html' : "scripts",
+                pathAfter: filePath
+            })) return;
             const warn = new core_WebpackError(errorMessage);
             warn.name = 'SpecialFoldersChange';
             warn.file = filePath;
@@ -7679,8 +7717,14 @@ class SpecialFoldersPlugin {
     apply(compiler) {
         const { manifestPath } = this.options;
         const context = compiler.options.context || __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
-        const publicDir = __rspack_external_node_path_c5b9b54f.join(context, 'public');
+        const inspection = inspectPublicFolders(manifestPath, context);
+        const publicDir = inspection.publicDir || __rspack_external_node_path_c5b9b54f.join(context, 'public');
+        rememberPublicRoots(compiler, inspection.publicDir ? [
+            publicDir
+        ] : []);
         compiler.hooks.thisCompilation.tap(SpecialFoldersPlugin.name, (compilation)=>{
+            if (inspection.bothExist) pushLayoutWarning(compiler, compilation, 'PublicFolderShadowedWarning', publicFolderShadowed(inspection.fromRoot, inspection.fromManifest));
+            else if (inspection.usedFallback) pushLayoutWarning(compiler, compilation, 'PublicLayoutWarning', publicMustBeAtProjectRoot(inspection.fromManifest, inspection.fromRoot));
             compilation.hooks.processAssets.tap({
                 name: `${SpecialFoldersPlugin.name}:root-absolute-refs`,
                 stage: compilation.constructor.PROCESS_ASSETS_STAGE_SUMMARIZE
@@ -7688,8 +7732,9 @@ class SpecialFoldersPlugin {
                 emitRootAbsoluteRefs(compilation, __rspack_external_node_path_c5b9b54f.dirname(manifestPath), publicDir);
             });
         });
-        if (__rspack_external_node_fs_5ea92f0c.existsSync(publicDir) && __rspack_external_node_fs_5ea92f0c.statSync(publicDir).isDirectory()) {
+        if (inspection.publicDir) {
             compiler.hooks.thisCompilation.tap(SpecialFoldersPlugin.name, (compilation)=>{
+                compilation.contextDependencies?.add(publicDir);
                 compilation.hooks.processAssets.tap({
                     name: `${SpecialFoldersPlugin.name}:guards`,
                     stage: compilation.constructor.PROCESS_ASSETS_STAGE_PRE_PROCESS
@@ -7719,6 +7764,13 @@ class SpecialFoldersPlugin {
         }
     }
 }
+function pushLayoutWarning(compiler, compilation, name, message) {
+    const ErrorConstructor = compiler?.rspack?.WebpackError || Error;
+    const warning = new ErrorConstructor(message);
+    warning.name = name;
+    if (!compilation.warnings) compilation.warnings = [];
+    compilation.warnings.push(warning);
+}
 function assetsRulesEnabled(rules) {
     const kinds = rules.length > 0 ? rules.join(',').toLowerCase() : 'none';
     return `${messaging_prefix('debug')} assets   rules=${rules.length} kinds=${kinds}`;
@@ -8112,7 +8164,7 @@ function resolveCssAsset(compilation, feature) {
         href: void 0
     };
 }
-function handleStaticAsset(compilation, htmlEntry, htmlDir, absolutePath, assetType, cleanPath, search, hash, baseHref, includeList, extname, childNode, attributeName) {
+function handleStaticAsset(compilation, htmlEntry, htmlDir, absolutePath, assetType, cleanPath, search, hash, includeList, extname, childNode, attributeName, manifestDir) {
     const isFilepathListEntry = isFromFilepathList(absolutePath, includeList);
     __rspack_external_node_path_c5b9b54f.posix.join('/', cleanPath);
     const attrName = resolveStaticAttributeName(assetType, attributeName);
@@ -8128,15 +8180,50 @@ function handleStaticAsset(compilation, htmlEntry, htmlDir, absolutePath, assetT
         node = applyRewrittenStaticUrl(node, attrName, cleanPath, cleanPath + (search || '') + (hash || ''));
         return node;
     }
-    const baseJoin = baseHref && !/^\w+:\/\//.test(baseHref) ? __rspack_external_node_path_c5b9b54f.resolve(htmlDir, baseHref) : htmlDir;
-    const fromRoot = __rspack_external_node_path_c5b9b54f.parse(baseJoin).root;
-    const toRoot = __rspack_external_node_path_c5b9b54f.parse(absolutePath).root;
-    const relativeFromHtml = fromRoot && toRoot && String(fromRoot).toLowerCase() !== String(toRoot).toLowerCase() ? __rspack_external_node_path_c5b9b54f.basename(absolutePath) : __rspack_external_node_path_c5b9b54f.relative(baseJoin, absolutePath);
-    const posixRelative = relativeFromHtml.split(__rspack_external_node_path_c5b9b54f.sep).join('/');
-    const filepath = joinEmittedAssetName('assets', posixRelative);
+    const filepath = htmlStaticAssetOutputName(manifestDir, htmlEntry, absolutePath);
     if (__rspack_external_node_fs_5ea92f0c.existsSync(absolutePath)) node = applyRewrittenStaticUrl(node, attrName, cleanPath, getFilePath(filepath, '', true) + (search || '') + (hash || ''));
     return node;
 }
+const LINK_ATTRIBUTES = {
+    a: 'href',
+    area: 'href',
+    form: 'action'
+};
+function isBakeable(value) {
+    const trimmed = value.trim();
+    if (!trimmed) return false;
+    if (trimmed.startsWith('#')) return false;
+    if (trimmed.startsWith('//')) return false;
+    if (/^[a-z][a-z0-9+.-]*:/i.test(trimmed)) return false;
+    return true;
+}
+function resolveLinkThroughBase(baseHref, value) {
+    if (utils_isUrl(baseHref)) return new URL(value, baseHref).href;
+    if (value.startsWith('/')) return value;
+    const joined = __rspack_external_node_path_c5b9b54f.posix.join(baseHref.replace(/\\/g, '/'), value);
+    return baseHref.startsWith('/') && !joined.startsWith('/') ? `/${joined}` : joined;
+}
+function base_href_walk(node, visit) {
+    visit(node);
+    for (const child of node.childNodes || [])base_href_walk(child, visit);
+}
+function bakeBaseHref(htmlDocument) {
+    const baseNode = getBaseNode(htmlDocument);
+    const baseHref = baseNode?.attrs?.find((attr)=>'href' === attr.name)?.value;
+    if (!baseNode || !baseHref) return;
+    base_href_walk(htmlDocument, (node)=>{
+        const attrName = LINK_ATTRIBUTES[String(node.nodeName || '')];
+        if (!attrName) return;
+        const attr = node.attrs?.find((entry)=>entry.name === attrName);
+        if (!attr || !isBakeable(attr.value)) return;
+        attr.value = resolveLinkThroughBase(baseHref, attr.value.trim());
+    });
+    baseNode.attrs = (baseNode.attrs || []).filter((attr)=>'href' !== attr.name);
+    if (0 === baseNode.attrs.length) base_href_walk(htmlDocument, (node)=>{
+        if (!node.childNodes) return;
+        node.childNodes = node.childNodes.filter((child)=>child !== baseNode);
+    });
+}
 function injectJsScript(bodyNode, feature, firstScriptAttrs) {
     const scriptTag = __rspack_external_parse5_utilities_78b19c6a.createNode("script");
     scriptTag.attrs = [
@@ -8169,7 +8256,7 @@ function warnIfPublicRootAssetMissing(compilation, htmlEntry, cleanPath) {
     warn.message = filtered.join('\n').trim();
     compilation.warnings.push(warn);
 }
-function patchHtml(compilation, feature, htmlEntry, includeList) {
+function patchHtml(compilation, feature, htmlEntry, includeList, manifestDir) {
     const htmlFile = __rspack_external_node_fs_5ea92f0c.readFileSync(htmlEntry, {
         encoding: 'utf8'
     });
@@ -8188,7 +8275,7 @@ function patchHtml(compilation, feature, htmlEntry, includeList) {
             if ('head' === htmlChildNode.nodeName || 'body' === htmlChildNode.nodeName) parseHtml(htmlChildNode, ({ filePath, childNode, assetType, attributeName })=>{
                 const htmlDir = __rspack_external_node_path_c5b9b54f.dirname(htmlEntry);
                 const { cleanPath, hash, search } = cleanAssetUrl(filePath);
-                const absolutePath = __rspack_external_node_path_c5b9b54f.resolve(htmlDir, cleanPath);
+                const absolutePath = resolveHtmlRefPath(htmlEntry, baseHref, cleanPath);
                 const extname = getExtname(absolutePath);
                 __rspack_external_node_path_c5b9b54f.posix.join('/', cleanPath);
                 let thisChildNode = childNode;
@@ -8215,7 +8302,7 @@ function patchHtml(compilation, feature, htmlEntry, includeList) {
                         break;
                     case 'staticHref':
                     case 'staticSrc':
-                        thisChildNode = handleStaticAsset(compilation, htmlEntry, htmlDir, absolutePath, assetType, cleanPath, search, hash, baseHref, includeList, extname, thisChildNode, attributeName);
+                        thisChildNode = handleStaticAsset(compilation, htmlEntry, htmlDir, absolutePath, assetType, cleanPath, search, hash, includeList, extname, thisChildNode, attributeName, manifestDir);
                         break;
                     default:
                         break;
@@ -8244,20 +8331,21 @@ function patchHtml(compilation, feature, htmlEntry, includeList) {
                 ];
             } else if (bodyNode) injectJsScript(bodyNode, feature, firstScriptAttrs);
         }
+        bakeBaseHref(htmlDocument);
         return __rspack_external_parse5_utilities_78b19c6a.stringify(htmlDocument);
     }
     return '';
 }
-function patchHtmlNested(compilation, htmlEntry) {
+function patchHtmlNested(compilation, htmlEntry, manifestDir) {
     const htmlFile = __rspack_external_node_fs_5ea92f0c.readFileSync(htmlEntry, {
         encoding: 'utf8'
     });
     const htmlDocument = __rspack_external_parse5_utilities_78b19c6a.parse(htmlFile);
+    const baseHref = getBaseHref(htmlDocument);
     for (const node of htmlDocument.childNodes)if ('html' === node.nodeName) {
         for (const htmlChildNode of node.childNodes)if ('head' === htmlChildNode.nodeName || 'body' === htmlChildNode.nodeName) parseHtml(htmlChildNode, ({ filePath, childNode, assetType, attributeName })=>{
-            const htmlDir = __rspack_external_node_path_c5b9b54f.dirname(htmlEntry);
             const { cleanPath, hash, search } = cleanAssetUrl(filePath);
-            const absolutePath = __rspack_external_node_path_c5b9b54f.resolve(htmlDir, cleanPath);
+            const absolutePath = resolveHtmlRefPath(htmlEntry, baseHref, cleanPath);
             const attrName = 'staticSrc' === assetType || 'staticHref' === assetType ? resolveStaticAttributeName(assetType, attributeName) : void 0;
             let thisChildNode = childNode;
             switch(assetType){
@@ -8279,9 +8367,7 @@ function patchHtmlNested(compilation, htmlEntry) {
                         warnIfPublicRootAssetMissing(compilation, htmlEntry, cleanPath);
                         thisChildNode = applyRewrittenStaticUrl(thisChildNode, attrName || resolveStaticAttributeName(assetType), cleanPath, cleanPath + (search || '') + (hash || ''));
                     } else if (__rspack_external_node_fs_5ea92f0c.existsSync(absolutePath)) {
-                        const relativeFromHtml = __rspack_external_node_path_c5b9b54f.relative(htmlDir, absolutePath);
-                        const posixRelative = relativeFromHtml.split(__rspack_external_node_path_c5b9b54f.sep).join('/');
-                        const filepath = joinEmittedAssetName('assets', posixRelative);
+                        const filepath = htmlStaticAssetOutputName(manifestDir, htmlEntry, absolutePath);
                         thisChildNode = applyRewrittenStaticUrl(thisChildNode, attrName || resolveStaticAttributeName(assetType), cleanPath, getFilePath(filepath, '', true) + (search || '') + (hash || ''));
                     }
                     break;
@@ -8289,6 +8375,7 @@ function patchHtmlNested(compilation, htmlEntry) {
                     break;
             }
         });
+        bakeBaseHref(htmlDocument);
         return __rspack_external_parse5_utilities_78b19c6a.stringify(htmlDocument);
     }
     return '';
@@ -8343,9 +8430,9 @@ function checkMissingLocalEntries(params) {
     css?.forEach(check);
 }
 function emitNestedHtmlAndReferencedAssets(params) {
-    const { compilation, filepath, absoluteFsPath } = params;
+    const { compilation, filepath, absoluteFsPath, manifestDir } = params;
     const source = __rspack_external_node_fs_5ea92f0c.readFileSync(absoluteFsPath);
-    const updatedHtml = patchHtmlNested(compilation, absoluteFsPath);
+    const updatedHtml = patchHtmlNested(compilation, absoluteFsPath, manifestDir);
     const htmlAssets = getAssetsFromHtml(absoluteFsPath);
     const assetsFromHtml = [
         ...htmlAssets?.js || [],
@@ -8357,7 +8444,7 @@ function emitNestedHtmlAndReferencedAssets(params) {
         if (!__rspack_external_node_path_c5b9b54f.isAbsolute(assetFromHtml) || !__rspack_external_node_fs_5ea92f0c.existsSync(assetFromHtml)) return;
         const s = __rspack_external_node_fs_5ea92f0c.readFileSync(assetFromHtml);
         const r = new core_sources.RawSource(s);
-        const assetFilepath = joinEmittedAssetName('assets', computePosixRelative(absoluteFsPath, assetFromHtml));
+        const assetFilepath = htmlStaticAssetOutputName(manifestDir, absoluteFsPath, assetFromHtml);
         if (!compilation.getAsset(assetFilepath)) compilation.emitAsset(assetFilepath, r);
     });
 }
@@ -8462,14 +8549,15 @@ class AddAssetsToCompilation {
                             } catch  {}
                             continue;
                         }
-                        const filepath = joinEmittedAssetName('assets', computePosixRelative(resource, absoluteFsPath));
+                        const filepath = htmlStaticAssetOutputName(manifestDir, resource, absoluteFsPath);
                         const isNestedHtml = asset.endsWith('.html');
                         const nestedHtmlAsset = isNestedHtml ? 'function' == typeof getAssetFn ? getAssetFn.call(compilation, __rspack_external_node_path_c5b9b54f.basename(asset)) : null : null;
                         if (!isFromIncludeList(asset, this.includeList) || nestedHtmlAsset) {
                             if (!('function' == typeof getAssetFn && getAssetFn.call(compilation, filepath))) if (asset.endsWith('.html')) emitNestedHtmlAndReferencedAssets({
                                 compilation,
                                 filepath,
-                                absoluteFsPath
+                                absoluteFsPath,
+                                manifestDir
                             });
                             else {
                                 const source = __rspack_external_node_fs_5ea92f0c.readFileSync(absoluteFsPath);
@@ -8763,6 +8851,8 @@ function manifestFieldForHtmlFeature(featureName, manifestPath) {
             if (has('action')) return 'action.default_popup';
             if (has('browser_action')) return 'browser_action.default_popup';
             return 'page_action.default_popup';
+        case 'page_action/index':
+            return 'page_action.default_popup';
         case 'options/index':
             return has('options_page') ? 'options_page' : 'options_ui.page';
         case 'background/index':
@@ -8928,6 +9018,11 @@ class ThrowIfRecompileIsNeeded {
                 if (this.hasEntriesChanged(updatedCssEntries, css) || this.hasEntriesChanged(updatedJsEntries, js)) {
                     const projectRoot = __rspack_external_node_path_c5b9b54f.dirname(this.manifestPath);
                     const relToManifest = __rspack_external_node_path_c5b9b54f.relative(projectRoot, changedFile);
+                    if (requestDevSessionRestart(compiler, {
+                        reason: 'html',
+                        pathAfter: changedFile,
+                        manifestField: relToManifest
+                    })) continue;
                     const err = new core_WebpackError(serverRestartRequiredFromHtml(relToManifest, changedFile));
                     err.name = 'HtmlEntrypointChanged';
                     err.file = relToManifest;
@@ -8960,7 +9055,7 @@ class UpdateHtmlFile {
                     const getAssetFn = compilation.getAsset;
                     const existing = 'function' == typeof getAssetFn ? getAssetFn.call(compilation, assetFilename) : compilation.assets?.[assetFilename];
                     if (!existing) continue;
-                    const updated = patchHtml(compilation, feature, resolved, this.includeList || {});
+                    const updated = patchHtml(compilation, feature, resolved, this.includeList || {}, projectDir);
                     const updatedHtml = 'string' == typeof updated ? updated : updated && 'string' == typeof updated.html ? updated.html : null;
                     if ('string' == typeof updatedHtml) compilation.updateAsset(assetFilename, new core_sources.RawSource(updatedHtml));
                 }
@@ -8978,9 +9073,11 @@ class HtmlPlugin {
     manifestPath;
     includeList;
     browser;
+    devSession;
     constructor(options){
         this.manifestPath = options.manifestPath;
         this.includeList = options.includeList;
+        this.devSession = options.devSession;
         this.browser = options.browser || 'chrome';
     }
     apply(compiler) {
@@ -9007,7 +9104,8 @@ class HtmlPlugin {
             includeList,
             browser: this.browser
         }).apply(compiler);
-        if ('production' !== (compiler.options.mode || 'development')) {
+        const devSession = this.devSession ?? 'production' !== (compiler.options.mode || 'development');
+        if (devSession) {
             const contentScriptEntryPaths = new Set();
             try {
                 const manifest = parseJsonSafe(__rspack_external_node_fs_5ea92f0c.readFileSync(this.manifestPath, 'utf-8'));
@@ -9018,11 +9116,16 @@ class HtmlPlugin {
                     for (const jsFile of jsList)contentScriptEntryPaths.add(toResourceKey(__rspack_external_node_path_c5b9b54f.resolve(manifestDir, jsFile)));
                 }
             } catch  {}
+            const projectRoot = String(compiler.options.context || '');
+            const pageDirs = new Set([
+                __rspack_external_node_path_c5b9b54f.dirname(this.manifestPath)
+            ]);
+            if (projectRoot) pageDirs.add(projectRoot);
+            for (const pagePath of Object.values(includeList))if ('string' == typeof pagePath && pagePath) pageDirs.add(__rspack_external_node_path_c5b9b54f.dirname(pagePath));
+            const frameworkOwnsRefresh = Boolean(projectRoot && (isUsingReact(projectRoot) || isUsingVue(projectRoot) || isUsingSvelte(projectRoot)));
             compiler.options.module.rules.push({
                 test: /\.(js|cjs|mjs|jsx|mjsx|ts|mts|tsx|mtsx)$/,
-                include: [
-                    __rspack_external_node_path_c5b9b54f.dirname(this.manifestPath)
-                ],
+                include: Array.from(pageDirs),
                 issuerLayer: {
                     not: EXTENSIONJS_CONTENT_SCRIPT_LAYER
                 },
@@ -9035,7 +9138,8 @@ class HtmlPlugin {
                         loader: resolveDevelopDistFile("ensure-hmr-for-scripts"),
                         options: {
                             manifestPath: this.manifestPath,
-                            includeList
+                            includeList,
+                            frameworkOwnsRefresh
                         }
                     }
                 ]
@@ -9058,6 +9162,32 @@ class HtmlPlugin {
         }).apply(compiler);
     }
 }
+function resolveManifestIconPath(context, relativePath) {
+    const unix = relativePath.replace(/\\/g, '/');
+    if (/^\/public\//i.test(unix)) return __rspack_external_node_path_c5b9b54f.join(context, 'public', unix.replace(/^\/public\//i, ''));
+    if (/^(?:\.\/)?public\//i.test(unix)) return __rspack_external_node_path_c5b9b54f.join(context, 'public', unix.replace(/^(?:\.\/)?public\//i, ''));
+    if (/^\//.test(unix)) return __rspack_external_node_path_c5b9b54f.join(context, unix.slice(1));
+    return __rspack_external_node_path_c5b9b54f.join(context, unix);
+}
+function extractActionThemeIcons(manifestPath) {
+    let manifest;
+    try {
+        manifest = JSON.parse(stripBom(__rspack_external_node_fs_5ea92f0c.readFileSync(manifestPath, 'utf8')));
+    } catch  {
+        return {};
+    }
+    const themeIcons = manifest?.action?.theme_icons;
+    if (!Array.isArray(themeIcons) || 0 === themeIcons.length) return {};
+    const context = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
+    const paths = [];
+    for (const icon of themeIcons)if (icon && 'object' == typeof icon) {
+        if ('string' == typeof icon.light && icon.light) paths.push(resolveManifestIconPath(context, icon.light));
+        if ('string' == typeof icon.dark && icon.dark) paths.push(resolveManifestIconPath(context, icon.dark));
+    }
+    return paths.length ? {
+        'action/theme_icons': paths
+    } : {};
+}
 function iconsMissingFile(manifestField, filePath, opts) {
     const lines = [];
     lines.push(`Can't find an icon file listed in ${pintor.blue(manifestField)}.`);
@@ -9141,15 +9271,20 @@ class add_to_file_dependencies_AddToFileDependencies {
                 name: 'icons:add-to-file-dependencies',
                 stage: core_Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, ()=>{
-                if (compilation.errors?.length) return;
                 const iconFields = this.includeList || {};
                 let added = 0;
                 for (const field of Object.entries(iconFields)){
                     const [, resource] = field;
                     const stringEntries = iconValuesToStrings(resource);
-                    for (const entry of stringEntries)if (entry && __rspack_external_node_fs_5ea92f0c.existsSync(entry) && !compilation.fileDependencies.has(entry)) {
-                        compilation.fileDependencies.add(entry);
-                        added++;
+                    for (const entry of stringEntries)if (entry && __rspack_external_node_path_c5b9b54f.isAbsolute(entry)) {
+                        if (!__rspack_external_node_fs_5ea92f0c.existsSync(entry)) {
+                            compilation.missingDependencies?.add(entry);
+                            continue;
+                        }
+                        if (!compilation.fileDependencies.has(entry)) {
+                            compilation.fileDependencies.add(entry);
+                            added++;
+                        }
                     }
                 }
                 if (isDebug()) console.log(iconsDepsTracked(added));
@@ -9231,7 +9366,7 @@ class EmitFile {
                         const parts = String(feature).split('/');
                         const group = parts[0];
                         const sub = parts[1] || '';
-                        const isDefaultIconFamily = ('action' === group || 'browser_action' === group || 'page_action' === group || 'sidebar_action' === group) && 'default_icon' === sub;
+                        const isDefaultIconFamily = ('action' === group || 'browser_action' === group || 'page_action' === group || 'sidebar_action' === group || 'omnibox' === group) && 'default_icon' === sub;
                         const isThemeImage = 'theme' === group && 'images' === sub;
                         if (!__rspack_external_node_fs_5ea92f0c.existsSync(resolved)) {
                             const isPublicRoot = entry.startsWith('/') && !entry.startsWith(projectPath);
@@ -9258,14 +9393,25 @@ class EmitFile {
                         const source = __rspack_external_node_fs_5ea92f0c.readFileSync(resolved);
                         const rawSource = new core_sources.RawSource(source);
                         const basename = __rspack_external_node_path_c5b9b54f.basename(resolved);
+                        const isThemeIcons = ('browser_action' === group || 'action' === group) && 'theme_icons' === sub;
                         let outputDir = group;
                         if (isDefaultIconFamily) outputDir = 'icons';
-                        else if ('browser_action' === group && 'theme_icons' === sub) outputDir = 'browser_action';
+                        else if (isThemeIcons) outputDir = group;
                         else if (isThemeImage) outputDir = 'theme/images';
                         let filename = `${outputDir}/${basename}`;
+                        const relFromManifest = __rspack_external_node_path_c5b9b54f.relative(manifestDir, resolved).replace(/\\/g, '/');
                         if ('icons' === outputDir) {
-                            const relFromManifest = __rspack_external_node_path_c5b9b54f.relative(manifestDir, resolved).replace(/\\/g, '/');
-                            if (relFromManifest && !relFromManifest.startsWith('..') && !__rspack_external_node_path_c5b9b54f.isAbsolute(relFromManifest)) filename = relFromManifest;
+                            if (relFromManifest && !__rspack_external_node_path_c5b9b54f.isAbsolute(relFromManifest)) filename = iconOutputPath(relFromManifest);
+                            else if (resolved) filename = iconOutputPath(resolved);
+                        }
+                        if (isThemeIcons) {
+                            const folder = 'action' === group ? 'action' : 'browser_action';
+                            if (relFromManifest && !__rspack_external_node_path_c5b9b54f.isAbsolute(relFromManifest)) filename = themeIconOutputPath(relFromManifest, folder);
+                            else if (resolved) filename = themeIconOutputPath(resolved, folder);
+                        }
+                        if (isThemeImage) {
+                            if (relFromManifest && !__rspack_external_node_path_c5b9b54f.isAbsolute(relFromManifest)) filename = themeImageOutputPath(relFromManifest);
+                            else if (resolved) filename = themeImageOutputPath(resolved);
                         }
                         compilation.emitAsset(filename, rawSource);
                         emittedCount++;
@@ -9289,7 +9435,10 @@ class IconsPlugin {
         this.includeList = options.includeList;
     }
     apply(compiler) {
-        const normalizedIncludeList = normalizeIconIncludeKeys(this.includeList);
+        const normalizedIncludeList = {
+            ...normalizeIconIncludeKeys(this.includeList),
+            ...extractActionThemeIcons(this.manifestPath)
+        };
         if (isDebug()) {
             const beforeKeys = Object.keys(this.includeList || {});
             const afterKeys = Object.keys(normalizedIncludeList || {});
@@ -9306,6 +9455,47 @@ class IconsPlugin {
         }).apply(compiler);
     }
 }
+function omniboxIconFields(manifestPath) {
+    let manifest;
+    try {
+        manifest = JSON.parse(stripBom(__rspack_external_node_fs_5ea92f0c.readFileSync(manifestPath, 'utf8')));
+    } catch  {
+        return {};
+    }
+    const icon = manifest?.omnibox?.default_icon;
+    if (!icon) return {};
+    const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
+    const resolve = (value)=>'string' != typeof value || value.startsWith('/') || __rspack_external_node_path_c5b9b54f.isAbsolute(value) ? String(value) : __rspack_external_node_path_c5b9b54f.join(manifestDir, value);
+    if ('string' == typeof icon) return {
+        'omnibox/default_icon': resolve(icon)
+    };
+    if ('object' == typeof icon) return {
+        'omnibox/default_icon': Object.fromEntries(Object.entries(icon).map(([size, value])=>[
+                size,
+                resolve(value)
+            ]))
+    };
+    return {};
+}
+function themeImageFields(manifestPath) {
+    let manifest;
+    try {
+        manifest = JSON.parse(stripBom(__rspack_external_node_fs_5ea92f0c.readFileSync(manifestPath, 'utf8')));
+    } catch  {
+        return {};
+    }
+    const images = manifest?.theme?.images;
+    if (!images || 'object' != typeof images || Array.isArray(images)) return {};
+    const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
+    const resolve = (value)=>value.startsWith('/') || __rspack_external_node_path_c5b9b54f.isAbsolute(value) ? value : __rspack_external_node_path_c5b9b54f.join(manifestDir, value);
+    const out = {};
+    for (const [key, value] of Object.entries(images))if ('string' == typeof value) out[`theme/images/${key}`] = resolve(value);
+    else if (Array.isArray(value)) {
+        const entries = value.filter((entry)=>'string' == typeof entry);
+        if (entries.length) out[`theme/images/${key}`] = entries.map(resolve);
+    }
+    return out;
+}
 function jsonMissingFile(manifestField, filePath, opts) {
     const lines = [];
     lines.push(`Can't find the JSON file listed in ${pintor.blue(manifestField)}.`);
@@ -9366,8 +9556,11 @@ function jsonDepsTracked(addedCount) {
 function jsonIncludeSummary(totalFeatures, criticalCount) {
     return `${messaging_prefix('debug')} json     include features=${String(totalFeatures)} critical=${String(criticalCount)}`;
 }
+function isManagedSchemaFeature(feature) {
+    return 'storage/managed_schema' === feature || 'storage.managed_schema' === feature;
+}
 function isCriticalJsonFeature(feature) {
-    return feature.startsWith('declarative_net_request') || 'storage.managed_schema' === feature || 'storage/managed_schema' === feature;
+    return feature.startsWith('declarative_net_request') || isManagedSchemaFeature(feature);
 }
 function isPlainObject(value) {
     return 'object' == typeof value && null !== value && !Array.isArray(value);
@@ -9421,7 +9614,7 @@ function validateJsonAsset(compilation, feature, filePath, buf) {
                 compilation.warnings.push(warn);
             }
         }
-    } else if ('storage.managed_schema' === feature) {
+    } else if (isManagedSchemaFeature(feature)) {
         if (null === parsed || Array.isArray(parsed) || 'object' != typeof parsed) {
             const err = new core_WebpackError(invalidManagedSchemaStructure(feature, filePath));
             err.file = filePath;
@@ -9440,23 +9633,40 @@ function firstExisting(candidates) {
     for (const candidate of candidates)if (candidate && __rspack_external_node_fs_5ea92f0c.existsSync(candidate)) return candidate;
 }
 function resolveJsonResource(thisResource, manifestDir, projectPath) {
-    const publicDir = __rspack_external_node_path_c5b9b54f.join(projectPath, 'public');
+    const manifestPath = __rspack_external_node_path_c5b9b54f.join(manifestDir, 'manifest.json');
+    const inspection = inspectPublicFolders(manifestPath, projectPath);
+    const publicRoots = [
+        inspection.fromRoot
+    ];
+    if (__rspack_external_node_path_c5b9b54f.resolve(inspection.fromManifest) !== __rspack_external_node_path_c5b9b54f.resolve(inspection.fromRoot)) publicRoots.push(inspection.fromManifest);
     const rawRef = String(thisResource);
     const looksLikeRootRef = rawRef.startsWith('/') && !rawRef.startsWith('//') && !(projectPath && rawRef.startsWith(projectPath));
     const isPublicRoot = looksLikeRootRef && (!__rspack_external_node_path_c5b9b54f.isAbsolute(rawRef) || __rspack_external_node_path_c5b9b54f.dirname(rawRef) === __rspack_external_node_path_c5b9b54f.parse(rawRef).root);
     const joined = __rspack_external_node_path_c5b9b54f.isAbsolute(rawRef) ? rawRef : __rspack_external_node_path_c5b9b54f.join(manifestDir, rawRef);
-    const publicFromProject = isInsideDir(joined, projectPath) ? __rspack_external_node_path_c5b9b54f.join(publicDir, __rspack_external_node_path_c5b9b54f.relative(projectPath, joined)) : '';
-    const publicFromSlash = looksLikeRootRef ? __rspack_external_node_path_c5b9b54f.join(publicDir, rawRef.replace(/^\/+/, '')) : '';
-    const publicFromRelative = __rspack_external_node_path_c5b9b54f.isAbsolute(rawRef) || rawRef.startsWith('public/') ? '' : __rspack_external_node_path_c5b9b54f.join(publicDir, rawRef);
-    const abs = firstExisting([
-        joined,
-        publicFromProject,
-        publicFromSlash,
-        publicFromRelative
-    ]) || joined;
+    const relFromManifest = isInsideDir(joined, manifestDir) ? __rspack_external_node_path_c5b9b54f.relative(manifestDir, joined) : '';
+    const relFromProject = isInsideDir(joined, projectPath) ? __rspack_external_node_path_c5b9b54f.relative(projectPath, joined) : '';
+    const trimmedRootRef = looksLikeRootRef ? rawRef.replace(/^\/+/, '') : '';
+    const relativeRef = __rspack_external_node_path_c5b9b54f.isAbsolute(rawRef) || rawRef.startsWith('public/') ? '' : rawRef;
+    const candidates = [
+        joined
+    ];
+    for (const publicRoot of publicRoots){
+        const rels = [
+            relFromManifest,
+            trimmedRootRef,
+            relativeRef
+        ];
+        if (publicRoot === inspection.fromRoot) rels.push(relFromProject);
+        for (const rel of rels)if (rel) candidates.push(__rspack_external_node_path_c5b9b54f.join(publicRoot, rel));
+    }
+    const abs = firstExisting(candidates) || joined;
+    const isUnderPublic = publicRoots.some((publicRoot)=>{
+        if (!isInsideDir(abs, publicRoot)) return false;
+        return !inspection.bothExist || publicRoot === inspection.fromRoot;
+    });
     return {
         abs,
-        isUnderPublic: isInsideDir(abs, publicDir),
+        isUnderPublic,
         isPublicRoot
     };
 }
@@ -9541,7 +9751,6 @@ function processJsonAssets(compilation, manifestPath, includeList) {
     }
 }
 function trackJsonDependencies(compilation, manifestPath, includeList) {
-    if (compilation.errors?.length) return;
     const jsonFields = includeList || {};
     const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
     const projectPath = compilation.compiler.options.context || compilation.options.context || manifestDir;
@@ -9553,7 +9762,11 @@ function trackJsonDependencies(compilation, manifestPath, includeList) {
         ];
         for (const thisResource of resourceArr)if (thisResource) {
             const { abs } = resolveJsonResource(thisResource, manifestDir, projectPath);
-            if (__rspack_external_node_fs_5ea92f0c.existsSync(abs) && !compilation.fileDependencies.has(abs)) {
+            if (!__rspack_external_node_fs_5ea92f0c.existsSync(abs)) {
+                compilation.missingDependencies?.add(abs);
+                continue;
+            }
+            if (!compilation.fileDependencies.has(abs)) {
                 compilation.fileDependencies.add(abs);
                 added++;
             }
@@ -9669,9 +9882,8 @@ function processLocaleAssets(compiler, compilation, manifestPath) {
     const resolvedLocalesRoot = resolveLocalesFolder(manifestPath, projectRoot);
     let emittedCount = 0;
     let missingCount = 0;
-    for (const field of Object.entries(localesFields || [])){
-        const [feature, resource] = field;
-        const thisResource = resource;
+    for (const thisResource of localesFields || []){
+        const feature = resolvedLocalesRoot ? __rspack_external_node_path_c5b9b54f.join('_locales', __rspack_external_node_path_c5b9b54f.relative(resolvedLocalesRoot, thisResource)).split(__rspack_external_node_path_c5b9b54f.sep).join('/') : thisResource;
         if (thisResource) {
             if ('.json' !== __rspack_external_node_path_c5b9b54f.extname(thisResource)) continue;
             if (!__rspack_external_node_fs_5ea92f0c.existsSync(thisResource)) {
@@ -9697,10 +9909,13 @@ function processLocaleAssets(compiler, compilation, manifestPath) {
     if (isDebug()) console.log(localesEmitSummary(emittedCount, missingCount, discoveredList.length));
 }
 function trackLocaleDependencies(compilation, manifestPath, projectRoot) {
-    if (compilation.errors?.length) return;
     const localesFields = getLocales(manifestPath, projectRoot) || [];
     let added = 0;
-    for (const thisResource of localesFields)if (__rspack_external_node_fs_5ea92f0c.existsSync(thisResource) && '.json' === __rspack_external_node_path_c5b9b54f.extname(thisResource)) {
+    for (const thisResource of localesFields)if ('.json' === __rspack_external_node_path_c5b9b54f.extname(thisResource)) {
+        if (!__rspack_external_node_fs_5ea92f0c.existsSync(thisResource)) {
+            compilation.missingDependencies?.add(thisResource);
+            continue;
+        }
         if (!compilation.fileDependencies.has(thisResource)) {
             compilation.fileDependencies.add(thisResource);
             added++;
@@ -9708,6 +9923,38 @@ function trackLocaleDependencies(compilation, manifestPath, projectRoot) {
     }
     if (isDebug()) console.log(localesDepsTracked(added));
 }
+const MSG_REFERENCE = /__MSG_([A-Za-z0-9_@]+?)__/g;
+function collectMsgReferences(value) {
+    const found = [];
+    const seen = new Set();
+    const visit = (node)=>{
+        if ('string' == typeof node) {
+            MSG_REFERENCE.lastIndex = 0;
+            let match = MSG_REFERENCE.exec(node);
+            while(null !== match){
+                const name = match[1];
+                if (name && !name.startsWith('@@') && !seen.has(name)) {
+                    seen.add(name);
+                    found.push(name);
+                }
+                match = MSG_REFERENCE.exec(node);
+            }
+            return;
+        }
+        if (Array.isArray(node)) {
+            for (const item of node)visit(item);
+            return;
+        }
+        if (node && 'object' == typeof node) for (const item of Object.values(node))visit(item);
+    };
+    visit(value);
+    return found;
+}
+function findUndefinedMsgReferences(value, catalogKeys) {
+    const lower = new Set();
+    for (const key of catalogKeys)lower.add(String(key).toLowerCase());
+    return collectMsgReferences(value).filter((name)=>!lower.has(name.toLowerCase()));
+}
 function pushCompilationError(compiler, compilation, name, message, file) {
     const ErrorConstructor = compiler?.rspack?.WebpackError || Error;
     const error = new ErrorConstructor(message);
@@ -9767,26 +10014,11 @@ function validateLocales(compiler, compilation, manifestPath) {
             }
             try {
                 const dict = defaultLocaleMessages;
-                const collectMsgKeys = (value, acc)=>{
-                    if ('string' == typeof value) {
-                        const regex = /__MSG_([A-Za-z0-9_@]+?)__/g;
-                        let matches;
-                        while(null !== (matches = regex.exec(value))){
-                            const key = matches[1];
-                            if (key && !key.startsWith('@@')) acc.add(key);
-                        }
-                    } else if (Array.isArray(value)) for (const item of value)collectMsgKeys(item, acc);
-                    else if (value && 'object' == typeof value) for (const v of Object.values(value))collectMsgKeys(v, acc);
-                };
-                const referenced = new Set();
-                collectMsgKeys(manifest, referenced);
+                const referenced = findUndefinedMsgReferences(manifest, Object.keys(dict || {}).filter((key)=>'string' == typeof dict?.[key]?.message));
                 for (const key of referenced){
-                    const entry = dict?.[key];
-                    if (!entry || 'string' != typeof entry.message) {
-                        if (isDebug()) console.log(localesValidationDetected(`missing key "${key}" in default locale`));
-                        pushCompilationError(compiler, compilation, 'LocalesValidationError', missingManifestMessageKey(key, defaultLocale), 'manifest.json');
-                        return false;
-                    }
+                    if (isDebug()) console.log(localesValidationDetected(`missing key "${key}" in default locale`));
+                    pushCompilationError(compiler, compilation, 'LocalesValidationError', missingManifestMessageKey(key, defaultLocale), 'manifest.json');
+                    return false;
                 }
             } catch (error) {
                 if (isDebug()) console.log(localesValidationDetected(`could not scan __MSG__ placeholders in _locales/${defaultLocale}/messages.json: ${String(error?.message || error)}`));
@@ -9919,6 +10151,12 @@ function manifestDepsTracked(addedCount) {
 function manifestLegacyWarningsSummary(count) {
     return `${messaging_prefix('debug')} manifest legacyWarnings=${String(count)}`;
 }
+function pageActionNotSupportedByBrowser(browser) {
+    return `${messaging_prefix('warn')} ${pintor.blue(browser)} does not show the ${pintor.yellow('page_action')} address bar surface.\nThe field was dropped from the built manifest and its page was not emitted.`;
+}
+function pageActionDroppedForBrowserAction(browser) {
+    return `${messaging_prefix('warn')} ${pintor.blue(browser)} refuses a Manifest V2 manifest that declares both ${pintor.yellow('browser_action')} and ${pintor.yellow('page_action')}.\nThe build kept ${pintor.yellow('browser_action')} and dropped ${pintor.yellow('page_action')} from the built manifest, so its page was not emitted. Remove one of the two keys, or scope page_action with the firefox: prefix.`;
+}
 class AddDependencies {
     dependencyList;
     constructor(dependencyList){
@@ -10025,7 +10263,18 @@ function loosenConnectSrcForDev(csp) {
         ...devSources
     ]);
 }
+function keepSiblingSlots(policy, extensionPages) {
+    if (policy && 'object' == typeof policy && !Array.isArray(policy)) return {
+        ...policy,
+        extension_pages: extensionPages
+    };
+    return extensionPages;
+}
 function patchV2CSP(manifest) {
+    const authored = manifest.content_security_policy;
+    return keepSiblingSlots(authored, patchV2PagesPolicy(manifest));
+}
+function patchV2PagesPolicy(manifest) {
     const policy = resolveV2Policy(manifest.content_security_policy);
     if (!policy) return buildCSP({
         "script-src": [
@@ -10079,7 +10328,8 @@ function patchV3CSP(manifest) {
             ]
         })
     };
-    const csp = content_security_policy_parser(policy.extension_pages || '');
+    const extensionPages = 'string' == typeof policy ? policy : policy.extension_pages;
+    const csp = content_security_policy_parser('string' == typeof extensionPages ? extensionPages : '');
     const defaultDirectives = {
         "script-src": [
             "'self'"
@@ -10092,9 +10342,7 @@ function patchV3CSP(manifest) {
     loosenConnectSrcForDev(csp);
     const cspObject = Object.fromEntries(csp.entries());
     const extensionPagesPolicy = buildCSP(cspObject);
-    return {
-        extension_pages: extensionPagesPolicy
-    };
+    return keepSiblingSlots(policy, extensionPagesPolicy);
 }
 function patchExternallyConnectable(manifest) {
     if (manifest.externally_connectable && !manifest.externally_connectable.ids) return {
@@ -10211,13 +10459,16 @@ function findInjectedOnlyPermissionUses(compilation, declared, injected) {
 class ApplyDevDefaults {
     manifestPath;
     browser;
+    devSession;
     constructor(options){
         this.manifestPath = options.manifestPath;
         this.browser = options.browser || 'chrome';
+        this.devSession = options.devSession;
     }
     apply(compiler) {
         if (!compiler?.hooks?.thisCompilation) return;
         if ('development' !== compiler.options.mode) return;
+        if (false === this.devSession) return;
         compiler.hooks.thisCompilation.tap('manifest:apply-dev-defaults', (compilation)=>{
             if (!compilation?.hooks?.processAssets) return;
             compilation.hooks.processAssets.tap({
@@ -10243,6 +10494,31 @@ class ApplyDevDefaults {
                         ])
                     ]
                 } : {};
+                const pushDevWarning = (name, text)=>{
+                    const WebpackErrorCtor = compiler.rspack?.WebpackError;
+                    const warning = WebpackErrorCtor ? new WebpackErrorCtor(text) : new Error(text);
+                    warning.name = name;
+                    if (!compilation.warnings) compilation.warnings = [];
+                    compilation.warnings.push(warning);
+                };
+                const optionalPermissions = new Set(canonicalManifest.optional_permissions || []);
+                const optionalHosts = new Set([
+                    ...canonicalManifest.optional_host_permissions || [],
+                    ...3 === canonicalManifest.manifest_version ? [] : [
+                        ...optionalPermissions
+                    ]
+                ]);
+                const devInjectedPermissions = 3 === canonicalManifest.manifest_version ? [
+                    "scripting",
+                    'tabs',
+                    'management',
+                    'storage'
+                ] : [
+                    'tabs',
+                    'storage'
+                ];
+                for (const permission of devInjectedPermissions)if (optionalPermissions.has(permission) && !(canonicalManifest.permissions || []).includes(permission)) pushDevWarning('DevPromotedOptionalPermissionWarning', `manifest.json lists "${permission}" under optional_permissions, but the dev build needs it and lists it under permissions too. Listed in both means required, so in development it is granted at install and your runtime request flow never runs. The production build keeps it optional.`);
+                for (const match of contentScriptMatches)if (optionalHosts.has(match)) pushDevWarning('DevPromotedOptionalHostWarning', `manifest.json keeps "${match}" optional, but a content script matches it and the dev build grants that host at install so it can re-inject the script on save. In development the host is required; the production build keeps it optional.`);
                 const patchedManifest = {
                     ...canonicalManifest,
                     content_security_policy: 3 === canonicalManifest.manifest_version ? patchV3CSP(canonicalManifest) : patchV2CSP(canonicalManifest),
@@ -10272,20 +10548,15 @@ class ApplyDevDefaults {
                     web_accessible_resources: 3 === canonicalManifest.manifest_version ? patchWebResourcesV3(canonicalManifest) : patchWebResourcesV2(canonicalManifest)
                 };
                 try {
-                    const declared = new Set([
-                        ...canonicalManifest.permissions || [],
-                        ...canonicalManifest.optional_permissions || []
-                    ]);
+                    const declared = new Set(canonicalManifest.permissions || []);
                     const injectedForEra = 3 === canonicalManifest.manifest_version ? INJECTED_PERMISSION_APIS : [
                         'storage'
                     ];
                     const uses = findInjectedOnlyPermissionUses(compilation, declared, injectedForEra);
                     for (const [api, file] of uses){
-                        const WebpackErrorCtor = compiler.rspack?.WebpackError;
-                        const text = `manifest.json does not declare the "${api}" permission, but ${__rspack_external_path.relative(__rspack_external_path.dirname(this.manifestPath), file)} uses chrome.${api}. It works in development only because the dev instrumentation injects "${api}": the production build will fail at runtime. Add "${api}" to permissions in manifest.json.`;
-                        const warning = WebpackErrorCtor ? new WebpackErrorCtor(text) : new Error(text);
-                        warning.name = 'DevInjectedPermissionWarning';
-                        compilation.warnings.push(warning);
+                        const relative = __rspack_external_path.relative(__rspack_external_path.dirname(this.manifestPath), file);
+                        const text = optionalPermissions.has(api) ? `manifest.json only lists the "${api}" permission under optional_permissions, but ${relative} uses chrome.${api}. It works in development only because the dev instrumentation injects "${api}" as required: the production build has it only after a runtime chrome.permissions.request, so guard the use or move "${api}" to permissions.` : `manifest.json does not declare the "${api}" permission, but ${relative} uses chrome.${api}. It works in development only because the dev instrumentation injects "${api}": the production build will fail at runtime. Add "${api}" to permissions in manifest.json.`;
+                        pushDevWarning('DevInjectedPermissionWarning', text);
                     }
                 } catch  {}
                 const source = JSON.stringify(patchedManifest, null, 2);
@@ -10448,8 +10719,8 @@ function collectReferencedRuntimePayloads(source, emittedAssetNames) {
     const found = new Set();
     const patternHits = source.match(EMITTED_ASSET_REF_PATTERN) || [];
     for (const hit of patternHits)if (!isExcludedFromWar(hit)) found.add(hit);
-    const eligible = emittedAssetNames.filter((name)=>!isExcludedFromWar(name)).sort((a, b)=>b.length - a.length);
-    for (const asset of eligible)if (source.includes(asset)) found.add(unixify(asset));
+    const eligible = emittedAssetNames.map((name)=>unixify(name)).filter((name)=>!isExcludedFromWar(name)).sort((a, b)=>b.length - a.length);
+    for (const asset of eligible)if (source.includes(asset)) found.add(asset);
     return Array.from(found);
 }
 function forEachStringKey(objectOrMap, callback) {
@@ -10474,6 +10745,33 @@ function getAssetSource(compilation, filename) {
     if ('string' == typeof src) return src;
     return '';
 }
+function collectContentScriptAsyncChunkFiles(compilation) {
+    const result = {};
+    if ('function' != typeof compilation.entrypoints?.forEach) return result;
+    compilation.entrypoints.forEach((entry, entryName)=>{
+        if (!String(entryName).startsWith("content_scripts/")) return;
+        const initial = new Set();
+        for (const chunk of toFileArray(entry.chunks))for (const file of toFileArray(chunk.files))initial.add(file);
+        const asyncFiles = new Set();
+        const visitChunk = (chunk)=>{
+            for (const file of toFileArray(chunk.files))if (!(!file.endsWith('.js') || initial.has(file))) asyncFiles.add(unixify(file));
+        };
+        for (const chunk of toFileArray(entry.chunks)){
+            const withAsync = chunk;
+            if ('function' == typeof withAsync.getAllAsyncChunks) for (const asyncChunk of withAsync.getAllAsyncChunks())visitChunk(asyncChunk);
+        }
+        const seenGroups = new Set();
+        const visitGroup = (group)=>{
+            if (seenGroups.has(group)) return;
+            seenGroups.add(group);
+            for (const chunk of toFileArray(group.chunks))visitChunk(chunk);
+            if ('function' == typeof group.getChildren) for (const child of group.getChildren())visitGroup(child);
+        };
+        if ('function' == typeof entry.getChildren) for (const child of entry.getChildren?.() || [])visitGroup(child);
+        if (asyncFiles.size > 0) result[entryName] = Array.from(asyncFiles).sort();
+    });
+    return result;
+}
 function collectContentScriptEntryImports(compilation, includeList) {
     const entryImports = {};
     const contentEntryNames = new Set(Object.keys(includeList || {}).filter((k)=>k.startsWith("content_scripts")));
@@ -10970,6 +11268,14 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
             });
         }
     }
+    const asyncChunks = collectContentScriptAsyncChunkFiles(compilation);
+    for (const [entryName, chunkFiles] of Object.entries(asyncChunks)){
+        const contentScript = canonicalManifest.content_scripts?.find((script)=>script.js?.some((jsFile)=>jsFile.includes(entryName)));
+        if (contentScript) {
+            if (3 === canonicalManifest.manifest_version) mergeIntoV3Group(webAccessibleResourcesV3, cleanMatches(contentScript.matches || []), chunkFiles);
+            else for (const file of chunkFiles)if (!webAccessibleResourcesV2.includes(file)) webAccessibleResourcesV2.push(file);
+        }
+    }
     if (3 === canonicalManifest.manifest_version) {
         const assetKeys = Object.keys(compilation.assets || {});
         const staticAssets = assetKeys.filter((k)=>k.startsWith('assets/')).filter((k)=>!k.endsWith('.js') && !k.endsWith('.map')).sort();
@@ -11090,7 +11396,7 @@ function normalizeManifestFile(filePath) {
     if ('string' != typeof filePath) return;
     const normalized = filePath.trim().replace(/^\/+/, '');
     if (!normalized) return;
-    if (/^(https?:)?\/\//i.test(filePath)) return;
+    if (isManifestAddress(filePath)) return;
     if (/[*?[\]{}]/.test(normalized)) return;
     return normalized;
 }
@@ -11116,6 +11422,10 @@ function collectRequiredManifestFiles(manifest) {
     addFile(manifestObj?.chrome_url_overrides?.newtab);
     addFile(manifestObj?.chrome_url_overrides?.history);
     addFile(manifestObj?.chrome_url_overrides?.bookmarks);
+    addFile(manifestObj?.theme_experiment?.stylesheet);
+    addFile(manifestObj?.chrome_settings_overrides?.search_provider?.favicon_url);
+    const startupPages = manifestObj?.chrome_settings_overrides?.startup_pages;
+    if (Array.isArray(startupPages)) for (const page of startupPages)addFile(page);
     const contentScripts = manifestObj?.content_scripts;
     if (Array.isArray(contentScripts)) for (const contentScript of contentScripts){
         const js = contentScript?.js;
@@ -11177,6 +11487,7 @@ class PersistManifestToDisk {
             const requiredFiles = collectRequiredManifestFiles(manifest);
             const missingFiles = findMissingFilesOnDisk(outputPath, requiredFiles);
             if (missingFiles.length > 0) {
+                if (isCompilerRestarting(compiler)) return;
                 const sample = missingFiles.slice(0, 5).join('\n  - ');
                 const more = missingFiles.length > 5 ? `\n  ... and ${missingFiles.length - 5} more` : '';
                 const err = new core.WebpackError([
@@ -12350,11 +12661,14 @@ class UpdateManifest {
             }, ()=>{
                 if (compilation.errors.length > 0) return;
                 const manifest = getManifestContent(compilation, this.manifestPath);
-                let patchedManifest = buildCanonicalManifest(this.manifestPath, manifest, this.browser);
+                const dropReason = pageActionDropReason(filterKeysForThisBrowser(manifest, this.browser), this.browser);
+                if (dropReason) reportToCompilation(compilation, compiler, 'conflicts' === dropReason ? pageActionDroppedForBrowserAction(String(this.browser)) : pageActionNotSupportedByBrowser(String(this.browser)), 'warning', 'manifest.json');
+                const projectPath = compiler.options.context || __rspack_external_node_path_c5b9b54f.dirname(this.manifestPath);
+                let patchedManifest = buildCanonicalManifest(this.manifestPath, manifest, this.browser, projectPath);
                 patchedManifest = patchGeckoBackground(patchedManifest, this.browser);
                 patchedManifest = patchChromiumBackground(patchedManifest, this.browser);
                 patchedManifest = patchChromiumThemeColors(patchedManifest, this.browser);
-                const overrides = getManifestOverrides(this.manifestPath, manifest);
+                const overrides = getManifestOverrides(this.manifestPath, manifest, projectPath);
                 if ('development' === compiler.options.mode) {
                     if (patchedManifest.content_scripts) patchedManifest.content_scripts = this.applyDevOverrides(patchedManifest);
                     patchedManifest = patchDevContentScriptManifestPaths(compilation, patchedManifest);
@@ -12437,10 +12751,12 @@ class ManifestPlugin {
     manifestPath;
     browser;
     includeList;
+    devSession;
     constructor(options){
         this.manifestPath = options.manifestPath;
         this.browser = options.browser || 'chrome';
         this.includeList = options.includeList;
+        this.devSession = options.devSession;
     }
     apply(compiler) {
         if (isDebug()) console.log(manifestIncludeSummary(String(this.browser || 'chrome'), this.manifestPath));
@@ -12462,7 +12778,8 @@ class ManifestPlugin {
         }).apply(compiler);
         new ApplyDevDefaults({
             manifestPath: this.manifestPath,
-            browser: this.browser
+            browser: this.browser,
+            devSession: this.devSession
         }).apply(compiler);
         new PersistManifestToDisk().apply(compiler);
         new AddDependencies([
@@ -13059,9 +13376,7 @@ function discoverDevtoolsPanelPages(manifestPath) {
     }
     return pages;
 }
-function isCriticalJsonFeatureKey(key) {
-    return key.startsWith('declarative_net_request') || 'storage.managed_schema' === key;
-}
+const isCriticalJsonFeatureKey = isCriticalJsonFeature;
 function toComparablePath(value) {
     return 'string' == typeof value ? value : JSON.stringify(value);
 }
@@ -13110,7 +13425,7 @@ class ManifestFieldsChangeDetector {
         this.browser = options.browser || 'chrome';
     }
     readSnapshot() {
-        const fields = getManifestFieldsData({
+        const fields = getResolvedManifestFieldsData({
             manifestPath: this.manifestPath,
             browser: this.browser
         });
@@ -13160,6 +13475,11 @@ class ManifestFieldsChangeDetector {
                 if (htmlDiff) this.pending.html = htmlDiff;
                 if (iconsDiff) this.pending.icons = iconsDiff;
                 if (jsonDiff) this.pending.json = jsonDiff;
+                if (this.tryAutoRestart(compiler)) {
+                    this.pending = {};
+                    done();
+                    return;
+                }
                 this.prev = next;
                 done();
             } catch  {
@@ -13176,6 +13496,24 @@ class ManifestFieldsChangeDetector {
             });
         });
     }
+    tryAutoRestart(compiler) {
+        const order = [
+            "scripts",
+            'html',
+            'icons',
+            'json'
+        ];
+        for (const reason of order){
+            const change = this.pending[reason];
+            if (change) return requestDevSessionRestart(compiler, {
+                reason,
+                pathAfter: change.pathAfter,
+                pathBefore: change.pathBefore,
+                manifestField: change.manifestField
+            });
+        }
+        return false;
+    }
     emitErrors(compilation) {
         if (this.pending.scripts) {
             const p = this.pending.scripts;
@@ -13212,23 +13550,81 @@ class ManifestFieldsChangeDetector {
         }
     }
 }
+function readManifest(manifestPath) {
+    try {
+        return JSON.parse(stripBom(__rspack_external_node_fs_5ea92f0c.readFileSync(manifestPath, 'utf8')));
+    } catch  {
+        return {};
+    }
+}
+function isPublicSpelling(value) {
+    return /^(?:\/public\/|(?:\.\/)?public\/)/i.test(value);
+}
+function resolveAsset(manifestDir, value) {
+    if (isPublicSpelling(value) || value.startsWith('/')) return value;
+    return __rspack_external_node_path_c5b9b54f.isAbsolute(value) ? value : __rspack_external_node_path_c5b9b54f.join(manifestDir, value);
+}
+function localFile(manifestDir, value) {
+    if ('string' != typeof value || !value.trim()) return;
+    if (isManifestAddress(value) || isPublicSpelling(value)) return;
+    const resolved = resolveAsset(manifestDir, value);
+    if (resolved.startsWith('/') && !__rspack_external_node_path_c5b9b54f.isAbsolute(resolved)) return;
+    if (resolved.startsWith('/') && !__rspack_external_node_fs_5ea92f0c.existsSync(resolved) && __rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(manifestDir, 'public', resolved.slice(1)))) return;
+    return resolved.startsWith('/') && !__rspack_external_node_fs_5ea92f0c.existsSync(resolved) ? __rspack_external_node_path_c5b9b54f.join(manifestDir, resolved.slice(1)) : resolved;
+}
+function themeExperimentStylesheetEntries(manifestPath) {
+    const manifest = readManifest(manifestPath);
+    const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
+    const file = localFile(manifestDir, manifest.theme_experiment?.stylesheet);
+    if (!file) return {};
+    const name = __rspack_external_node_path_c5b9b54f.basename(file).replace(/\.[^.]+$/, '');
+    return {
+        [`theme_experiment/${name}`]: [
+            file
+        ]
+    };
+}
+function settingsOverridesIconFields(manifestPath) {
+    const manifest = readManifest(manifestPath);
+    const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
+    const fav = manifest.chrome_settings_overrides?.search_provider?.favicon_url;
+    if ('string' != typeof fav || !fav.trim() || isManifestAddress(fav)) return {};
+    return {
+        'chrome_settings_overrides/favicon_url': resolveAsset(manifestDir, fav)
+    };
+}
+function settingsOverridesStartupPages(manifestPath) {
+    const manifest = readManifest(manifestPath);
+    const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
+    const pages = manifest.chrome_settings_overrides?.startup_pages;
+    if (!Array.isArray(pages)) return {};
+    const out = {};
+    pages.forEach((page, index)=>{
+        const file = localFile(manifestDir, page);
+        if (file) out[`chrome_settings_overrides/startup-${index}`] = file;
+    });
+    return out;
+}
 class plugin_web_extension_WebExtensionPlugin {
     static name = 'plugin-extension';
     manifestPath;
     browser;
+    devSession;
     constructor(options){
         this.manifestPath = options.manifestPath;
         this.browser = options.browser || 'chrome';
+        this.devSession = options.devSession;
     }
     apply(compiler) {
         const manifestPath = this.manifestPath;
-        const manifestFieldsData = getManifestFieldsData({
+        const manifestFieldsData = getResolvedManifestFieldsData({
             manifestPath,
             browser: this.browser
         });
         const specialFoldersData = getSpecialFoldersDataForCompiler(compiler);
         new ManifestPlugin({
             browser: this.browser,
+            devSession: this.devSession,
             manifestPath,
             includeList: {
                 ...manifestFieldsData.html,
@@ -13238,11 +13634,13 @@ class plugin_web_extension_WebExtensionPlugin {
             }
         }).apply(compiler);
         new HtmlPlugin({
+            devSession: this.devSession,
             manifestPath,
             browser: this.browser,
             includeList: {
                 ...manifestFieldsData.html,
                 ...discoverDevtoolsPanelPages(manifestPath),
+                ...settingsOverridesStartupPages(manifestPath),
                 ...specialFoldersData.pages
             }
         }).apply(compiler);
@@ -13251,7 +13649,8 @@ class plugin_web_extension_WebExtensionPlugin {
             browser: this.browser,
             includeList: {
                 ...manifestFieldsData.scripts,
-                ...specialFoldersData.scripts
+                ...specialFoldersData.scripts,
+                ...themeExperimentStylesheetEntries(manifestPath)
             }
         }).apply(compiler);
         new LocalesPlugin({
@@ -13266,7 +13665,9 @@ class plugin_web_extension_WebExtensionPlugin {
             manifestPath,
             includeList: {
                 ...manifestFieldsData.icons,
-                ...manifestFieldsData.theme
+                ...themeImageFields(manifestPath),
+                ...omniboxIconFields(manifestPath),
+                ...settingsOverridesIconFields(manifestPath)
             },
             browser: this.browser
         }).apply(compiler);
@@ -13286,6 +13687,7 @@ class plugin_web_extension_WebExtensionPlugin {
 function webpackConfig(projectStructure, devOptions) {
     const { manifestPath } = projectStructure;
     const { packageJsonDir } = getDirs(projectStructure);
+    const devSession = devOptions.metadataCommand ? 'dev' === devOptions.metadataCommand : 'development' === (devOptions.mode || 'development');
     let rawManifest;
     try {
         rawManifest = JSON.parse(stripBom(__rspack_external_node_fs_5ea92f0c.readFileSync(manifestPath, 'utf-8')));
@@ -13297,7 +13699,8 @@ function webpackConfig(projectStructure, devOptions) {
     const publishedExtensionOutputDir = devOptions.output.finalPath ? asAbsolute(__rspack_external_node_path_c5b9b54f.isAbsolute(devOptions.output.finalPath) ? devOptions.output.finalPath : __rspack_external_node_path_c5b9b54f.resolve(packageJsonDir, devOptions.output.finalPath)) : primaryExtensionOutputDir;
     const companionUnpackedExtensionDirs = resolveCompanionExtensionDirs({
         projectRoot: packageJsonDir,
-        config: devOptions.extensions
+        config: devOptions.extensions,
+        browser: devOptions.browser
     });
     const unpackedExtensionDirsToLoad = computeExtensionsToLoad(__rspack_external_node_path_c5b9b54f.resolve(__rspack_import_meta_dirname__, '..'), devOptions.mode, devOptions.browser, primaryExtensionOutputDir, companionUnpackedExtensionDirs, manifestPath);
     const debug = isDebug();
@@ -13351,11 +13754,13 @@ function webpackConfig(projectStructure, devOptions) {
         }),
         new plugin_web_extension_WebExtensionPlugin({
             manifestPath,
-            browser: devOptions.browser
+            browser: devOptions.browser,
+            devSession
         }),
         new ReloadPlugin({
             manifestPath,
-            browser: devOptions.browser
+            browser: devOptions.browser,
+            devSession
         }),
         new SetupChunkLoadingTarget({
             manifestPath,
@@ -13473,7 +13878,7 @@ function webpackConfig(projectStructure, devOptions) {
         ],
         context: packageJsonDir,
         cache: false,
-        devtool: 'production' === (devOptions.mode || 'development') ? false : 3 === manifest.manifest_version ? 'cheap-source-map' : 'eval-cheap-source-map',
+        devtool: 'production' === (devOptions.mode || 'development') ? false : 'cheap-module-source-map',
         output: {
             clean: devOptions.output.clean,
             path: primaryExtensionOutputDir,
@@ -13547,10 +13952,7 @@ function webpackConfig(projectStructure, devOptions) {
                 'node_modules',
                 __rspack_external_node_path_c5b9b54f.join(process.cwd(), 'node_modules')
             ],
-            roots: [
-                __rspack_external_node_path_c5b9b54f.join(packageJsonDir, 'public'),
-                __rspack_external_node_path_c5b9b54f.dirname(manifestPath)
-            ],
+            roots: publicResolveRoots(packageJsonDir, manifestPath),
             extensionAlias: {
                 '.js': [
                     '.ts',
@@ -13646,4 +14048,4 @@ function webpackConfig(projectStructure, devOptions) {
         }
     };
 }
-export { resolveConnectableHost, rspack_config_namespaceObject, setupCompilerLifecycleHooks, setupNoBrowserBannerOnFirstDone, webpackConfig };
+export { DevSessionRestartScheduler, bindDevSessionRestart, resolveConnectableHost, rspack_config_namespaceObject, setupCompilerLifecycleHooks, setupNoBrowserBannerOnFirstDone, unbindDevSessionRestart, webpackConfig };