extension-develop 4.1.19 → 4.1.21

package/dist/rspack-config~0.mjs

@@ -1,7 +1,7 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import core, { Compilation as core_Compilation, DefinePlugin, EntryPlugin, LightningCssMinimizerRspackPlugin, ProvidePlugin, SwcJsMinimizerRspackPlugin, WebpackError as core_WebpackError, experiments, javascript as core_javascript, library, rspack, sources as core_sources } from "@rspack/core";
 import { createRequire } from "node:module";
 import pintor from "pintor";
-import core, { Compilation as core_Compilation, DefinePlugin, EntryPlugin, ProvidePlugin, WebpackError as core_WebpackError, javascript as core_javascript, library, rspack, sources as core_sources } from "@rspack/core";
 import case_sensitive_paths_webpack_plugin from "case-sensitive-paths-webpack-plugin";
 import { zipSync } from "fflate";
 import ignore from "ignore";
@@ -14,12 +14,12 @@ import node_path from "node:path";
 import { utils_isUrl, getBaseNode, parseHtml, manifestJsonOutputTarget, getExtname, getBaseHref, isResourceUnderDirs, getAssetsFromHtml, normalizeManifestOutputPath, manifestPageOutputTarget, canonicalizeDir, iconOutputPath, isFromIncludeList, htmlStaticAssetOutputName, isSpecialScheme, resolveStaticAttributeName, getHtmlPageDeclaredAssetPath, themeImageOutputPath, themeIconOutputPath, applyRewrittenStaticUrl, toResourceKey, cleanLeading, getFilePath, resolveAbsoluteFsPath, cleanAssetUrl, isHttpLike, resolveHtmlRefPath } from "./938~0.mjs";
 import { prefix as messaging_prefix, isDebug } from "./852~0.mjs";
 import { isChromiumBasedBrowser, CHROMIUM_FAMILY_ALIASES, GECKO_FAMILY_ALIASES, isWebkitBasedBrowser, isGeckoBasedBrowser } from "./331~0.mjs";
-import { isUsingTypeScript, jsFrameworksIntegrationsEnabled, classifyEntrySurface, ensureTypeScriptConfig, ensureOptionalContractModuleLoaded, resolveDevelopInstallRoot, isUsingCustomLoader, getUserTypeScriptConfigFile, loadOptionalContractModuleWithoutInstall, isUsingIntegration as messages_isUsingIntegration, resolveOptionalContractPackageWithoutInstall, jsFrameworksHmrSummary, humanLine, ensureOptionalContractPackageResolved, jsFrameworksConfigsDetected, recordZipArtifact, hasDependency, resolveDevelopDistFile, defaultSplitChunks } from "./840~0.mjs";
+import { maybeUsePreact, isUsingTypeScript, jsFrameworksIntegrationsEnabled, maybeUseReact, isUsingVue, classifyEntrySurface, ensureTypeScriptConfig, resolveDevelopInstallRoot, loadLoaderOptions, getUserTypeScriptConfigFile, isUsingIntegration as messages_isUsingIntegration, maybeUseVue, maybeUseSolid, jsFrameworksHmrSummary, humanLine, ensureOptionalContractPackageResolved, jsFrameworksConfigsDetected, recordZipArtifact, hasDependency, resolveDevelopDistFile, isUsingJsxFramework, getJsxImportSource, swcParserForFile, isUsingReact, defaultSplitChunks } from "./840~0.mjs";
 import { bundlerFatalError, bundlerRecompiling, browserRunnerDisabled, PlaywrightPlugin, publicFolderShadowed, resolveCompanionExtensionDirs, specialFoldersSetupSummary, noEntrypointsDetected, serverRestartRequiredFromSpecialFolderMessageOnly, specialFolderChangeDetected, spacerLine, messages_ready, getPreloadedEnvKeys, publicMustBeAtProjectRoot, computeExtensionsToLoad, getSpecialFoldersDataForCompiler } from "./832~0.mjs";
 import { renderStatsBlocks, makeSanitizedConsole } from "./stats-handler~0.mjs";
 import { stripBom, findNearestProjectManifestSync, PROJECT_MANIFEST_FILENAMES, parseJsonSafe, readProjectDependencies } from "./731~0.mjs";
 import { EXTENSIONJS_CONTENT_SCRIPT_LAYER, getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, CONTENT_SCRIPT_CSS_PROBE_MARKER_PREFIX, createContentScriptCssProbeMarkerPattern, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName, isCanonicalContentScriptAsset } from "./640~0.mjs";
-import { getURLDependencyMissing, findDroppedVendorKeys, isStaticThemeSource, entrySplitAcrossInitialFiles, isStaticTheme, fetchedFileDependencyMissing, filterKeysForThisBrowser, compiledSourceSpelling, importScriptsDependencyMissing, injectedFileDependencyMissing, injectedCompiledSourceLiteral, staticImportDependencyMissing, runtimeSetSurfaceDependencyMissing } from "./672~0.mjs";
+import { getURLDependencyMissing, findDroppedVendorKeys, isStaticThemeSource, workerStartedFromPageContext, importScriptsDependencyMissing, filterKeysForThisBrowser, findPrefixedManifestVersionKeys, injectedCompiledSourceLiteral, staticImportDependencyMissing, entrySplitAcrossInitialFiles, fetchedFileDependencyMissing, isStaticTheme, compiledSourceSpelling, injectedFileDependencyMissing, isValidManifestVersion, runtimeSetSurfaceDependencyMissing } from "./672~0.mjs";
 import { packagingSourceFiles, debugBrowser, debugExtensionsToLoad, treeWithSourceFiles, debugOutputPath, manifestInvalidJson, getDirs, asAbsolute, treeWithDistFilesBrowser, packagingDistributionFiles, treeWithSourceAndDistFiles, toPosixPath as paths_toPosixPath, debugContextPath, noCompanionExtensionsResolved } from "./950~0.mjs";
 import { cssMinifierDroppedRules, postCssConfigUnreadable, missingSassDependency, deadCssUrlRef, postCssPluginNotResolved, postCssConfigPluginsShape, cssIntegrationsEnabled, cssConfigsDetected, isUsingIntegration } from "./524~0.mjs";
 import { minifierDroppedTokens, restoreVerbatimCssAssets } from "./88~0.mjs";
@@ -33,8 +33,6 @@ import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
 import * as __rspack_external_node_path_806ed179 from "node:path";
 import * as __rspack_external_dotenv from "dotenv";
 import * as __rspack_external_parse5_utilities_4a00fdd6 from "parse5-utilities";
-import * as __rspack_external_fs from "fs";
-import * as __rspack_external_path from "path";
 import * as __rspack_external_node_crypto_2e7c4b46 from "node:crypto";
 function normalizePath(filePath) {
     return filePath.replace(/\\/g, '/');
@@ -707,7 +705,7 @@ function optionsPage(manifest, manifestPath) {
         })()
     };
 }
-function optionsUi(manifest, manifestPath) {
+function options_ui_optionsUi(manifest, manifestPath) {
     return manifest.options_ui && {
         options_ui: {
             ...manifest.options_ui,
@@ -806,7 +804,7 @@ function manifestCommon(manifest, manifestPath, projectPath) {
         ...commands_commands(manifest),
         ...permissions_permissions(manifest),
         ...optionsPage(manifest, manifestPath),
-        ...optionsUi(manifest, manifestPath),
+        ...options_ui_optionsUi(manifest, manifestPath),
         ...sandbox(manifest, manifestPath),
         ...storage(manifest, manifestPath, projectPath),
         ...theme_theme(manifest, manifestPath),
@@ -1119,6 +1117,348 @@ function getManifestOverrides(manifestPath, manifest, projectPath) {
     if (Object.keys(backgroundMerged).length) merged.background = backgroundMerged;
     return JSON.stringify(dropMv2ObjectPolicy(dropMv2HostKeys(merged)), null, 2);
 }
+function serverRestartRequiredFromManifestError(fileAdded, fileRemoved) {
+    const lines = [];
+    lines.push("Entrypoint references changed.");
+    if (fileRemoved) lines.push(`${pintor.gray('EXPECTED')} ${pintor.underline(fileRemoved)}`);
+    if (fileAdded) lines.push(`${pintor.gray('GOT')} ${pintor.underline(fileAdded)}`);
+    lines.push("Restart the dev server to pick up changes to manifest entrypoints.");
+    return lines.join('\n');
+}
+function legacyManifestPathWarning(field, legacyPath, modernPath) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} The ${pintor.blue(field)} field uses a deprecated scaffold path.`);
+    lines.push(`${pintor.gray('PATH')} ${pintor.underline(legacyPath)}`);
+    lines.push(`Point it at ${pintor.underline(modernPath)}, Extension.js already emits the page there.`);
+    return lines.join('\n');
+}
+function fatalManifestShapeFixed(field, detail) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} Repaired the ${pintor.blue(field)} field, which Chrome refuses to load the extension over.`);
+    lines.push(`${pintor.gray('REASON')} ${pintor.underline(detail)}`);
+    lines.push(`Fix the field in your ${pintor.blue('manifest.json')} file.`);
+    return lines.join('\n');
+}
+function invalidThemeValue(field, detail, value) {
+    const lines = [];
+    lines.push(`Check the ${pintor.yellow(field)} field in your ${pintor.yellow('manifest.json')} file.`);
+    lines.push(detail);
+    lines.push(`Chrome rejects the whole extension when this value is malformed.\nThe build stops here to protect you.`);
+    lines.push('');
+    lines.push(`${pintor.red('INVALID VALUE')} ${value}`);
+    return lines.join('\n');
+}
+function themeNotSupportedByBrowser(browser) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} ${pintor.blue(browser)} does not support the ${pintor.yellow('theme')} field.`);
+    lines.push("The field ships unchanged in the manifest and Safari ignores it.");
+    return lines.join('\n');
+}
+function missingGeckoDataCollectionPermissions() {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} addons.mozilla.org requires ${pintor.blue('browser_specific_settings.gecko.data_collection_permissions')} for new add-ons.`);
+    lines.push(`Declare ${pintor.blue('{"required": ["none"]}')} if this extension transmits no data.`);
+    lines.push(`See ${pintor.underline('https://extensionworkshop.com/documentation/develop/firefox-builtin-data-consent/')} for details.`);
+    return lines.join('\n');
+}
+function manifestInvalidError(error) {
+    const lines = [];
+    lines.push(`Can't read your ${pintor.blue('manifest.json')} file.`);
+    lines.push(`${pintor.gray('REASON')} ${pintor.underline(String(error))}`);
+    lines.push("Update your manifest and try again.");
+    return lines.join('\n');
+}
+function manifestIncludeSummary(browser, manifestPath) {
+    return `${messaging_prefix('debug')} manifest include browser=${browser} path=${manifestPath}`;
+}
+function manifestEmitSuccess() {
+    return `${messaging_prefix('debug')} manifest emitted=true schemaStripped=true`;
+}
+function manifestOverridesSummary(overrideKeys, devCssStubsAdded) {
+    return `${messaging_prefix('debug')} manifest overrides keys=${String(overrideKeys)} devCssStubs=${String(devCssStubsAdded)}`;
+}
+function manifestDepsTracked(addedCount) {
+    return `${messaging_prefix('debug')} manifest deps=${String(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.`;
+}
+function vendorPrefixedKeyDropped(key, familyKey, vendor, browser) {
+    const vendorName = 'edge' === vendor ? 'Edge' : 'Chrome';
+    return `${messaging_prefix('warn')} ${pintor.yellow(key)} now applies only to ${vendorName} builds, so the ${pintor.blue(browser)} build dropped it.\nRename it to ${pintor.yellow(familyKey)} to keep it on every Chromium-based browser. Leave it as is if it's meant for ${vendorName} only.`;
+}
+function prefixScope(prefix) {
+    if ('chrome' === prefix) return 'Chrome';
+    if ('edge' === prefix) return 'Edge';
+    if ('chromium' === prefix) return 'Chromium-based';
+    if ('firefox' === prefix || 'gecko' === prefix) return 'Firefox-based';
+    if ('safari' === prefix || 'webkit' === prefix) return 'Safari';
+    return prefix;
+}
+function manifestVersionLostForBrowser(browser, prefixedKeys, resolved) {
+    const target = pintor.blue(browser);
+    const field = pintor.yellow('manifest_version');
+    const scoped = prefixedKeys.map((key)=>{
+        const scope = prefixScope(key.substring(0, key.indexOf(':')));
+        return `${pintor.yellow(key)} applies only to ${scope} builds`;
+    });
+    const lead = void 0 === resolved ? scoped.length ? `${scoped.join(', ')}, so the ${target} build has no ${field}.` : `The ${target} build has no ${field}.` : `The ${target} build resolved ${field} to ${pintor.yellow(JSON.stringify(resolved))}, and browsers load only 2 or 3.`;
+    return `${messaging_prefix('error')} ${lead}\nNo browser loads a manifest without it, so the build was refused. Add a plain ${field}, or scope one to this browser: ${pintor.yellow('chromium:manifest_version')} for every Chromium-based browser, ${pintor.yellow('firefox:manifest_version')} for Firefox.`;
+}
+function edgeStoreKeyDropped(browser) {
+    return `${messaging_prefix('warn')} Edge Add-ons refuses a package whose manifest carries ${pintor.yellow('key')}, so the ${pintor.blue(browser)} production build dropped it.\nPartner Center assigns the id that ${pintor.yellow('key')} pins everywhere else, so the field has no use in this package. Write it as ${pintor.yellow('chrome:key')} if it is meant for the Chrome Web Store build only.`;
+}
+function mv2SandboxPolicyDropped(browser) {
+    return `${messaging_prefix('warn')} ${pintor.blue(browser)} reads a Manifest V2 ${pintor.yellow('content_security_policy')} as one string, so the ${pintor.yellow('sandbox')} slot has nowhere to go.\nThe build wrote the ${pintor.yellow('extension_pages')} policy as that string and dropped the sandbox policy from the built manifest. Scope the object form with the chromium: prefix, or declare a Manifest V3 build for this browser.`;
+}
+function geckoSidePanelUnsupported(file) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} ${pintor.underline(file)} uses chrome.sidePanel, which is Chromium only.`);
+    lines.push(`Firefox opens a sidebar through the ${pintor.yellow('sidebar_action')} manifest key on every manifest version, and addons-linter flags the call as UNSUPPORTED_API.`);
+    lines.push(`Move the call behind a build-time branch on ${pintor.blue('import.meta.env.EXTENSION_PUBLIC_BROWSER')} so the Firefox bundle drops it.`);
+    return lines.join('\n');
+}
+function safariUnsupportedApi(file, api, detail) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} ${pintor.underline(file)} calls chrome.${api}, which Safari does not have.`);
+    lines.push(detail);
+    lines.push(`Move the call behind a build-time branch on ${pintor.blue('import.meta.env.EXTENSION_PUBLIC_BROWSER')}, or guard it with ${pintor.yellow(`chrome.${api}?.`)}.`);
+    return lines.join('\n');
+}
+const safariBackgroundDies = "The call throws when the script runs, Safari drops the background, and nothing reports an error.";
+function safariSidePanelUnsupported(file) {
+    return safariUnsupportedApi(file, 'sidePanel', "The call throws when the script runs. In a background service worker, Safari then never starts the worker, and nothing reports an error.");
+}
+function safariOffscreenUnsupported(file) {
+    return safariUnsupportedApi(file, 'offscreen', `Safari has no offscreen documents, so that DOM work has no place to run. ${safariBackgroundDies}`);
+}
+function safariTabGroupsUnsupported(file) {
+    return safariUnsupportedApi(file, 'tabGroups', `Safari has no tab groups, and its tabs carry no group id. ${safariBackgroundDies}`);
+}
+function safariManagementUnsupported(file) {
+    return safariUnsupportedApi(file, 'management', `Safari exposes no management namespace at all, not even getSelf. ${safariBackgroundDies}`);
+}
+function safariUserScriptsUnsupported(file) {
+    return safariUnsupportedApi(file, 'userScripts', `Safari has no userScripts namespace, and scripting.registerContentScripts is the closest it offers. ${safariBackgroundDies}`);
+}
+function safariIdentityUnsupported(file) {
+    return safariUnsupportedApi(file, 'identity', `Safari has no identity namespace, and Apple points OAuth flows at a normal tab instead. ${safariBackgroundDies}`);
+}
+function safariNotificationsUnsupported(file) {
+    return safariUnsupportedApi(file, 'notifications', `Safari has no notifications namespace, so a page has to raise the web Notification instead. ${safariBackgroundDies}`);
+}
+function safariOmniboxUnsupported(file) {
+    return safariUnsupportedApi(file, 'omnibox', `Safari has no omnibox keyword API. ${safariBackgroundDies}`);
+}
+function safariBookmarksUnsupported(file) {
+    return safariUnsupportedApi(file, 'bookmarks', `Safari does not expose bookmarks to extensions on any version. ${safariBackgroundDies}`);
+}
+function safariHistoryUnsupported(file) {
+    return safariUnsupportedApi(file, 'history', `Safari does not expose browsing history to extensions on any version. ${safariBackgroundDies}`);
+}
+function safariDownloadsUnsupported(file) {
+    return safariUnsupportedApi(file, 'downloads', `Safari has no downloads namespace. ${safariBackgroundDies}`);
+}
+function safariIdleUnsupported(file) {
+    return safariUnsupportedApi(file, 'idle', `Safari has no idle namespace. ${safariBackgroundDies}`);
+}
+const safariMissingMemberDetails = {
+    'action.getUserSettings': `Safari has no pinned-state query for the toolbar button, so there is no function to call. ${safariBackgroundDies}`,
+    'action.getBadgeTextColor': `Safari draws the badge in its own colors and offers no badge text color call. ${safariBackgroundDies}`,
+    'action.setBadgeTextColor': `Safari draws the badge in its own colors and offers no badge text color call. ${safariBackgroundDies}`,
+    'action.onUserSettingsChanged': `Safari raises no event when the toolbar button settings change, so the listener attaches to nothing. ${safariBackgroundDies}`,
+    'storage.managed': `Safari has no managed storage area, since it carries no enterprise policy channel for web extensions. ${safariBackgroundDies}`,
+    'runtime.getContexts': `Safari keeps no inventory of extension contexts to hand back. ${safariBackgroundDies}`,
+    'runtime.onSuspend': `Safari tears a background down without announcing it, so this lifecycle event does not exist. ${safariBackgroundDies}`,
+    'runtime.onSuspendCanceled': `Safari tears a background down without announcing it, so this lifecycle event does not exist. ${safariBackgroundDies}`,
+    'runtime.onUpdateAvailable': `Safari ships an extension inside its host app, so the browser raises no update event for it. ${safariBackgroundDies}`,
+    'declarativeNetRequest.getAvailableStaticRuleCount': `Safari implements the blocking core of declarativeNetRequest and not its rule-budget queries. ${safariBackgroundDies}`,
+    'declarativeNetRequest.getDisabledRuleIds': `Safari cannot disable individual static rules, so it has nothing to report here. ${safariBackgroundDies}`,
+    'declarativeNetRequest.updateStaticRules': `Safari cannot toggle individual static rules, only whole rulesets through updateEnabledRulesets. ${safariBackgroundDies}`,
+    'declarativeNetRequest.testMatchOutcome': `Safari has no rule-matching test harness, which is a Chrome debugging aid. ${safariBackgroundDies}`,
+    'declarativeNetRequest.onRuleMatchedDebug': `Safari raises no rule-match debug event, which Chrome offers to unpacked extensions only. ${safariBackgroundDies}`,
+    'tabs.group': `Safari has no tab groups at all, so there is no group to move a tab into. ${safariBackgroundDies}`,
+    'tabs.ungroup': `Safari has no tab groups at all, so there is no group to take a tab out of. ${safariBackgroundDies}`,
+    'webNavigation.onCreatedNavigationTarget': `Safari reports the main navigation events only, and this one is not among them. ${safariBackgroundDies}`,
+    'webNavigation.onHistoryStateUpdated': `Safari reports the main navigation events only, so a History API navigation goes unannounced. ${safariBackgroundDies}`,
+    'webNavigation.onReferenceFragmentUpdated': `Safari reports the main navigation events only, so a fragment change goes unannounced. ${safariBackgroundDies}`,
+    'webNavigation.onTabReplaced': `Safari reports the main navigation events only, and this one is not among them. ${safariBackgroundDies}`,
+    'windows.onBoundsChanged': `Safari raises no event when a window is moved or resized. ${safariBackgroundDies}`
+};
+function safariMemberUnsupported(file, api, member, kind) {
+    const guard = 'call' === kind ? `chrome.${api}.${member}?.()` : `chrome.${api}.${member}?.`;
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} ${pintor.underline(file)} calls chrome.${api}.${member}, which Safari does not have.`);
+    lines.push(safariMissingMemberDetails[`${api}.${member}`] || `Safari ships chrome.${api} without this member. ${safariBackgroundDies}`);
+    lines.push(`Safari has ${pintor.blue(`chrome.${api}`)} itself, so a guard on the namespace does not help. Move the call behind a build-time branch on ${pintor.blue('import.meta.env.EXTENSION_PUBLIC_BROWSER')}, or guard it with ${pintor.yellow(guard)}.`);
+    return lines.join('\n');
+}
+function geckoActionUnsupportedOnMv2(file) {
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} ${pintor.underline(file)} uses chrome.action, which Manifest V2 does not have on Firefox.`);
+    lines.push("Firefox Manifest V2 exposes the toolbar button as browserAction, and addons-linter flags the call as UNSUPPORTED_API.");
+    lines.push(`Use browserAction behind a build-time branch on ${pintor.blue('import.meta.env.EXTENSION_PUBLIC_BROWSER')}, or declare Manifest V3 for Firefox with ${pintor.yellow('firefox:manifest_version')}.`);
+    return lines.join('\n');
+}
+function webkitUnsupportedKeysDropped(browser, dropped) {
+    const count = dropped.length;
+    const lines = [];
+    lines.push(`${messaging_prefix('warn')} Safari has no support for ${String(count)} manifest ${1 === count ? 'key' : 'keys'} this build inherited from its Chromium manifest, so the ${pintor.blue(browser)} build dropped ${1 === count ? 'it' : 'them'}.`);
+    for (const entry of dropped)lines.push(`${pintor.yellow(entry.path)} ${pintor.gray(entry.reason)}`);
+    lines.push(`Every key above is inert on Safari, so the built app lost nothing it could have run. Declare a Safari-only replacement with the ${pintor.yellow('safari:')} prefix if you have one.`);
+    return lines.join('\n');
+}
+const UNSUPPORTED_TOP_LEVEL_KEYS = {
+    side_panel: 'Safari has no side panel surface',
+    sandbox: 'Safari cannot run sandboxed extension pages',
+    user_scripts: 'Safari has no userScripts API',
+    omnibox: 'Safari has no omnibox keyword API',
+    chrome_settings_overrides: 'Safari lets no extension override these settings',
+    tts_engine: 'Safari has no speech engine API',
+    file_browser_handlers: 'ChromeOS only',
+    input_components: 'ChromeOS only',
+    cross_origin_embedder_policy: 'Safari reads no COEP key from a manifest',
+    cross_origin_opener_policy: 'Safari reads no COOP key from a manifest',
+    requirements: 'Chrome Web Store only',
+    oauth2: 'Safari has no identity API to consume it',
+    nacl_modules: 'Native Client is Chrome only',
+    replacement_web_app: 'Chrome Web Store only',
+    offline_enabled: 'Chrome Web Store only',
+    differential_fingerprint: 'Chrome Web Store only',
+    incognito: 'Safari always runs extensions in spanning mode and ignores the declared value'
+};
+const UNSUPPORTED_PERMISSIONS = new Set([
+    'accessibilityFeatures.modify',
+    'accessibilityFeatures.read',
+    'audio',
+    'background',
+    'bookmarks',
+    'browsingData',
+    'certificateProvider',
+    'clipboardRead',
+    'contentSettings',
+    'debugger',
+    'declarativeContent',
+    'desktopCapture',
+    'documentScan',
+    'downloads',
+    'enterprise.deviceAttributes',
+    'enterprise.platformKeys',
+    'experimental',
+    'favicon',
+    'fileSystemProvider',
+    'fontSettings',
+    'gcm',
+    'geolocation',
+    'history',
+    'identity',
+    'identity.email',
+    'idle',
+    'management',
+    'notifications',
+    'offscreen',
+    'pageCapture',
+    'platformKeys',
+    'power',
+    'printerProvider',
+    'privacy',
+    'processes',
+    'proxy',
+    'readingList',
+    'search',
+    'sessions',
+    'sidePanel',
+    'system.cpu',
+    'system.display',
+    'system.memory',
+    'system.storage',
+    'systemLog',
+    'tabCapture',
+    'tabGroups',
+    'topSites',
+    'tts',
+    'ttsEngine',
+    'userScripts',
+    'vpnProvider',
+    'wallpaper',
+    'webAuthenticationProxy',
+    'webRequestBlocking'
+]);
+const PERMISSION_LISTS = [
+    'permissions',
+    'optional_permissions'
+];
+const UNSUPPORTED_OPTIONS_UI_KEYS = {
+    open_in_tab: 'Safari always opens the options page in a tab'
+};
+function isPlainObject(value) {
+    return !!value && 'object' == typeof value && !Array.isArray(value);
+}
+function dropWebkitUnsupportedKeys(manifest, browser) {
+    const dropped = [];
+    if (!isWebkitBasedBrowser(String(browser))) return {
+        manifest,
+        dropped
+    };
+    const next = {
+        ...manifest
+    };
+    for (const [key, reason] of Object.entries(UNSUPPORTED_TOP_LEVEL_KEYS))if (key in next) {
+        delete next[key];
+        dropped.push({
+            path: key,
+            reason
+        });
+    }
+    for (const listName of PERMISSION_LISTS){
+        const list = next[listName];
+        if (!Array.isArray(list)) continue;
+        const kept = list.filter((entry)=>{
+            if ('string' != typeof entry || !UNSUPPORTED_PERMISSIONS.has(entry)) return true;
+            dropped.push({
+                path: `${listName}.${entry}`,
+                reason: `Safari has no ${entry} API`
+            });
+            return false;
+        });
+        if (kept.length !== list.length) if (0 === kept.length) delete next[listName];
+        else next[listName] = kept;
+    }
+    const optionsUi = next.options_ui;
+    if (isPlainObject(optionsUi)) {
+        const patched = {
+            ...optionsUi
+        };
+        let changed = false;
+        for (const [key, reason] of Object.entries(UNSUPPORTED_OPTIONS_UI_KEYS))if (key in patched) {
+            delete patched[key];
+            changed = true;
+            dropped.push({
+                path: `options_ui.${key}`,
+                reason
+            });
+        }
+        if (changed) next.options_ui = patched;
+    }
+    return {
+        manifest: next,
+        dropped
+    };
+}
+const reportedDrops = new Set();
+function reportWebkitDroppedKeys(dropped, browser) {
+    if (0 === dropped.length) return;
+    const signature = `${String(browser)}\0${dropped.map((entry)=>entry.path).join(',')}`;
+    if (reportedDrops.has(signature)) return;
+    reportedDrops.add(signature);
+    humanLine(webkitUnsupportedKeysDropped(String(browser), dropped));
+}
 const manifest_cjsRequire = createRequire(import.meta.url);
 const manifestSourceStore = new WeakMap();
 function manifestSourceEntry(compilation) {
@@ -1185,12 +1525,22 @@ function getManifestContent(compilation, manifestPath) {
 function buildCanonicalManifest(manifestPath, manifest, browser, projectPath) {
     const filteredManifest = filterKeysForThisBrowser(manifest, browser);
     const forOverrides = shouldDropPageAction(filteredManifest, browser) ? dropPageAction(filteredManifest) : filteredManifest;
-    return dropMv2ObjectPolicy(dropMv2HostKeys({
+    const canonical = dropMv2ObjectPolicy(dropMv2HostKeys({
         ...forOverrides,
         ...JSON.parse(getManifestOverrides(manifestPath, forOverrides, projectPath))
     }));
+    const webkit = dropWebkitUnsupportedKeys(canonical, browser);
+    reportWebkitDroppedKeys(webkit.dropped, browser);
+    return webkit.manifest;
 }
 const IMPORT_META_URL_RUNTIME = '(function(){var h=typeof document!=="undefined"&&document.baseURI||self.location.href;try{var g=globalThis,r=(g.browser||g.chrome).runtime.getURL("/");return h.indexOf(r)===0?h:r}catch(_){return h}})()';
+function importMetaUrlForEmitPath(emitPath) {
+    const request = emitPath.replace(/\\/g, '/').replace(/^\/+/, '');
+    return `(function(){try{var g=globalThis;return (g.browser||g.chrome).runtime.getURL(${toJsStringLiteral(request)})}catch(_){return ${IMPORT_META_URL_RUNTIME}}})()`;
+}
+function toJsStringLiteral(value) {
+    return JSON.stringify(value).replace(/[<>\u007f-\uffff]/g, (char)=>`\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}
 function resolveProcessShim() {
     const candidate = __rspack_external_node_path_806ed179.join(__rspack_import_meta_dirname__, '..', 'runtime', 'process-shim.cjs');
     try {
@@ -1303,7 +1653,6 @@ class EnvPlugin {
         filteredEnvVars['import.meta.dirname'] = 'undefined';
         filteredEnvVars['import.meta.filename'] = 'undefined';
         filteredEnvVars.global = 'globalThis';
-        filteredEnvVars['import.meta.url'] = IMPORT_META_URL_RUNTIME;
         const injectedCount = Object.keys(filteredEnvVars).filter((k)=>k.startsWith('process.env.EXTENSION_PUBLIC_')).length;
         if (isDebug()) console.log(envInjectedPublicVars(injectedCount));
         const processShim = resolveProcessShim();
@@ -1312,6 +1661,11 @@ class EnvPlugin {
             filteredEnvVars.process = '({env:{},argv:[],platform:"browser",browser:true,versions:{},nextTick:function(cb){Promise.resolve().then(function(){cb()})}})';
         }
         new DefinePlugin(filteredEnvVars).apply(compiler);
+        const importMetaUrl = new DefinePlugin({
+            'import.meta.url': IMPORT_META_URL_RUNTIME
+        });
+        importMetaUrl.affectedHooks = 'thisCompilation';
+        importMetaUrl.apply(compiler);
         if (processShim) new ProvidePlugin({
             process: processShim
         }).apply(compiler);
@@ -2577,294 +2931,8 @@ function getResolvedManifestFieldsData(options) {
         return data;
     }
 }
-let preact_userMessageDelivered = false;
-function isUsingPreact(projectPath) {
-    if (hasDependency(projectPath, 'preact')) {
-        if (!preact_userMessageDelivered) {
-            if (isDebug()) console.log(`${messaging_prefix('debug')} ${messages_isUsingIntegration('Preact')}`);
-            preact_userMessageDelivered = true;
-        }
-        return true;
-    }
-    return false;
-}
-async function maybeUsePreact(projectPath) {
-    if (!isUsingPreact(projectPath)) return;
-    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
-    const resolveFromProject = (id)=>{
-        try {
-            return requireFromProject.resolve(id);
-        } catch  {
-            return;
-        }
-    };
-    const preactPkgJson = resolveFromProject('preact/package.json');
-    const preactDir = preactPkgJson ? __rspack_external_node_path_806ed179.dirname(preactPkgJson) : void 0;
-    const preactCompat = resolveFromProject('preact/compat');
-    const preactTestUtils = resolveFromProject('preact/test-utils');
-    const preactJsxRuntime = resolveFromProject('preact/jsx-runtime');
-    const preactJsxDevRuntime = resolveFromProject('preact/jsx-dev-runtime');
-    const alias = {};
-    if (preactJsxRuntime) alias['preact/jsx-runtime'] = preactJsxRuntime;
-    if (preactJsxDevRuntime) alias['preact/jsx-dev-runtime'] = preactJsxDevRuntime;
-    if (preactDir) alias.preact = preactDir;
-    if (preactCompat) {
-        alias.react = preactCompat;
-        alias['react-dom'] = preactCompat;
-    }
-    if (preactTestUtils) alias['react-dom/test-utils'] = preactTestUtils;
-    if (preactJsxRuntime) alias['react/jsx-runtime'] = preactJsxRuntime;
-    if (preactJsxDevRuntime) alias['react/jsx-dev-runtime'] = preactJsxDevRuntime;
-    return {
-        plugins: [],
-        loaders: void 0,
-        alias
-    };
-}
-let react_userMessageDelivered = false;
-function isUsingReact(projectPath) {
-    if (hasDependency(projectPath, 'react')) {
-        if (!react_userMessageDelivered) {
-            if (isDebug()) console.log(`${messaging_prefix('debug')} ${messages_isUsingIntegration('React')}`);
-            react_userMessageDelivered = true;
-        }
-        return true;
-    }
-    return false;
-}
-async function maybeUseReact(projectPath, options = {}) {
-    if (!isUsingReact(projectPath)) return;
-    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
-    let reactPath;
-    let reactDomPath;
-    let reactDomClientPath;
-    let jsxRuntimePath;
-    let jsxDevRuntimePath;
-    try {
-        reactPath = requireFromProject.resolve('react');
-    } catch  {}
-    try {
-        reactDomPath = requireFromProject.resolve('react-dom');
-    } catch  {}
-    try {
-        reactDomClientPath = requireFromProject.resolve('react-dom/client');
-    } catch  {}
-    try {
-        jsxRuntimePath = requireFromProject.resolve('react/jsx-runtime');
-    } catch  {}
-    try {
-        jsxDevRuntimePath = requireFromProject.resolve('react/jsx-dev-runtime');
-    } catch  {}
-    const alias = {};
-    if (reactPath) alias.react$ = reactPath;
-    if (reactDomPath) alias['react-dom$'] = reactDomPath;
-    if (reactDomClientPath) alias['react-dom/client'] = reactDomClientPath;
-    if (jsxRuntimePath) alias['react/jsx-runtime'] = jsxRuntimePath;
-    if (jsxDevRuntimePath) alias['react/jsx-dev-runtime'] = jsxDevRuntimePath;
-    if (true === options.disableRefresh) return {
-        plugins: [],
-        loaders: void 0,
-        alias
-    };
-    resolveOptionalContractPackageWithoutInstall({
-        contractId: 'react-refresh',
-        projectPath,
-        dependencyId: 'react-refresh'
-    });
-    const ReactRefreshPlugin = loadOptionalContractModuleWithoutInstall({
-        contractId: 'react-refresh',
-        projectPath,
-        dependencyId: '@rspack/plugin-react-refresh',
-        moduleAdapter: (mod)=>mod && (mod.default || mod.ReactRefreshRspackPlugin) || mod
-    });
-    const reactPlugins = [
-        new ReactRefreshPlugin({
-            overlay: false,
-            ...void 0 === options.refreshExclude ? {} : {
-                exclude: options.refreshExclude
-            }
-        })
-    ];
-    return {
-        plugins: reactPlugins,
-        loaders: void 0,
-        alias
-    };
-}
-let solid_userMessageDelivered = false;
-function isUsingSolid(projectPath) {
-    if (hasDependency(projectPath, 'solid-js')) {
-        if (!solid_userMessageDelivered) {
-            if (isDebug()) console.log(`${messaging_prefix('debug')} ${messages_isUsingIntegration('Solid')}`);
-            solid_userMessageDelivered = true;
-        }
-        return true;
-    }
-    return false;
-}
-async function maybeUseSolid(projectPath) {
-    if (!isUsingSolid(projectPath)) return;
-    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
-    const resolveFromProject = (id)=>{
-        try {
-            return requireFromProject.resolve(id);
-        } catch  {
-            return;
-        }
-    };
-    const adapter = resolveDevelopDistFile('solid-jsx-runtime');
-    const hyperscript = resolveFromProject('solid-js/h');
-    const alias = {
-        'solid-js/jsx-runtime$': adapter,
-        'solid-js/jsx-dev-runtime$': adapter
-    };
-    if (hyperscript) alias['solid-js/h$'] = hyperscript;
-    return {
-        plugins: [],
-        loaders: void 0,
-        alias
-    };
-}
-let load_loader_options_userMessageDelivered = false;
-function resolveLoaderConfigPath(projectPath, framework) {
-    const candidates = [
-        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.ts`),
-        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.mts`),
-        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.js`),
-        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.mjs`)
-    ];
-    return candidates.find((p)=>__rspack_external_node_fs_1b05aee1.existsSync(p)) || null;
-}
-async function loadLoaderOptions(projectPath, framework) {
-    const configPath = resolveLoaderConfigPath(projectPath, framework);
-    if (configPath) {
-        if (!load_loader_options_userMessageDelivered && isDebug()) {
-            const display = __rspack_external_node_path_806ed179.basename(configPath);
-            console.log(isUsingCustomLoader(display));
-            load_loader_options_userMessageDelivered = true;
-        }
-        try {
-            const module = await import(pathToFileURL(configPath).href);
-            return module.default || module;
-        } catch (err) {
-            const error = err;
-            console.error(`Error loading ${framework} loader options: ${error.message}`);
-            throw err;
-        }
-    }
-    return null;
-}
-let vue_userMessageDelivered = false;
-function isUsingVue(projectPath) {
-    const using = hasDependency(projectPath, 'vue');
-    if (using && !vue_userMessageDelivered) {
-        if (isDebug()) console.log(`${messaging_prefix('debug')} ${messages_isUsingIntegration('Vue')}`);
-        vue_userMessageDelivered = true;
-    }
-    return using;
-}
-function resolveVueBundlerEntry(requireFromProject, id) {
-    try {
-        const manifestPath = requireFromProject.resolve(`${id}/package.json`);
-        const manifest = JSON.parse(__rspack_external_node_fs_1b05aee1.readFileSync(manifestPath, 'utf8'));
-        if ('string' == typeof manifest.module && manifest.module) {
-            const entry = __rspack_external_node_path_806ed179.join(__rspack_external_node_path_806ed179.dirname(manifestPath), manifest.module);
-            if (__rspack_external_node_fs_1b05aee1.existsSync(entry)) return entry;
-        }
-    } catch  {}
-    try {
-        return requireFromProject.resolve(id);
-    } catch  {
-        return;
-    }
-}
-async function maybeUseVue(projectPath, mode = 'development') {
-    if (!isUsingVue(projectPath)) return;
-    const vueLoaderPath = await ensureOptionalContractPackageResolved({
-        contractId: 'vue',
-        projectPath,
-        dependencyId: 'vue-loader'
-    });
-    const VueLoaderPlugin = await ensureOptionalContractModuleLoaded({
-        contractId: 'vue',
-        projectPath,
-        dependencyId: 'vue-loader',
-        moduleAdapter: (mod)=>mod?.VueLoaderPlugin || mod?.default?.VueLoaderPlugin
-    });
-    const customOptions = await loadLoaderOptions(projectPath, 'vue');
-    const defaultLoaders = [
-        {
-            test: /\.vue$/,
-            loader: vueLoaderPath,
-            options: {
-                experimentalInlineMatchResource: true,
-                ...customOptions || {}
-            },
-            include: projectPath,
-            exclude: /node_modules/
-        }
-    ];
-    const isProd = 'production' === mode;
-    const defaultPlugins = [
-        new VueLoaderPlugin(),
-        new DefinePlugin({
-            __VUE_OPTIONS_API__: JSON.stringify(true),
-            __VUE_PROD_DEVTOOLS__: JSON.stringify(!isProd),
-            __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: JSON.stringify(!isProd)
-        })
-    ];
-    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
-    const resolveFromProject = (id)=>resolveVueBundlerEntry(requireFromProject, id);
-    const alias = {};
-    const vuePath = resolveFromProject('vue');
-    const vueRuntimeDom = resolveFromProject('@vue/runtime-dom');
-    const vueRuntimeCore = resolveFromProject('@vue/runtime-core');
-    const vueShared = resolveFromProject('@vue/shared');
-    if (vuePath) alias.vue$ = vuePath;
-    if (vueRuntimeDom) alias['@vue/runtime-dom'] = vueRuntimeDom;
-    if (vueRuntimeCore) alias['@vue/runtime-core'] = vueRuntimeCore;
-    if (vueShared) alias['@vue/shared'] = vueShared;
-    return {
-        plugins: defaultPlugins,
-        loaders: defaultLoaders,
-        alias
-    };
-}
-function isUsingJsxFramework(projectPath) {
-    return isUsingReact(projectPath) || isUsingPreact(projectPath) || isUsingSolid(projectPath) || isUsingVue(projectPath);
-}
-function getJsxImportSource(projectPath) {
-    if (isUsingSolid(projectPath)) return 'solid-js';
-    if (isUsingPreact(projectPath) && !isUsingReact(projectPath)) return 'preact';
-    if (isUsingVue(projectPath) && !isUsingReact(projectPath) && !isUsingPreact(projectPath)) return 'vue';
-    return 'react';
-}
-function swcParserForFile(resourcePath, jsxInPlainJs) {
-    const clean = String(resourcePath || '').split('?')[0];
-    const ext = __rspack_external_node_path_806ed179.extname(clean).toLowerCase();
-    if ('.tsx' === ext || '.mtsx' === ext) return {
-        syntax: "typescript",
-        tsx: true,
-        dynamicImport: true
-    };
-    if ('.ts' === ext || '.mts' === ext || '.cts' === ext) return {
-        syntax: "typescript",
-        tsx: false,
-        dynamicImport: true
-    };
-    if ('.jsx' === ext || '.mjsx' === ext) return {
-        syntax: "ecmascript",
-        jsx: true,
-        dynamicImport: true
-    };
-    return {
-        syntax: "ecmascript",
-        jsx: jsxInPlainJs,
-        dynamicImport: true
-    };
-}
 let svelte_userMessageDelivered = false;
-function svelte_resolveFromProject(id, projectPath) {
+function resolveFromProject(id, projectPath) {
     for (const base of [
         projectPath,
         process.cwd()
@@ -2921,10 +2989,10 @@ async function maybeUseSvelte(projectPath, mode) {
             }
         }
     ];
-    const sveltePackageJson = svelte_resolveFromProject('svelte/package.json', projectPath);
+    const sveltePackageJson = resolveFromProject('svelte/package.json', projectPath);
     const sveltePackageRoot = sveltePackageJson ? __rspack_external_node_path_806ed179.dirname(sveltePackageJson) : void 0;
     const resolveClientSubpath = (relative)=>{
-        const direct = svelte_resolveFromProject(`svelte/${relative}`, projectPath);
+        const direct = resolveFromProject(`svelte/${relative}`, projectPath);
         if (direct) return direct;
         if (!sveltePackageRoot) return;
         const fromRoot = __rspack_external_node_path_806ed179.join(sveltePackageRoot, relative);
@@ -3531,14 +3599,28 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
     var connectFailures = 0;
     var MAX_QUEUE = 1000;
     var MAX_RESULT_BYTES = 256 * 1024;
+    // Where error frames are parked so a context that dies before its socket
+    // opens does not take them along. Capped, and old entries are dropped.
+    var PENDING_ERRORS_KEY = "__extjsPendingErrors";
+    var MAX_PENDING_ERRORS = 20;
+    var PENDING_ERROR_TTL = 300000;
 
     function nowId() {
       return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
     }
 
+    // The extension's own URL scheme names the engine outright, which beats a
+    // user agent where Chrome and Safari both say "Safari".
     function engineName() {
       try {
-        return (typeof navigator !== "undefined" && /firefox/i.test(navigator.userAgent)) ? "firefox" : "chromium";
+        var scheme = (typeof location !== "undefined" && location.protocol) || "";
+        if (scheme.indexOf("safari-web-extension") === 0) return "webkit";
+        if (scheme.indexOf("moz-extension") === 0) return "firefox";
+        if (scheme.indexOf("chrome-extension") === 0) return "chromium";
+        var ua = (typeof navigator !== "undefined" && navigator.userAgent) || "";
+        if (/firefox/i.test(ua)) return "firefox";
+        if (/safari/i.test(ua) && !/chrome|chromium|edg/i.test(ua)) return "webkit";
+        return "chromium";
       } catch (e) { return "chromium"; }
     }
 
@@ -3687,7 +3769,7 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
                 // MV3 forbids eval of strings in the SW/extension pages and
                 // rejects 'unsafe-eval'. Surface it honestly with an alternative.
                 if (/Content Security Policy|unsafe-eval/i.test(msg)) {
-                  replyErr(cmdId, "Unsupported", "eval is blocked in the MV3 service worker by CSP. Use --context page --tab <id> (eval runs in the page's MAIN world), or run on an MV2/Firefox build. Engine: " + engineName());
+                  replyErr(cmdId, "Unsupported", "eval is blocked in the extension background by CSP, which allows no unsafe-eval. Use --context page --tab <id> (eval runs in the page's MAIN world), or run on a build whose CSP permits it. Engine: " + engineName());
                 } else {
                   replyErr(cmdId, (e && e.name) || "EvalError", msg);
                 }
@@ -3837,6 +3919,11 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
             try { chrome.runtime.openOptionsPage(function () { replyOk(cmdId, {opened: "options"}); }); }
             catch (e) { replyErr(cmdId, "Unsupported", "openOptionsPage: " + e); }
           } else if (surface === "sidebar") {
+            // The two member reads below are exactly what the Safari
+            // unsupported-API scan looks for, and this runtime is prepended to
+            // the background asset at PROCESS_ASSETS_STAGE_REPORT + 101, after
+            // that scan runs at SUMMARIZE + 1. Move the injection earlier and
+            // every Safari dev session warns about this line.
             if (chrome.sidePanel && chrome.sidePanel.open && chrome.windows) {
               chrome.windows.getCurrent(function (w) {
                 nsCall("sidePanel", "open", [{windowId: w.id}], function (err) {
@@ -4289,6 +4376,80 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
         }
       }
       if (queue.length < MAX_QUEUE) queue.push(frame);
+      parkPendingError(frame);
+    }
+
+    // The queue above lives in this context's memory only, so a background
+    // that throws while it evaluates dies with the error still queued: the
+    // socket has not finished its handshake yet. Park error frames in
+    // extension storage too, where the NEXT context to connect can ship them.
+    // Best effort by construction: the write is asynchronous, so a teardown
+    // can cut it before the browser records anything.
+    var parkedErrors = [];
+    function storageLocalArea() {
+      try {
+        var ns = (g.chrome && g.chrome.storage) || (g.browser && g.browser.storage);
+        var area = ns && ns.local;
+        if (!area || typeof area.get !== "function" || typeof area.set !== "function") return null;
+        return area;
+      } catch (e) { return null; }
+    }
+    function parkPendingError(frame) {
+      if (open) return;
+      if (!frame || frame.type !== "log" || !frame.event || frame.event.level !== "error") return;
+      var area = storageLocalArea();
+      if (!area) return;
+      // The whole list is rewritten on every park, so two errors in one turn
+      // cannot lose each other to a read-modify-write, and the cap holds.
+      parkedErrors.push(frame);
+      while (parkedErrors.length > MAX_PENDING_ERRORS) parkedErrors.shift();
+      var items = {};
+      items[PENDING_ERRORS_KEY] = parkedErrors;
+      try { area.set(items, noopLastError); } catch (e) {
+        // Ignore
+      }
+    }
+    function parkedHere(id) {
+      for (var i = 0; i < parkedErrors.length; i++) {
+        var ev = parkedErrors[i] && parkedErrors[i].event;
+        if (ev && ev.id === id) return true;
+      }
+      return false;
+    }
+    // Ship what an earlier context parked and never got to send. Entries from
+    // another build (a different instance id) or from an older run are dropped,
+    // and the key is cleared on read so one failure is reported once.
+    function flushPendingErrors() {
+      var area = storageLocalArea();
+      if (!area) return;
+      var read = false;
+      function onRead(res) {
+        if (read) return;
+        read = true;
+        var list = res && res[PENDING_ERRORS_KEY];
+        if (!list || !list.length) return;
+        try {
+          if (typeof area.remove === "function") area.remove(PENDING_ERRORS_KEY, noopLastError);
+        } catch (e) {
+          // Ignore
+        }
+        var now = Date.now();
+        for (var i = 0; i < list.length; i++) {
+          var frame = list[i];
+          var ev = frame && frame.event;
+          if (!ev || ev.runId !== INSTANCE_ID) continue;
+          // This context parked it, so the queue flush above already has it.
+          if (parkedHere(ev.id)) continue;
+          if (typeof ev.timestamp !== "number" || now - ev.timestamp > PENDING_ERROR_TTL) continue;
+          send(frame);
+        }
+      }
+      try {
+        var ret = area.get(PENDING_ERRORS_KEY, function (res) { noopLastError(); onRead(res); });
+        if (ret && typeof ret.then === "function") ret.then(onRead, function () {});
+      } catch (e) {
+        // Ignore
+      }
     }
 
     // The baked PORT is a snapshot of an ephemeral port. After a dev-server
@@ -4342,6 +4503,9 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
           // Ignore
         }
         flush();
+        // Hello went first and this context's own queue is out; now replay any
+        // error a previous context parked before it died.
+        flushPendingErrors();
       };
       socket.onmessage = function (ev) {
         var frame;
@@ -4809,10 +4973,12 @@ class InjectBridgeProducer {
                 name: InjectBridgeProducer.name,
                 stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT + 101
             }, ()=>{
-                if (!compilation.getAsset(CONTROL_PORT_ASSET_NAME)) compilation.emitAsset(CONTROL_PORT_ASSET_NAME, new core_sources.RawSource(JSON.stringify({
+                const controlAsset = new core_sources.RawSource(JSON.stringify({
                     port: controlPort,
                     instanceId
-                })));
+                }));
+                if (compilation.getAsset(CONTROL_PORT_ASSET_NAME)) compilation.updateAsset(CONTROL_PORT_ASSET_NAME, controlAsset);
+                else compilation.emitAsset(CONTROL_PORT_ASSET_NAME, controlAsset);
                 for (const asset of compilation.getAssets()){
                     if (!BACKGROUND_ASSET.test(asset.name)) continue;
                     const original = asset.source.source().toString();
@@ -6756,16 +6922,10 @@ class TraceRun {
 async function compileRuntimeLoadedFiles(compilation, compiler, requests) {
     if (0 === requests.length) return [];
     const before = new Set(compilation.getAssets().map((asset)=>asset.name));
-    for (const format of [
-        'module',
-        'classic'
-    ]){
-        const group = requests.filter((request)=>request.format === format);
-        if (0 !== group.length) await compileTracedFiles({
-            compilation,
-            compiler
-        }, format, group);
-    }
+    for (const request of requests)await compileTracedFile({
+        compilation,
+        compiler
+    }, request);
     return compilation.getAssets().map((asset)=>asset.name).filter((name)=>!before.has(name));
 }
 function planTracedFile(opts) {
@@ -6849,21 +7009,24 @@ function isFile(candidate) {
         return false;
     }
 }
-async function compileTracedFiles(host, format, requests) {
+async function compileTracedFile(host, request) {
     const { compilation, compiler } = host;
-    const isModule = 'module' === format;
-    const chunkLoadingFor = (context)=>isModule ? 'import' : 'importScripts' === context ? "import-scripts" : 'jsonp';
-    const entries = requests.map((request)=>new EntryPlugin(compiler.context, request.sourcePath, {
-            name: request.emitPath.replace(/\.[^./]+$/, ''),
-            filename: request.emitPath,
-            chunkLoading: chunkLoadingFor(request.context),
-            ...isModule ? {
-                library: {
-                    type: 'module'
-                }
-            } : {}
-        }));
-    const child = compilation.createChildCompiler(`${TraceRuntimeLoadedFiles.name}:${format}`, {
+    const isModule = 'module' === request.format;
+    const chunkLoading = isModule ? 'import' : 'importScripts' === request.context ? "import-scripts" : 'jsonp';
+    const entry = new EntryPlugin(compiler.context, request.sourcePath, {
+        name: request.emitPath.replace(/\.[^./]+$/, ''),
+        filename: request.emitPath,
+        chunkLoading,
+        ...isModule ? {
+            library: {
+                type: 'module'
+            }
+        } : {}
+    });
+    const importMetaUrl = new DefinePlugin({
+        'import.meta.url': importMetaUrlForEmitPath(request.emitPath)
+    });
+    const child = compilation.createChildCompiler(`${TraceRuntimeLoadedFiles.name}:${request.format}`, {
         filename: '[name].js',
         module: isModule,
         iife: false,
@@ -6873,8 +7036,11 @@ async function compileTracedFiles(host, format, requests) {
             type: 'module'
         } : void 0,
         clean: false
-    }, entries);
-    for (const type of new Set(requests.map((request)=>chunkLoadingFor(request.context))))new core_javascript.EnableChunkLoadingPlugin(type).apply(child);
+    }, [
+        entry,
+        importMetaUrl
+    ]);
+    new core_javascript.EnableChunkLoadingPlugin(chunkLoading).apply(child);
     if (isModule) new library.EnableLibraryPlugin('module').apply(child);
     child.options.entry = {};
     child.options.optimization = {
@@ -6890,7 +7056,7 @@ async function compileTracedFiles(host, format, requests) {
     await new Promise((resolve)=>{
         child.runAsChild((error, _entries, childCompilation)=>{
             if (error) {
-                const failure = new core_WebpackError(`Compiling runtime-loaded ${requests.map((request)=>request.emitPath).join(', ')} failed: ${error.message}`);
+                const failure = new core_WebpackError(`Compiling runtime-loaded ${request.emitPath} failed: ${error.message}`);
                 failure.name = 'RuntimeLoadedFileCompileFailed';
                 compilation.errors.push(failure);
             }
@@ -9537,17 +9703,17 @@ function isManagedSchemaFeature(feature) {
 function isCriticalJsonFeature(feature) {
     return feature.startsWith('declarative_net_request') || isManagedSchemaFeature(feature);
 }
-function isPlainObject(value) {
+function json_validation_isPlainObject(value) {
     return 'object' == typeof value && null !== value && !Array.isArray(value);
 }
 function getDnrRuleRejection(rule) {
-    if (!isPlainObject(rule)) return 'the rule is not an object';
+    if (!json_validation_isPlainObject(rule)) return 'the rule is not an object';
     const id = rule.id;
     if ('number' != typeof id || !Number.isInteger(id) || id < 1) return 'the rule id is not a positive integer';
     const action = rule.action;
-    if (!isPlainObject(action)) return 'the rule has no action object';
+    if (!json_validation_isPlainObject(action)) return 'the rule has no action object';
     if ('string' != typeof action.type || 0 === action.type.length) return 'the rule action has no type';
-    if (!isPlainObject(rule.condition)) return 'the rule has no condition object';
+    if (!json_validation_isPlainObject(rule.condition)) return 'the rule has no condition object';
 }
 function getDnrRuleSoftIssue(rule) {
     const priority = rule.priority;
@@ -10060,99 +10226,6 @@ class LocalesPlugin {
         });
     }
 }
-function serverRestartRequiredFromManifestError(fileAdded, fileRemoved) {
-    const lines = [];
-    lines.push("Entrypoint references changed.");
-    if (fileRemoved) lines.push(`${pintor.gray('EXPECTED')} ${pintor.underline(fileRemoved)}`);
-    if (fileAdded) lines.push(`${pintor.gray('GOT')} ${pintor.underline(fileAdded)}`);
-    lines.push("Restart the dev server to pick up changes to manifest entrypoints.");
-    return lines.join('\n');
-}
-function legacyManifestPathWarning(field, legacyPath, modernPath) {
-    const lines = [];
-    lines.push(`${messaging_prefix('warn')} The ${pintor.blue(field)} field uses a deprecated scaffold path.`);
-    lines.push(`${pintor.gray('PATH')} ${pintor.underline(legacyPath)}`);
-    lines.push(`Point it at ${pintor.underline(modernPath)}, Extension.js already emits the page there.`);
-    return lines.join('\n');
-}
-function fatalManifestShapeFixed(field, detail) {
-    const lines = [];
-    lines.push(`${messaging_prefix('warn')} Repaired the ${pintor.blue(field)} field, which Chrome refuses to load the extension over.`);
-    lines.push(`${pintor.gray('REASON')} ${pintor.underline(detail)}`);
-    lines.push(`Fix the field in your ${pintor.blue('manifest.json')} file.`);
-    return lines.join('\n');
-}
-function invalidThemeValue(field, detail, value) {
-    const lines = [];
-    lines.push(`Check the ${pintor.yellow(field)} field in your ${pintor.yellow('manifest.json')} file.`);
-    lines.push(detail);
-    lines.push(`Chrome rejects the whole extension when this value is malformed.\nThe build stops here to protect you.`);
-    lines.push('');
-    lines.push(`${pintor.red('INVALID VALUE')} ${value}`);
-    return lines.join('\n');
-}
-function themeNotSupportedByBrowser(browser) {
-    const lines = [];
-    lines.push(`${messaging_prefix('warn')} ${pintor.blue(browser)} does not support the ${pintor.yellow('theme')} field.`);
-    lines.push("The field ships unchanged in the manifest and Safari ignores it.");
-    return lines.join('\n');
-}
-function missingGeckoDataCollectionPermissions() {
-    const lines = [];
-    lines.push(`${messaging_prefix('warn')} addons.mozilla.org requires ${pintor.blue('browser_specific_settings.gecko.data_collection_permissions')} for new add-ons.`);
-    lines.push(`Declare ${pintor.blue('{"required": ["none"]}')} if this extension transmits no data.`);
-    lines.push(`See ${pintor.underline('https://extensionworkshop.com/documentation/develop/firefox-builtin-data-consent/')} for details.`);
-    return lines.join('\n');
-}
-function manifestInvalidError(error) {
-    const lines = [];
-    lines.push(`Can't read your ${pintor.blue('manifest.json')} file.`);
-    lines.push(`${pintor.gray('REASON')} ${pintor.underline(String(error))}`);
-    lines.push("Update your manifest and try again.");
-    return lines.join('\n');
-}
-function manifestIncludeSummary(browser, manifestPath) {
-    return `${messaging_prefix('debug')} manifest include browser=${browser} path=${manifestPath}`;
-}
-function manifestEmitSuccess() {
-    return `${messaging_prefix('debug')} manifest emitted=true schemaStripped=true`;
-}
-function manifestOverridesSummary(overrideKeys, devCssStubsAdded) {
-    return `${messaging_prefix('debug')} manifest overrides keys=${String(overrideKeys)} devCssStubs=${String(devCssStubsAdded)}`;
-}
-function manifestDepsTracked(addedCount) {
-    return `${messaging_prefix('debug')} manifest deps=${String(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.`;
-}
-function vendorPrefixedKeyDropped(key, familyKey, vendor, browser) {
-    const vendorName = 'edge' === vendor ? 'Edge' : 'Chrome';
-    return `${messaging_prefix('warn')} ${pintor.yellow(key)} now applies only to ${vendorName} builds, so the ${pintor.blue(browser)} build dropped it.\nRename it to ${pintor.yellow(familyKey)} to keep it on every Chromium-based browser. Leave it as is if it's meant for ${vendorName} only.`;
-}
-function mv2SandboxPolicyDropped(browser) {
-    return `${messaging_prefix('warn')} ${pintor.blue(browser)} reads a Manifest V2 ${pintor.yellow('content_security_policy')} as one string, so the ${pintor.yellow('sandbox')} slot has nowhere to go.\nThe build wrote the ${pintor.yellow('extension_pages')} policy as that string and dropped the sandbox policy from the built manifest. Scope the object form with the chromium: prefix, or declare a Manifest V3 build for this browser.`;
-}
-function geckoSidePanelUnsupported(file) {
-    const lines = [];
-    lines.push(`${messaging_prefix('warn')} ${pintor.underline(file)} uses chrome.sidePanel, which is Chromium only.`);
-    lines.push(`Firefox opens a sidebar through the ${pintor.yellow('sidebar_action')} manifest key on every manifest version, and addons-linter flags the call as UNSUPPORTED_API.`);
-    lines.push(`Move the call behind a build-time branch on ${pintor.blue('import.meta.env.EXTENSION_PUBLIC_BROWSER')} so the Firefox bundle drops it.`);
-    return lines.join('\n');
-}
-function geckoActionUnsupportedOnMv2(file) {
-    const lines = [];
-    lines.push(`${messaging_prefix('warn')} ${pintor.underline(file)} uses chrome.action, which Manifest V2 does not have on Firefox.`);
-    lines.push("Firefox Manifest V2 exposes the toolbar button as browserAction, and addons-linter flags the call as UNSUPPORTED_API.");
-    lines.push(`Use browserAction behind a build-time branch on ${pintor.blue('import.meta.env.EXTENSION_PUBLIC_BROWSER')}, or declare Manifest V3 for Firefox with ${pintor.yellow('firefox:manifest_version')}.`);
-    return lines.join('\n');
-}
 class AddDependencies {
     dependencyList;
     constructor(dependencyList){
@@ -10333,6 +10406,71 @@ function partiallyGatedWarning(api, relative) {
     if (!note) return null;
     return `manifest.json does not declare the "${api}" permission, but ${relative} uses chrome.${api}. The dev build injects "${api}" so the same code may behave differently once packaged: ${note}. Add "${api}" to permissions in manifest.json if you read those fields.`;
 }
+const EMITTED_SCRIPT_RE = /\.[cm]?js$/;
+const MAX_SOURCE_BYTES = 1048576;
+const MAX_ASSET_BYTES = 16777216;
+const MAX_COMPRESS_BYTES = 4194304;
+function shippableText(text) {
+    if (text.length > MAX_COMPRESS_BYTES) return text;
+    try {
+        const compressed = experiments?.swc?.minifySync(text, {
+            compress: true,
+            mangle: false
+        });
+        return 'string' == typeof compressed?.code ? compressed.code : text;
+    } catch  {
+        return text;
+    }
+}
+function readEmittedScripts(compilation) {
+    const scripts = new Map();
+    let assets;
+    try {
+        assets = compilation.getAssets?.() || [];
+    } catch  {
+        return scripts;
+    }
+    for (const asset of assets)if (EMITTED_SCRIPT_RE.test(asset.name)) try {
+        const raw = asset.source.source();
+        const text = 'string' == typeof raw ? raw : raw.toString('utf-8');
+        if (text.length > MAX_ASSET_BYTES) continue;
+        scripts.set(asset.name, text);
+    } catch  {}
+    return scripts;
+}
+function readProjectSource(resource) {
+    try {
+        if (__rspack_external_node_fs_1b05aee1.statSync(resource).size > MAX_SOURCE_BYTES) return;
+        return __rspack_external_node_fs_1b05aee1.readFileSync(resource, 'utf-8');
+    } catch  {
+        return;
+    }
+}
+function emittedFilesOf(compilation, module) {
+    if (!compilation.chunkGraph) return;
+    try {
+        const files = [];
+        for (const chunk of compilation.chunkGraph.getModuleChunksIterable(module))for (const file of chunk.files || [])files.push(file);
+        return files;
+    } catch  {
+        return;
+    }
+}
+function patchWebkitBackground(manifest, browser) {
+    if (!isWebkitBasedBrowser(String(browser))) return manifest;
+    const background = manifest.background;
+    if (!background || !background.service_worker || background.scripts) return manifest;
+    const { service_worker, type, ...rest } = background;
+    return {
+        ...manifest,
+        background: {
+            ...rest,
+            scripts: [
+                service_worker
+            ]
+        }
+    };
+}
 function persistentPatchFor(manifest) {
     return 3 === manifest.manifest_version ? {} : {
         persistent: true
@@ -10360,12 +10498,16 @@ function patchBackground(manifest, browser) {
                 ...persistentPatchFor(manifest)
             }
         };
-        return {
+        const injected = {
+            ...manifest,
             background: {
                 ...manifest.background || {},
                 service_worker: 'background/service_worker.js'
             }
         };
+        return {
+            background: patchWebkitBackground(injected, browser).background
+        };
     }
     return {
         background: {
@@ -10511,87 +10653,88 @@ function patchExternallyConnectable(manifest) {
     };
     return {};
 }
+function cleanMatches(matches) {
+    return matches.map((match)=>{
+        try {
+            const url = new URL(match.replace(/^\*:\/\//, 'https://'));
+            if (match.endsWith(url.pathname)) return `${match.substring(0, match.length - url.pathname.length)}/*`;
+            if ('/' === url.pathname) return `${match}/*`;
+            return match;
+        } catch  {
+            return match;
+        }
+    });
+}
+const DEV_RUNTIME_RESOURCES = [
+    'hot/*',
+    'extension-js-control.json'
+];
+function patch_web_resources_contentScriptMatches(manifest) {
+    const scripts = manifest.content_scripts || [];
+    return Array.from(new Set(cleanMatches(scripts.flatMap((script)=>script.matches || [])))).sort();
+}
 function patchWebResourcesV2(manifest) {
-    const defaultResources = [
-        '/*.json',
-        '/*.js',
-        '/*.css',
-        '/*.scss',
-        '/*.sass',
-        '/*.less',
-        '*.styl',
-        "/scripts/*.js",
-        "/scripts/*.css",
-        '/hot/*',
-        '/*.png',
-        '/*.jpg',
-        '/*.jpeg',
-        '/*.svg',
-        '/*.gif',
-        '/*.webp',
-        '/*.ico',
-        '/*.avif',
-        '/*.wasm',
-        '/*.bin'
-    ];
     const resources = manifest.web_accessible_resources;
-    if (!resources || 0 === resources.length) return defaultResources;
-    const webResources = new Set(resources);
-    for (const resource of defaultResources)if (!webResources.has(resource)) webResources.add(resource);
+    const webResources = new Set(resources || []);
+    if (0 === patch_web_resources_contentScriptMatches(manifest).length) return Array.from(webResources);
+    for (const resource of DEV_RUNTIME_RESOURCES)webResources.add(resource);
     return Array.from(webResources);
 }
 function patchWebResourcesV3(manifest) {
-    const defaultResources = [
-        '/*.json',
-        '/*.js',
-        '/*.css',
-        '/*.scss',
-        '/*.sass',
-        '/*.less',
-        '*.styl',
-        "/scripts/*.js",
-        "/scripts/*.css",
-        '/hot/*',
-        '/*.png',
-        '/*.jpg',
-        '/*.jpeg',
-        '/*.svg',
-        '/*.gif',
-        '/*.webp',
-        '/*.ico',
-        '/*.avif',
-        '/*.wasm',
-        '/*.bin'
-    ];
+    const existing = manifest.web_accessible_resources || [];
+    const matches = patch_web_resources_contentScriptMatches(manifest);
+    if (0 === matches.length) return existing;
     return [
-        ...manifest.web_accessible_resources || [],
+        ...existing,
         {
-            resources: defaultResources,
-            matches: [
-                '<all_urls>'
-            ]
+            resources: [
+                ...DEV_RUNTIME_RESOURCES
+            ],
+            matches
         }
     ];
 }
+function patchWebResources(manifest) {
+    const patched = 3 === manifest.manifest_version ? patchWebResourcesV3(manifest) : patchWebResourcesV2(manifest);
+    if (!patched.length) return {};
+    return {
+        web_accessible_resources: patched
+    };
+}
 function findInjectedOnlyPermissionUses(compilation, declared, injected) {
     const firstOffenderByApi = new Map();
     const candidates = injected.filter((api)=>!declared.has(api));
     if (!candidates.length) return firstOffenderByApi;
-    for (const module of compilation.modules){
-        const resource = scannableSourcePath(module.resource);
-        if (!resource) continue;
-        let source;
-        try {
-            const stat = __rspack_external_fs.statSync(resource);
-            if (stat.size > 1048576) continue;
-            source = __rspack_external_fs.readFileSync(resource, 'utf-8');
-        } catch  {
-            continue;
-        }
-        for (const api of candidates){
-            if (firstOffenderByApi.has(api)) continue;
-            const useRe = new RegExp(`\\b(?:chrome|browser)\\s*\\.\\s*${api}\\b`);
-            if (useRe.test(source)) firstOffenderByApi.set(api, resource);
+    const emitted = readEmittedScripts(compilation);
+    const shipped = new Map();
+    const shippedText = (file)=>{
+        if (shipped.has(file)) return shipped.get(file);
+        const text = emitted.get(file);
+        if (void 0 === text) return;
+        const compressed = shippableText(text);
+        shipped.set(file, compressed);
+        return compressed;
+    };
+    for (const outer of compilation.modules){
+        const inner = outer.modules ? [
+            ...outer.modules
+        ] : [
+            outer
+        ];
+        for (const module of inner){
+            const resource = scannableSourcePath(module.resource);
+            if (!resource) continue;
+            const source = readProjectSource(resource);
+            if (void 0 !== source) for (const api of candidates){
+                if (firstOffenderByApi.has(api)) continue;
+                const useRe = new RegExp(`\\b(?:chrome|browser)\\s*\\.\\s*${api}\\b`);
+                if (!useRe.test(source)) continue;
+                const files = emittedFilesOf(compilation, outer);
+                if (!files || files.some((file)=>{
+                    const text = shippedText(file);
+                    return void 0 !== text && useRe.test(text);
+                })) firstOffenderByApi.set(api, resource);
+            }
         }
         if (firstOffenderByApi.size === candidates.length) break;
     }
@@ -10672,13 +10815,13 @@ class ApplyDevDefaults {
                     ...hostPermissionsPatch,
                     ...patchBackground(canonicalManifest, this.browser),
                     ...patchExternallyConnectable(canonicalManifest),
-                    web_accessible_resources: 3 === canonicalManifest.manifest_version ? patchWebResourcesV3(canonicalManifest) : patchWebResourcesV2(canonicalManifest)
+                    ...patchWebResources(canonicalManifest)
                 };
                 try {
                     const declared = new Set(canonicalManifest.permissions || []);
                     const uses = findInjectedOnlyPermissionUses(compilation, declared, injectedPermissions);
                     for (const [api, file] of uses){
-                        const relative = __rspack_external_path.relative(__rspack_external_path.dirname(this.manifestPath), file);
+                        const relative = __rspack_external_node_path_806ed179.relative(__rspack_external_node_path_806ed179.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.` : partiallyGatedWarning(api, relative) || `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', optionalPermissions.has(api) ? text + partiallyGatedNote(api) : text);
                     }
@@ -10687,7 +10830,7 @@ class ApplyDevDefaults {
                     const injectedOnlyHosts = findInjectedOnlyHostUses(compilation.modules, contentScriptMatches, declaredHostPatterns(canonicalManifest), optionalHostPatterns(canonicalManifest));
                     const hostKey = 3 === canonicalManifest.manifest_version ? 'host_permissions' : 'permissions';
                     for (const use of injectedOnlyHosts){
-                        const relative = __rspack_external_path.relative(__rspack_external_path.dirname(this.manifestPath), use.file);
+                        const relative = __rspack_external_node_path_806ed179.relative(__rspack_external_node_path_806ed179.dirname(this.manifestPath), use.file);
                         const text = use.optional ? `manifest.json only lists "${use.pattern}" under optional host permissions, but ${relative} requests ${use.url}. It works in development only because a content script matches "${use.pattern}" and the dev build grants that host as required so it can re-inject the script on save. The production build has the host only after a runtime chrome.permissions.request, so guard the request or add "${use.pattern}" to ${hostKey} in manifest.json.` : `manifest.json does not grant host access to ${use.url}, but ${relative} requests it. The dev build grants that host because a content script matches "${use.pattern}" and it re-injects the script on save. The production build has no host permission for it, so the request is subject to the server's CORS policy and is blocked when the server does not allow it. If it needs the permission, add "${requestOriginPattern(use.url, use.pattern)}" to ${hostKey} in manifest.json rather than the content-script pattern.`;
                         pushDevWarning('DevInjectedHostWarning', text);
                     }
@@ -10912,6 +11055,17 @@ function collectContentScriptAsyncChunkFiles(compilation) {
     });
     return result;
 }
+function collectPageContextEntryFiles(compilation) {
+    const result = {};
+    if ('function' != typeof compilation.entrypoints?.forEach) return result;
+    compilation.entrypoints.forEach((entry, entryName)=>{
+        if (!isPageContextEntry(String(entryName))) return;
+        const files = new Set();
+        for (const chunk of toFileArray(entry.chunks))for (const file of toFileArray(chunk.files))if (file.endsWith('.js')) files.add(unixify(file));
+        if (files.size > 0) result[String(entryName)] = Array.from(files).sort();
+    });
+    return result;
+}
 function collectContentScriptEntryImports(compilation, includeList) {
     const entryImports = {};
     const contentEntryNames = new Set(Object.keys(includeList || {}).filter((k)=>isPageContextEntry(k)));
@@ -10982,18 +11136,6 @@ function collectContentScriptEntryImports(compilation, includeList) {
     }
     return entryImports;
 }
-function cleanMatches(matches) {
-    return matches.map((match)=>{
-        try {
-            const url = new URL(match.replace(/^\*:\/\//, 'https://'));
-            if (match.endsWith(url.pathname)) return `${match.substring(0, match.length - url.pathname.length)}/*`;
-            if ('/' === url.pathname) return `${match}/*`;
-            return match;
-        } catch  {
-            return match;
-        }
-    });
-}
 function warFieldError(filePath, opts) {
     const displayPath = opts?.overrideNotFoundPath || filePath;
     const lines = [];
@@ -11036,6 +11178,14 @@ function warInvalidMatchPattern(pattern) {
     lines.push(`Update the pattern in your ${pintor.blue('manifest.json')} file. See ${pintor.underline('https://developer.chrome.com/docs/extensions/reference/manifest/web-accessible-resources#manifest_declaration')} for the format.`);
     return lines.join('\n');
 }
+function warUnreachableResource(resource, entryName) {
+    const lines = [];
+    lines.push(`${pintor.underline(entryName)} asks the extension for ${pintor.blue(resource)}, but ${pintor.blue('web_accessible_resources')} does not list it.`);
+    lines.push("The browser refuses it with a SecurityError because a content script reads extension files with the page's origin.");
+    lines.push(`Add it to ${pintor.blue('web_accessible_resources')} in ${pintor.blue('manifest.json')}, scoped to the matches that need it.`);
+    lines.push(`Learn more: ${pintor.underline('https://extension.js.org/docs/development/web-accessible-resources')}`);
+    return lines.join('\n');
+}
 function entryImportsSummary(entryCount, totalResources) {
     return `${messaging_prefix('debug')} war      entryImports entries=${String(entryCount)} resources=${String(totalResources)}`;
 }
@@ -11279,6 +11429,54 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
         v3
     };
 }
+function normalizeResourcePath(value) {
+    return String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '');
+}
+function escapeRegex(value) {
+    return value.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+}
+function globToRegex(pattern) {
+    const escaped = pattern.split('*').map((segment)=>escapeRegex(segment)).join('.*');
+    return new RegExp(`^${escaped}$`);
+}
+function isResourceCovered(declared, candidate) {
+    const target = normalizeResourcePath(candidate);
+    for (const entry of declared){
+        const pattern = normalizeResourcePath(entry);
+        if (pattern === target) return true;
+        if (pattern.includes('*')) try {
+            if (globToRegex(pattern).test(target)) return true;
+        } catch  {}
+    }
+    return false;
+}
+const GET_URL_LITERAL_PATTERN = /getURL\s*\(\s*["'`]([^"'`\n)]+)["'`]\s*\)/g;
+const MAX_SCANNED_SOURCE_BYTES = 4194304;
+function collectGetUrlLiterals(source) {
+    if (!source || source.length > MAX_SCANNED_SOURCE_BYTES) return [];
+    const found = new Set();
+    const pattern = new RegExp(GET_URL_LITERAL_PATTERN.source, 'g');
+    let match = pattern.exec(source);
+    while(match){
+        const name = normalizeResourcePath(match[1]);
+        if (name && !name.includes('${')) found.add(name);
+        match = pattern.exec(source);
+    }
+    return Array.from(found).sort();
+}
+const TOOLING_RESOURCES = new Set([
+    'manifest.json',
+    'extension-js-control.json'
+]);
+function findUnreachableRuntimeResources(options) {
+    const emitted = new Set(options.emittedAssetNames.map((name)=>normalizeResourcePath(name)));
+    return collectGetUrlLiterals(options.source).filter((name)=>{
+        if (TOOLING_RESOURCES.has(name)) return false;
+        if (name.startsWith('hot/')) return false;
+        if (!emitted.has(name)) return false;
+        return !isResourceCovered(options.declaredResources, name);
+    });
+}
 function generate_manifest_getAssetSource(compilation, filename) {
     const byGet = 'function' == typeof compilation.getAsset ? compilation.getAsset(filename) : void 0;
     const byAssets = !byGet && compilation.assets ? compilation.assets[filename] : void 0;
@@ -11306,16 +11504,16 @@ function generate_manifest_getAssetSource(compilation, filename) {
 function hasWildcardPattern(pattern) {
     return /[*?[\]]/.test(pattern);
 }
-function escapeRegex(s) {
+function generate_manifest_escapeRegex(s) {
     return s.replace(/[.+^${}()|\\]/g, '\\$&');
 }
-function globToRegex(pattern) {
-    const escaped = pattern.split('*').map((seg)=>escapeRegex(seg)).join('.*');
+function generate_manifest_globToRegex(pattern) {
+    const escaped = pattern.split('*').map((seg)=>generate_manifest_escapeRegex(seg)).join('.*');
     return new RegExp(`^${escaped}$`);
 }
 function isCoveredByExistingGlobs(existingPatterns, candidate) {
     for (const existingPattern of existingPatterns)if (hasWildcardPattern(existingPattern)) try {
-        const re = globToRegex(existingPattern);
+        const re = generate_manifest_globToRegex(existingPattern);
         if (re.test(candidate)) return true;
     } catch  {}
     return false;
@@ -11356,6 +11554,42 @@ function toCanonicalContentScriptCss(jsFile) {
     if (!/^content_scripts\/content-\d+\.js$/.test(normalized)) return;
     return normalized.replace(/\.js$/, '.css');
 }
+function declaredWarResources(manifest) {
+    const war = manifest.web_accessible_resources;
+    if (!Array.isArray(war)) return [];
+    return war.flatMap((entry)=>{
+        if ('string' == typeof entry) return [
+            entry
+        ];
+        const resources = entry.resources;
+        return Array.isArray(resources) ? resources.map((r)=>String(r)) : [];
+    });
+}
+function warnOnUnreachableResources(compilation, manifest) {
+    try {
+        const declared = declaredWarResources(manifest);
+        const emittedAssetNames = listEmittedAssetNames(compilation);
+        const entryFiles = collectPageContextEntryFiles(compilation);
+        const reported = new Set();
+        for (const [entryName, files] of Object.entries(entryFiles))for (const file of files){
+            const unreachable = findUnreachableRuntimeResources({
+                source: generate_manifest_getAssetSource(compilation, file),
+                emittedAssetNames,
+                declaredResources: declared
+            });
+            for (const resource of unreachable){
+                const key = `${entryName}:${resource}`;
+                if (reported.has(key)) continue;
+                reported.add(key);
+                compilation.warnings = compilation.warnings || [];
+                const warning = new core_WebpackError(warUnreachableResource(resource, entryName));
+                warning.name = 'UnreachableWebAccessibleResourceWarning';
+                warning.file = file;
+                compilation.warnings.push(warning);
+            }
+        }
+    } catch  {}
+}
 function generateManifestPatches(compilation, manifestPath, entryImports, browser) {
     const canonicalManifest = getManifestContent(compilation, manifestPath);
     const resolved = resolveUserDeclaredWAR(compilation, manifestPath, canonicalManifest, browser);
@@ -11495,6 +11729,7 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
                 matches: Array.from(new Set(entry.matches)).sort()
             })).sort((a, b)=>a.matches.join(',').localeCompare(b.matches.join(',')));
     } else if (webAccessibleResourcesV2.length > 0) canonicalManifest.web_accessible_resources = Array.from(new Set(webAccessibleResourcesV2)).sort();
+    warnOnUnreachableResources(compilation, canonicalManifest);
     const source = JSON.stringify(canonicalManifest, null, 2);
     const rawSource = new core_sources.RawSource(source);
     setCurrentManifestContent(compilation, source);
@@ -11674,6 +11909,22 @@ class PersistManifestToDisk {
         });
     }
 }
+function dropEdgeStoreKey(manifest, browser) {
+    if ('edge' !== String(browser)) return {
+        manifest,
+        dropped: false
+    };
+    const source = manifest;
+    if (!('key' in source)) return {
+        manifest,
+        dropped: false
+    };
+    const { key: _key, ...rest } = source;
+    return {
+        manifest: rest,
+        dropped: true
+    };
+}
 function gecko_data_collection_missingGeckoDataCollectionPermissions(manifest) {
     const bss = manifest.browser_specific_settings;
     const declaration = bss?.gecko?.data_collection_permissions;
@@ -12784,7 +13035,134 @@ function patchGeckoBackground(manifest, browser) {
         }
     };
 }
-function geckoUnsupportedApis(manifestVersion) {
+const webkitUnsupportedApis = {
+    sidePanel: safariSidePanelUnsupported,
+    offscreen: safariOffscreenUnsupported,
+    tabGroups: safariTabGroupsUnsupported,
+    management: safariManagementUnsupported,
+    userScripts: safariUserScriptsUnsupported,
+    identity: safariIdentityUnsupported,
+    notifications: safariNotificationsUnsupported,
+    omnibox: safariOmniboxUnsupported,
+    bookmarks: safariBookmarksUnsupported,
+    history: safariHistoryUnsupported,
+    downloads: safariDownloadsUnsupported,
+    idle: safariIdleUnsupported
+};
+const webkitUnsupportedMembers = [
+    {
+        api: 'action',
+        member: 'getUserSettings',
+        kind: 'call'
+    },
+    {
+        api: 'action',
+        member: 'getBadgeTextColor',
+        kind: 'call'
+    },
+    {
+        api: 'action',
+        member: 'setBadgeTextColor',
+        kind: 'call'
+    },
+    {
+        api: 'action',
+        member: 'onUserSettingsChanged',
+        kind: 'read'
+    },
+    {
+        api: 'storage',
+        member: 'managed',
+        kind: 'read'
+    },
+    {
+        api: 'runtime',
+        member: 'getContexts',
+        kind: 'call'
+    },
+    {
+        api: 'runtime',
+        member: 'onSuspend',
+        kind: 'read'
+    },
+    {
+        api: 'runtime',
+        member: 'onSuspendCanceled',
+        kind: 'read'
+    },
+    {
+        api: 'runtime',
+        member: 'onUpdateAvailable',
+        kind: 'read'
+    },
+    {
+        api: 'declarativeNetRequest',
+        member: 'getAvailableStaticRuleCount',
+        kind: 'call'
+    },
+    {
+        api: 'declarativeNetRequest',
+        member: 'getDisabledRuleIds',
+        kind: 'call'
+    },
+    {
+        api: 'declarativeNetRequest',
+        member: 'updateStaticRules',
+        kind: 'call'
+    },
+    {
+        api: 'declarativeNetRequest',
+        member: 'testMatchOutcome',
+        kind: 'call'
+    },
+    {
+        api: 'declarativeNetRequest',
+        member: 'onRuleMatchedDebug',
+        kind: 'read'
+    },
+    {
+        api: 'tabs',
+        member: 'group',
+        kind: 'call'
+    },
+    {
+        api: 'tabs',
+        member: 'ungroup',
+        kind: 'call'
+    },
+    {
+        api: 'webNavigation',
+        member: 'onCreatedNavigationTarget',
+        kind: 'read'
+    },
+    {
+        api: 'webNavigation',
+        member: 'onHistoryStateUpdated',
+        kind: 'read'
+    },
+    {
+        api: 'webNavigation',
+        member: 'onReferenceFragmentUpdated',
+        kind: 'read'
+    },
+    {
+        api: 'webNavigation',
+        member: 'onTabReplaced',
+        kind: 'read'
+    },
+    {
+        api: 'windows',
+        member: 'onBoundsChanged',
+        kind: 'read'
+    }
+];
+const webkitMemberEntries = webkitUnsupportedMembers.filter((entry)=>!(entry.api in webkitUnsupportedApis));
+const webkitMemberByKey = new Map(webkitUnsupportedMembers.map((entry)=>[
+        `${entry.api}.${entry.member}`,
+        entry
+    ]));
+function geckoUnsupportedApis(manifestVersion, engine = 'gecko') {
+    if ('webkit' === engine) return Object.keys(webkitUnsupportedApis);
     return 2 === manifestVersion ? [
         'sidePanel',
         'action'
@@ -12792,52 +13170,51 @@ function geckoUnsupportedApis(manifestVersion) {
         'sidePanel'
     ];
 }
-function usesGeckoUnsupportedApi(source, api) {
-    const memberRe = new RegExp(`\\b(?:chrome|browser)\\s*\\.\\s*${api}\\s*\\??\\.\\s*[A-Za-z_$]`);
+function usesGeckoUnsupportedApi(source, api, engine = 'gecko') {
+    const chain = 'webkit' === engine ? '' : '\\??';
+    const memberRe = new RegExp(`\\b(?:chrome|browser)\\s*\\.\\s*${api}\\s*${chain}\\.\\s*[A-Za-z_$]`);
     return memberRe.test(source);
 }
-const EMITTED_SCRIPT_RE = /\.[cm]?js$/;
-const MAX_SOURCE_BYTES = 1048576;
-const MAX_ASSET_BYTES = 16777216;
-function readEmittedScripts(compilation) {
-    const scripts = new Map();
-    let assets;
-    try {
-        assets = compilation.getAssets?.() || [];
-    } catch  {
-        return scripts;
-    }
-    for (const asset of assets)if (EMITTED_SCRIPT_RE.test(asset.name)) try {
-        const raw = asset.source.source();
-        const text = 'string' == typeof raw ? raw : raw.toString('utf-8');
-        if (text.length > MAX_ASSET_BYTES) continue;
-        scripts.set(asset.name, text);
-    } catch  {}
-    return scripts;
-}
-function readProjectSource(resource) {
-    try {
-        if (__rspack_external_node_fs_1b05aee1.statSync(resource).size > MAX_SOURCE_BYTES) return;
-        return __rspack_external_node_fs_1b05aee1.readFileSync(resource, 'utf-8');
-    } catch  {
-        return;
-    }
+function usesWebkitUnsupportedMember(source, entry) {
+    const tail = 'call' === entry.kind ? '\\s*\\(' : '\\s*\\.\\s*[A-Za-z_$]';
+    const memberRe = new RegExp(`\\b(?:chrome|browser)\\s*\\.\\s*${entry.api}\\s*\\.\\s*${entry.member}(?![\\w$])${tail}`);
+    return memberRe.test(source);
 }
-function emittedFilesOf(compilation, module) {
-    if (!compilation.chunkGraph) return;
-    try {
-        const files = [];
-        for (const chunk of compilation.chunkGraph.getModuleChunksIterable(module))for (const file of chunk.files || [])files.push(file);
-        return files;
-    } catch  {
-        return;
-    }
+function scanTargets(manifestVersion, engine) {
+    const targets = geckoUnsupportedApis(manifestVersion, engine).map((api)=>({
+            key: api,
+            api,
+            test: (text)=>usesGeckoUnsupportedApi(text, api, engine)
+        }));
+    if ('webkit' !== engine) return targets;
+    for (const entry of webkitMemberEntries)targets.push({
+        key: `${entry.api}.${entry.member}`,
+        api: entry.api,
+        member: entry.member,
+        test: (text)=>usesWebkitUnsupportedMember(text, entry)
+    });
+    return targets;
 }
-function findGeckoUnsupportedApiUses(compilation, manifestVersion) {
-    const apis = geckoUnsupportedApis(manifestVersion);
+function findGeckoUnsupportedApiUses(compilation, manifestVersion, engine = 'gecko', requireEmittedEvidence = false) {
+    const targets = scanTargets(manifestVersion, engine);
     const emitted = readEmittedScripts(compilation);
     const explained = new Set();
     const uses = new Map();
+    const shipped = new Map();
+    const shippedText = (file)=>{
+        if (shipped.has(file)) return shipped.get(file);
+        const text = emitted.get(file);
+        if (void 0 === text) return;
+        const compressed = requireEmittedEvidence ? shippableText(text) : text;
+        shipped.set(file, compressed);
+        return compressed;
+    };
+    const carries = (file, target)=>{
+        const raw = emitted.get(file);
+        if (void 0 === raw || !target.test(raw)) return false;
+        const text = shippedText(file);
+        return void 0 !== text && target.test(text);
+    };
     for (const outer of compilation.modules){
         const inner = outer.modules ? [
             ...outer.modules
@@ -12848,20 +13225,20 @@ function findGeckoUnsupportedApiUses(compilation, manifestVersion) {
             const resource = scannableSourcePath(module.resource);
             if (!resource) continue;
             const source = readProjectSource(resource);
-            if (void 0 !== source) for (const api of apis){
-                const key = `${api}\0${resource}`;
-                if (uses.has(key) || !usesGeckoUnsupportedApi(source, api)) continue;
+            if (void 0 !== source) for (const target of targets){
+                const key = `${target.key}\0${resource}`;
+                if (uses.has(key) || !target.test(source)) continue;
                 const files = emittedFilesOf(compilation, outer);
                 if (files) {
-                    const carrying = files.filter((file)=>{
-                        const text = emitted.get(file);
-                        return void 0 !== text && usesGeckoUnsupportedApi(text, api);
-                    });
+                    const carrying = files.filter((file)=>carries(file, target));
                     if (!carrying.length) continue;
-                    for (const file of carrying)explained.add(`${api}\0${file}`);
-                }
+                    for (const file of carrying)explained.add(`${target.key}\0${file}`);
+                } else if (requireEmittedEvidence) continue;
                 uses.set(key, {
-                    api,
+                    api: target.api,
+                    ...target.member ? {
+                        member: target.member
+                    } : {},
                     file: resource,
                     emitted: false
                 });
@@ -12871,10 +13248,13 @@ function findGeckoUnsupportedApiUses(compilation, manifestVersion) {
     if (!compilation.chunkGraph) return [
         ...uses.values()
     ];
-    for (const [name, text] of emitted)for (const api of apis){
-        const key = `${api}\0${name}`;
-        if (!explained.has(key) && usesGeckoUnsupportedApi(text, api)) uses.set(key, {
-            api,
+    for (const name of emitted.keys())for (const target of targets){
+        const key = `${target.key}\0${name}`;
+        if (!explained.has(key) && carries(name, target)) uses.set(key, {
+            api: target.api,
+            ...target.member ? {
+                member: target.member
+            } : {},
             file: name,
             emitted: true
         });
@@ -12896,16 +13276,25 @@ function relativeToProject(projectPath, file) {
     }
     return __rspack_external_node_path_806ed179.relative(projectPath, file) || file;
 }
-function reportGeckoUnsupportedApis(compilation, compiler, browser, manifest, projectPath) {
-    if ('production' !== compiler.options.mode) return;
-    if (!isGeckoBasedBrowser(String(browser))) return;
+function reportGeckoUnsupportedApis(compilation, compiler, browser, manifest, projectPath, reported) {
+    const engine = isGeckoBasedBrowser(String(browser)) ? 'gecko' : isWebkitBasedBrowser(String(browser)) ? 'webkit' : void 0;
+    if (!engine) return;
+    const isProduction = 'production' === compiler.options.mode;
+    if (!isProduction && 'webkit' !== engine) return;
     try {
-        const uses = findGeckoUnsupportedApiUses(compilation, manifest.manifest_version);
+        const uses = findGeckoUnsupportedApiUses(compilation, manifest.manifest_version, engine, !isProduction);
         for (const use of uses){
             const label = use.emitted ? use.file : relativeToProject(projectPath, use.file);
-            const text = 'sidePanel' === use.api ? geckoSidePanelUnsupported(label) : geckoActionUnsupportedOnMv2(label);
+            if (!isProduction && reported) {
+                const signature = `${use.api}.${use.member || ''}\0${label}`;
+                if (reported.has(signature)) continue;
+                reported.add(signature);
+            }
+            const memberEntry = use.member ? webkitMemberByKey.get(`${use.api}.${use.member}`) : void 0;
+            const webkitMessage = 'webkit' !== engine || memberEntry ? void 0 : webkitUnsupportedApis[use.api];
+            const text = memberEntry ? safariMemberUnsupported(label, memberEntry.api, memberEntry.member, memberEntry.kind) : webkitMessage ? webkitMessage(label) : 'sidePanel' === use.api ? geckoSidePanelUnsupported(label) : geckoActionUnsupportedOnMv2(label);
             const warn = new core_WebpackError(text);
-            warn.name = 'GeckoUnsupportedApiWarning';
+            warn.name = 'webkit' === engine ? 'SafariUnsupportedApiWarning' : 'GeckoUnsupportedApiWarning';
             warn.file = label;
             compilation.warnings.push(warn);
         }
@@ -12915,6 +13304,7 @@ class UpdateManifest {
     manifestPath;
     browser;
     reportedFatalFixes = new Set();
+    reportedUnsupportedApis = new Set();
     constructor(options){
         this.manifestPath = options.manifestPath;
         this.browser = options.browser || 'chrome';
@@ -12946,10 +13336,19 @@ class UpdateManifest {
                 if (dropReason) reportToCompilation(compilation, compiler, 'conflicts' === dropReason ? pageActionDroppedForBrowserAction(String(this.browser)) : pageActionNotSupportedByBrowser(String(this.browser)), 'warning', 'manifest.json');
                 if (hasMv2SandboxPolicy(forBrowser)) reportToCompilation(compilation, compiler, mv2SandboxPolicyDropped(String(this.browser)), 'warning', 'manifest.json');
                 for (const dropped of findDroppedVendorKeys(manifest, this.browser))if (dropped.appliedBefore) reportToCompilation(compilation, compiler, vendorPrefixedKeyDropped(dropped.path, dropped.familyPath, dropped.vendor, String(this.browser)), 'warning', 'manifest.json');
+                if (!isValidManifestVersion(forBrowser.manifest_version)) reportToCompilation(compilation, compiler, manifestVersionLostForBrowser(String(this.browser), findPrefixedManifestVersionKeys(manifest), forBrowser.manifest_version), 'error', 'manifest.json');
                 const projectPath = compiler.options.context || __rspack_external_node_path_806ed179.dirname(this.manifestPath);
                 let patchedManifest = buildCanonicalManifest(this.manifestPath, manifest, this.browser, projectPath);
+                if ('production' === compiler.options.mode) {
+                    const edgeKey = dropEdgeStoreKey(patchedManifest, this.browser);
+                    if (edgeKey.dropped) {
+                        patchedManifest = edgeKey.manifest;
+                        reportToCompilation(compilation, compiler, edgeStoreKeyDropped(String(this.browser)), 'warning', 'manifest.json');
+                    }
+                }
                 patchedManifest = patchGeckoBackground(patchedManifest, this.browser);
                 patchedManifest = patchChromiumBackground(patchedManifest, this.browser);
+                patchedManifest = patchWebkitBackground(patchedManifest, this.browser);
                 patchedManifest = patchChromiumThemeColors(patchedManifest, this.browser);
                 const overrides = getManifestOverrides(this.manifestPath, manifest, projectPath);
                 if ('development' === compiler.options.mode) {
@@ -12989,7 +13388,7 @@ class UpdateManifest {
                     warn.file = 'manifest.json';
                     compilation.warnings.push(warn);
                 }
-                reportGeckoUnsupportedApis(compilation, compiler, this.browser, patchedManifest, projectPath);
+                reportGeckoUnsupportedApis(compilation, compiler, this.browser, patchedManifest, projectPath, this.reportedUnsupportedApis);
                 const source = JSON.stringify(patchedManifest, null, 2);
                 const rawSource = new core_sources.RawSource(source);
                 setCurrentManifestContent(compilation, source);
@@ -13496,6 +13895,100 @@ function parsesAsModule(source) {
         return false;
     }
 }
+const WORKER_FROM_URL = /new\s+Worker\s*\(\s*(?:\/\*[\s\S]*?\*\/\s*)?new\s+URL\s*\(/;
+const EXTENSION_BASES = [
+    /^import\.meta\.url$/,
+    /^[A-Za-z_$][\w$]*\.b$/,
+    /^(?:chrome|browser)\.runtime\.getURL\(/,
+    /^["'`](?:chrome-extension|moz-extension|safari-web-extension):\/\//
+];
+const JS_ASSET = /\.m?js$/i;
+function readCallArguments(source, from) {
+    const args = [];
+    let depth = 0;
+    let start = from;
+    for(let i = from; i < source.length; i++){
+        const char = source[i];
+        if ('"' === char || "'" === char || '`' === char) {
+            i = skipQuoted(source, i, char);
+            continue;
+        }
+        if ('/' === char && '*' === source[i + 1]) {
+            const end = source.indexOf('*/', i + 2);
+            i = -1 === end ? source.length : end + 1;
+            continue;
+        }
+        if ('/' === char && '/' === source[i + 1]) {
+            const end = source.indexOf('\n', i + 2);
+            i = -1 === end ? source.length : end;
+            continue;
+        }
+        if ('(' === char || '[' === char || '{' === char) {
+            depth++;
+            continue;
+        }
+        if (')' === char || ']' === char || '}' === char) {
+            if (0 === depth) {
+                args.push(source.slice(start, i));
+                return args;
+            }
+            depth--;
+            continue;
+        }
+        if (',' === char && 0 === depth) {
+            args.push(source.slice(start, i));
+            start = i + 1;
+        }
+    }
+}
+function skipQuoted(source, from, quote) {
+    for(let i = from + 1; i < source.length; i++){
+        if ('\\' === source[i]) {
+            i++;
+            continue;
+        }
+        if (source[i] === quote) return i;
+    }
+    return source.length;
+}
+function resolvesAgainstExtension(base) {
+    const text = (base ?? '').replace(/\s+/g, '');
+    if (!text) return true;
+    return EXTENSION_BASES.some((shape)=>shape.test(text));
+}
+function startsWorkerFromExtensionUrl(source) {
+    const call = new RegExp(WORKER_FROM_URL.source, 'g');
+    let match = call.exec(source);
+    while(match){
+        const args = readCallArguments(source, match.index + match[0].length);
+        if (args && resolvesAgainstExtension(args[1])) return true;
+        match = call.exec(source);
+    }
+    return false;
+}
+class WarnPageContextWorker {
+    apply(compiler) {
+        if (!compiler?.hooks?.thisCompilation?.tap) return;
+        compiler.hooks.thisCompilation.tap("scripts:warn-page-context-worker", (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: "scripts:warn-page-context-worker",
+                stage: core_Compilation.PROCESS_ASSETS_STAGE_REPORT
+            }, ()=>{
+                for (const asset of compilation.getAssets()){
+                    const name = String(asset.name || '');
+                    if (!JS_ASSET.test(name)) continue;
+                    const surface = classifyEntrySurface(name);
+                    if ("content_script" !== surface && "script" !== surface) continue;
+                    const source = String(asset.source?.source() || '');
+                    if (!startsWorkerFromExtensionUrl(source)) continue;
+                    const warning = new core_WebpackError(workerStartedFromPageContext(name, surface));
+                    warning.file = name;
+                    compilation.warnings.push(warning);
+                }
+            });
+        });
+    }
+}
 class WarnSplitInitialChunks {
     apply(compiler) {
         if (!compiler?.hooks?.thisCompilation?.tap) return;
@@ -13552,6 +14045,7 @@ class ScriptsPlugin {
         if ('production' === compiler.options.mode) new AddPublicPathRuntimeModule().apply(compiler);
         new ValidateEmittedScriptSyntax().apply(compiler);
         new WarnSplitInitialChunks().apply(compiler);
+        new WarnPageContextWorker().apply(compiler);
     }
 }
 class CollectContentEntryImports {
@@ -14350,6 +14844,12 @@ function webpackConfig(projectStructure, devOptions) {
         optimization: {
             emitOnErrors: false,
             minimize: 'production' === devOptions.mode,
+            minimizer: [
+                new SwcJsMinimizerRspackPlugin(),
+                new LightningCssMinimizerRspackPlugin({
+                    removeUnusedLocalIdents: false
+                })
+            ],
             sideEffects: true,
             usedExports: 'global',
             concatenateModules: 'production' === devOptions.mode,