extension-develop 3.18.3 → 3.18.4-canary.320.767e107

package/dist/0~dev-server.mjs

@@ -569,11 +569,15 @@ class BridgeBroker {
                 reload: this.allowControl,
                 open: this.allowControl ? isFirefox ? [
                     'popup',
-                    'options'
+                    'options',
+                    'action',
+                    'command'
                 ] : [
                     'popup',
                     'options',
-                    'sidebar'
+                    'sidebar',
+                    'action',
+                    'command'
                 ] : [],
                 deepDom: 'chromium' === this.engine
             }

package/dist/0~rslib-runtime.mjs

@@ -1,16 +1,5 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
-var __webpack_modules__ = {};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-__webpack_require__.m = __webpack_modules__;
+var __webpack_require__ = {};
 (()=>{
     __webpack_require__.d = (exports, definition)=>{
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
@@ -19,11 +8,6 @@ __webpack_require__.m = __webpack_modules__;
         });
     };
 })();
-(()=>{
-    __webpack_require__.add = function(modules) {
-        Object.assign(__webpack_require__.m, modules);
-    };
-})();
 (()=>{
     __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
 })();

package/dist/0~rspack-config.mjs

@@ -375,7 +375,9 @@ function getFilename(feature, filePath) {
         '.js',
         '.jsx',
         '.tsx',
-        '.ts'
+        '.ts',
+        '.vue',
+        '.svelte'
     ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.js');
     if ([
         '.html',
@@ -851,16 +853,18 @@ function normalizeOutputPath(originalPath) {
 }
 function webAccessibleResources(manifest) {
     if (!manifest.web_accessible_resources || !manifest.web_accessible_resources.length) return;
-    if (Array.isArray(manifest.web_accessible_resources) && 'string' == typeof manifest.web_accessible_resources[0]) return {
-        web_accessible_resources: manifest.web_accessible_resources.map((resource)=>getFilename(normalizeOutputPath(resource), resource))
-    };
-    const v3 = manifest.web_accessible_resources.filter((entry)=>Array.isArray(entry.resources)).map((entry)=>({
+    const mapResource = (resource)=>getFilename(normalizeOutputPath(resource), resource);
+    const entries = manifest.web_accessible_resources.map((entry)=>{
+        if ('string' == typeof entry) return mapResource(entry);
+        if (!entry || !Array.isArray(entry.resources)) return;
+        return {
             ...entry,
-            resources: (entry.resources || []).map((res)=>getFilename(normalizeOutputPath(res), res))
-        }));
-    if (0 === v3.length) return;
+            resources: entry.resources.map(mapResource)
+        };
+    }).filter((entry)=>void 0 !== entry);
+    if (0 === entries.length) return;
     return {
-        web_accessible_resources: v3
+        web_accessible_resources: entries
     };
 }
 function contentSecurityPolicy(manifest) {
@@ -2910,6 +2914,7 @@ class JsFrameworksPlugin {
                 issuerLayer: {
                     not: EXTENSIONJS_CONTENT_SCRIPT_LAYER
                 },
+                type: "javascript/esm",
                 exclude: [
                     ...swcRuleBase.exclude,
                     (resourcePath)=>isfeatureScriptsContentLike(resourcePath)
@@ -3108,6 +3113,25 @@ function purgeStaleHashedContentScripts(compilation, currentNames) {
         }
     } catch  {}
 }
+function isGeckoBrowser(browser) {
+    const b = String(browser);
+    return 'firefox' === b || b.includes('firefox') || b.includes('gecko');
+}
+function patchGeckoBackground(manifest, browser) {
+    if (!isGeckoBrowser(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
+            ]
+        }
+    };
+}
 class UpdateManifest {
     manifestPath;
     browser;
@@ -3133,6 +3157,7 @@ class UpdateManifest {
                 if (compilation.errors.length > 0) return;
                 const manifest = getManifestContent(compilation, this.manifestPath);
                 let patchedManifest = buildCanonicalManifest(this.manifestPath, manifest, this.browser);
+                patchedManifest = patchGeckoBackground(patchedManifest, this.browser);
                 const overrides = getManifestOverrides(this.manifestPath, manifest);
                 if ('development' === compiler.options.mode) patchedManifest = patchDevContentScriptManifestPaths(compilation, patchedManifest);
                 if ('development' === compiler.options.mode) {
@@ -3169,6 +3194,18 @@ function getSharedFor(compilation) {
     }
     return shared;
 }
+function cleanMatches(matches) {
+    return matches.map((match)=>{
+        try {
+            const url = new URL(match.replace(/^\*:\/\//, 'https://'));
+            if (match.endsWith(url.pathname)) return `${match.substring(0, match.length - url.pathname.length)}/*`;
+            if ('/' === url.pathname) return `${match}/*`;
+            return match;
+        } catch  {
+            return match;
+        }
+    });
+}
 function warFieldError(filePath, opts) {
     const displayPath = opts?.overrideNotFoundPath || filePath;
     const lines = [];
@@ -3179,6 +3216,10 @@ function warFieldError(filePath, opts) {
         lines.push(`To reference files in ${pintor.yellow('public/')}, use a leading '/' (e.g. ${pintor.yellow('/open-panel.gif')}). These resolve from the built extension root.`);
         lines.push('');
         lines.push(`Fix: Add the file to ${pintor.yellow('public/')} or update the path to the correct '/...' location.`);
+    } else if (opts?.sourceSibling) {
+        lines.push(`Found ${pintor.yellow(opts.sourceSibling)}, but web_accessible_resources entries are copied as-is, not compiled.`);
+        lines.push('');
+        lines.push(`Fix: Import the file from a script so it gets bundled, or move a prebuilt copy to ${pintor.yellow('public/')} and reference it with a leading '/'.`);
     } else {
         lines.push("Relative paths must point to a real source file so the build can emit it.");
         lines.push('');
@@ -3189,6 +3230,16 @@ function warFieldError(filePath, opts) {
     lines.push(`${pintor.red('NOT FOUND')} ${pintor.underline(displayPath)}`);
     return lines.join('\n');
 }
+function warStringEntryInMv3(entry) {
+    const lines = [];
+    lines.push(`Check the ${pintor.yellow('web_accessible_resources')} field in your ${pintor.yellow('manifest.json')} file.`);
+    lines.push(`Manifest V3 requires object entries with ${pintor.yellow('resources')} and ${pintor.yellow('matches')} (or ${pintor.yellow('extension_ids')}). Plain string entries are the Manifest V2 format and Chrome rejects them at load time.`);
+    lines.push('');
+    lines.push(`Fix: Wrap it like ${pintor.yellow(`{"resources": ["${entry}"], "matches": ["<all_urls>"]}`)} with the matches your pages need.`);
+    lines.push('');
+    lines.push(`${pintor.red('INVALID MV3 ENTRY')} ${pintor.underline(entry)}`);
+    return lines.join('\n');
+}
 function warInvalidMatchPattern(pattern) {
     const lines = [];
     lines.push(`Check the ${pintor.yellow('web_accessible_resources')} field in your ${pintor.yellow('manifest.json')} file.`);
@@ -3229,6 +3280,33 @@ function emitFileAsAsset(compilation, absPath) {
     compilation.fileDependencies.add(absPath);
     return unixify(outName);
 }
+function findSourceSibling(absOutputPath) {
+    const candidatesByExt = {
+        '.js': [
+            '.ts',
+            '.tsx',
+            '.jsx',
+            '.vue',
+            '.svelte'
+        ],
+        '.css': [
+            '.scss',
+            '.sass',
+            '.less'
+        ],
+        '.html': [
+            '.njk',
+            '.nunjucks'
+        ]
+    };
+    const ext = __rspack_external_path.extname(absOutputPath);
+    const sourceExts = candidatesByExt[ext];
+    if (!sourceExts) return;
+    for (const sourceExt of sourceExts){
+        const candidate = absOutputPath.slice(0, -ext.length) + sourceExt;
+        if (__rspack_external_fs.existsSync(candidate)) return candidate;
+    }
+}
 function isFirefox(browser) {
     return !!browser && browser.toLowerCase().includes('firefox');
 }
@@ -3264,30 +3342,33 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
         v2,
         v3
     };
-    const isV2 = Array.isArray(war) && 'string' == typeof war[0];
+    const isMv2 = 3 !== manifestObj.manifest_version;
     const manifestDir = __rspack_external_path.dirname(manifestPath);
     const projectPath = compilation.options?.context || manifestDir;
-    const pushResource = (matches, resource)=>{
-        if (2 === manifestObj.manifest_version || isV2) return void v2.add(resource);
+    const pushResource = (matches, resource, extra)=>{
+        if (isMv2) return void v2.add(resource);
         const key = (matches || []).join(',');
         let group = v3.find((g)=>g.matches.join(',') === key);
-        if (!group) {
+        if (group) {
+            if (extra && !group.extra) group.extra = extra;
+        } else {
             group = {
                 matches: matches || [],
-                resources: new Set()
+                resources: new Set(),
+                extra
             };
             v3.push(group);
         }
         group.resources.add(resource);
     };
-    const handleOne = (matches, res)=>{
+    const handleOne = (matches, res, extra)=>{
         compilation.errors = compilation.errors || [];
         compilation.warnings = compilation.warnings || [];
         const normalizedOutput = normalizeManifestOutputPath(res);
         const publicCandidate = __rspack_external_path.join(projectPath, 'public', normalizedOutput);
-        if (__rspack_external_fs.existsSync(publicCandidate)) return void pushResource(matches, normalizedOutput);
+        if (__rspack_external_fs.existsSync(publicCandidate)) return void pushResource(matches, normalizedOutput, extra);
         __rspack_external_path.isAbsolute(res) || __rspack_external_path.join(manifestDir, isPublicRootLike(res) ? toPublicOutput(res) : res);
-        if (/[*?\[\]{}]/.test(res)) return void pushResource(matches, res);
+        if (/[*?\[\]{}]/.test(res)) return void pushResource(matches, res, extra);
         if (isPublicRootLike(res)) {
             const output = normalizeManifestOutputPath(res);
             const publicAbs = __rspack_external_path.join(projectPath, 'public', output);
@@ -3318,7 +3399,7 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
                 err.file = 'manifest.json';
                 compilation.warnings.push(err);
             }
-            pushResource(matches, output);
+            pushResource(matches, output, extra);
             return;
         }
         const abs = __rspack_external_path.isAbsolute(res) ? res : __rspack_external_path.join(manifestDir, res);
@@ -3330,46 +3411,47 @@ function resolveUserDeclaredWAR(compilation, manifestPath, manifest, browser) {
             const assetEmitted = Boolean(asset2 && asset2.name === res) || __rspack_external_fs.existsSync(builtAbs);
             if (__rspack_external_fs.existsSync(publicAbsMaybe) || assetEmitted) {
                 const output = toPublicOutput('/' + res);
-                pushResource(matches, output);
+                pushResource(matches, output, extra);
                 return;
             }
+            const sourceSibling = findSourceSibling(abs);
             const msg = warFieldError(abs, {
-                relativeRef: res
+                relativeRef: res,
+                sourceSibling: sourceSibling ? __rspack_external_path.relative(manifestDir, sourceSibling) : void 0
             });
             const warn = new core_WebpackError(msg);
             warn.file = 'manifest.json';
             warn.name = 'WARRelativeAssetMissing';
             compilation.warnings.push(warn);
-            pushResource(matches, res);
             return;
         }
         const emitted = emitFileAsAsset(compilation, abs);
-        pushResource(matches, emitted);
+        pushResource(matches, emitted, extra);
     };
-    if (isV2) war.forEach((res)=>handleOne(void 0, res));
-    else war.forEach((group)=>{
-        const matches = group.matches || [];
+    war.forEach((entry)=>{
+        if ('string' == typeof entry) {
+            if (isMv2) return void handleOne(void 0, entry);
+            const msg = warStringEntryInMv3(entry);
+            const err = new core_WebpackError(msg);
+            err.file = 'manifest.json';
+            err.name = 'WARStringEntryInMv3';
+            compilation.errors = compilation.errors || [];
+            compilation.errors.push(err);
+            return;
+        }
+        if (!entry || 'object' != typeof entry) return;
+        const matches = entry.matches || [];
         validateMatchesOrReport(compilation, matches, browser);
-        if (!Array.isArray(group.resources)) return;
-        group.resources.forEach((res)=>handleOne(matches, res));
+        if (!Array.isArray(entry.resources)) return;
+        const { resources: _resources, matches: _matches, ...extra } = entry;
+        const extraFields = Object.keys(extra).length > 0 ? extra : void 0;
+        entry.resources.forEach((res)=>handleOne(matches, res, extraFields));
     });
     return {
         v2,
         v3
     };
 }
-function cleanMatches(matches) {
-    return matches.map((match)=>{
-        try {
-            const url = new URL(match.replace(/^\*:\/\//, 'https://'));
-            if (match.endsWith(url.pathname)) return `${match.substring(0, match.length - url.pathname.length)}/*`;
-            if ('/' === url.pathname) return `${match}/*`;
-            return match;
-        } catch  {
-            return match;
-        }
-    });
-}
 function getAssetSource(compilation, filename) {
     const byGet = 'function' == typeof compilation.getAsset ? compilation.getAsset(filename) : void 0;
     const byAssets = !byGet && compilation.assets ? compilation.assets[filename] : void 0;
@@ -3434,6 +3516,7 @@ function mergeIntoV3Group(groups, normalizedMatches, resources, options) {
         ].sort()
     });
 }
+const assetScanCache = new WeakMap();
 function isCanonicalContentScriptCss(resource) {
     return /^content_scripts\/content-\d+\.css$/.test(resource);
 }
@@ -3446,6 +3529,7 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
     const canonicalManifest = getManifestContent(compilation, manifestPath);
     const resolved = resolveUserDeclaredWAR(compilation, manifestPath, canonicalManifest, browser);
     const webAccessibleResourcesV3 = 3 === canonicalManifest.manifest_version ? resolved.v3.map((g)=>({
+            ...g.extra || {},
             matches: g.matches,
             resources: Array.from(g.resources)
         })) : [];
@@ -3455,11 +3539,17 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
         const normalizedMatches = cleanMatches(matches);
         const jsFiles = Array.isArray(contentScript.js) ? contentScript.js : [];
         for (const jsFile of jsFiles){
-            const source = getAssetSource(compilation, jsFile);
-            if (!source) continue;
-            const re = /assets\/[A-Za-z0-9._-]+/g;
-            const found = source.match(re) || [];
-            const filtered = Array.from(new Set(found.filter((r)=>!r.endsWith('.js') && !r.endsWith('.map')))).sort();
+            const assetForCache = 'function' == typeof compilation.getAsset ? compilation.getAsset(jsFile) : void 0;
+            const cacheKey = assetForCache && 'object' == typeof assetForCache.source ? assetForCache.source : void 0;
+            let filtered = cacheKey ? assetScanCache.get(cacheKey) : void 0;
+            if (!filtered) {
+                const source = getAssetSource(compilation, jsFile);
+                if (!source) continue;
+                const re = /assets\/[A-Za-z0-9._-]+/g;
+                const found = source.match(re) || [];
+                filtered = Array.from(new Set(found.filter((r)=>!r.endsWith('.js') && !r.endsWith('.map')))).sort();
+                if (cacheKey) assetScanCache.set(cacheKey, filtered);
+            }
             if (0 !== filtered.length) mergeIntoV3Group(webAccessibleResourcesV3, normalizedMatches, filtered);
         }
     }
@@ -3513,7 +3603,8 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
     const emittedCssUnderContentScripts = assetKeys.filter((k)=>k.startsWith("content_scripts/")).filter((k)=>k.endsWith('.css'));
     const onDiskCssUnderContentScripts = [];
     const outputPath = compilation.options.output?.path;
-    if (outputPath) try {
+    const isDevModeBuild = 'production' !== (compilation.options?.mode || 'development');
+    if (outputPath && isDevModeBuild) try {
         const csDir = __rspack_external_path.join(outputPath, "content_scripts");
         if (__rspack_external_fs.existsSync(csDir)) {
             for (const name of __rspack_external_fs.readdirSync(csDir))if (name.endsWith('.css')) onDiskCssUnderContentScripts.push(`content_scripts/${name}`);
@@ -3542,6 +3633,7 @@ function generateManifestPatches(compilation, manifestPath, entryImports, browse
     }
     if (3 === canonicalManifest.manifest_version) {
         if (webAccessibleResourcesV3.length > 0) canonicalManifest.web_accessible_resources = webAccessibleResourcesV3.map((entry)=>({
+                ...entry,
                 resources: Array.from(new Set(entry.resources)).sort(),
                 matches: Array.from(new Set(entry.matches)).sort()
             })).sort((a, b)=>a.matches.join(',').localeCompare(b.matches.join(',')));
@@ -6647,6 +6739,44 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
     var consoleRef = g.console || {};
     g.__extjsBridgeProducerInstalled = true;
 
+    // Capture extension event listeners at install time. The producer is
+    // prepended to the background bundle, so these wraps run BEFORE user code
+    // registers its listeners — letting the bridge replay them on demand. The
+    // platform exposes no API to dispatch these events, and CDP attaches too
+    // late to wrap addListener, so this is the only path. Replay invokes the
+    // handler WITHOUT a user gesture, so the gesture-derived activeTab grant
+    // does NOT apply (callers are told gesture:false). This is engine-agnostic:
+    // it works on Chromium and Gecko because it only touches addListener.
+    //
+    // captureEvent transparently wraps addListener/removeListener (delegating to
+    // the originals) and records callbacks into the sink array.
+    function captureEvent(event, sink) {
+      try {
+        if (!event || typeof event.addListener !== "function") return;
+        var origAdd = event.addListener.bind(event);
+        event.addListener = function (cb) {
+          if (typeof cb === "function" && sink.indexOf(cb) === -1) sink.push(cb);
+          return origAdd(cb);
+        };
+        if (typeof event.removeListener === "function") {
+          var origRemove = event.removeListener.bind(event);
+          event.removeListener = function (cb) {
+            var i = sink.indexOf(cb);
+            if (i !== -1) sink.splice(i, 1);
+            return origRemove(cb);
+          };
+        }
+      } catch (e) { /* non-fatal: trigger falls back to its no-listener reply */ }
+    }
+
+    // Use g.chrome (not the hoisted chrome var below) — this runs first.
+    var actionClickedListeners = [];
+    var commandListeners = [];
+    if (g.chrome) {
+      captureEvent(g.chrome.action && g.chrome.action.onClicked, actionClickedListeners);
+      captureEvent(g.chrome.commands && g.chrome.commands.onCommand, commandListeners);
+    }
+
     var LEVELS = ["log", "info", "warn", "error", "debug", "trace"];
     var socket = null;
     var open = false;
@@ -6751,6 +6881,42 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
         }
         if (op === "open") {
           var surface = args.surface || ctx;
+          // getPopup is promise-style on Gecko and (MV3) Chromium; fall back to
+          // callback-style for older Chromium. Always resolves to a string.
+          var getActionPopup = function (cb) {
+            try {
+              var r = chrome.action && chrome.action.getPopup && chrome.action.getPopup({});
+              if (r && typeof r.then === "function") {
+                r.then(function (p) { cb(p || ""); }, function () { cb(""); });
+                return;
+              }
+            } catch (e) {}
+            try { chrome.action.getPopup({}, function (p) { cb(p || ""); }); }
+            catch (e) { cb(""); }
+          };
+          // Resolve the tab a replayed event should carry: an explicit args.tabId,
+          // else the active tab of the focused window.
+          var resolveActiveTab = function (a, cb) {
+            if (a && typeof a.tabId === "number") {
+              try { chrome.tabs.get(a.tabId, function (t) { cb(t || {id: a.tabId}); }); return; }
+              catch (e) {}
+            }
+            try { chrome.tabs.query({active: true, lastFocusedWindow: true}, function (tabs) { cb((tabs && tabs[0]) || undefined); }); }
+            catch (e) { cb(undefined); }
+          };
+          // Replaying a listener carries no user gesture, so activeTab is never
+          // granted. Warn when the manifest declares it (handler will diverge
+          // from a real click).
+          var activeTabWarning = function () {
+            try {
+              var m = chrome.runtime.getManifest();
+              var perms = (m && m.permissions) || [];
+              if (perms.indexOf("activeTab") !== -1) {
+                return "replayed without a user gesture: activeTab is NOT granted, so APIs that depend on it (scripting on the active tab, captureVisibleTab) behave differently than a real click";
+              }
+            } catch (e) {}
+            return null;
+          };
           if (surface === "popup") {
             if (chrome.action && chrome.action.openPopup) {
               chrome.action.openPopup().then(function () { replyOk(cmdId, {opened: "popup"}); }, function (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); });
@@ -6764,6 +6930,47 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
                 chrome.sidePanel.open({windowId: w.id}).then(function () { replyOk(cmdId, {opened: "sidebar"}); }, function (e) { replyErr(cmdId, "Unsupported", "sidePanel.open: " + e); });
               });
             } else { replyErr(cmdId, "Unsupported", "sidePanel not available (engine: " + engineName() + ")"); }
+          } else if (surface === "action") {
+            // Trigger the toolbar action. With a default_popup, clicking the icon
+            // opens it (reuse openPopup). Without a popup, clicking fires
+            // chrome.action.onClicked — we replay the listeners captured at install.
+            if (chrome.action) {
+              getActionPopup(function (popup) {
+                if (popup) {
+                  try {
+                    chrome.action.openPopup().then(function () { replyOk(cmdId, {triggered: "popup"}); }, function (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); });
+                  } catch (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); }
+                } else if (actionClickedListeners.length) {
+                  resolveActiveTab(args, function (tab) {
+                    var fired = 0;
+                    for (var i = 0; i < actionClickedListeners.length; i++) {
+                      try { actionClickedListeners[i](tab); fired++; } catch (e) {}
+                    }
+                    var reply = {triggered: "onClicked", listeners: fired, gesture: false};
+                    var warning = activeTabWarning();
+                    if (warning) reply.warning = warning;
+                    replyOk(cmdId, reply);
+                  });
+                } else {
+                  replyErr(cmdId, "Unsupported", "action has no popup and no onClicked listener registered");
+                }
+              });
+            } else { replyErr(cmdId, "Unsupported", "chrome.action not available (engine: " + engineName() + ")"); }
+          } else if (surface === "command") {
+            // Replay a captured chrome.commands.onCommand listener (keyboard
+            // shortcut). Same no-gesture caveat as onClicked.
+            var commandName = (args && args.name) || undefined;
+            if (!commandListeners.length) {
+              replyErr(cmdId, "Unsupported", "no chrome.commands.onCommand listener registered");
+            } else {
+              resolveActiveTab(args, function (tab) {
+                var fired = 0;
+                for (var i = 0; i < commandListeners.length; i++) {
+                  try { commandListeners[i](commandName, tab); fired++; } catch (e) {}
+                }
+                replyOk(cmdId, {triggered: "command", command: commandName || null, listeners: fired, gesture: false});
+              });
+            }
           } else { replyErr(cmdId, "BadRequest", "unknown surface: " + surface); }
           return;
         }
@@ -7068,7 +7275,7 @@ function buildBridgeProducerSource(opts) {
     if (!opts.controlPort || opts.controlPort < 1) return '';
     return BRIDGE_PRODUCER_SOURCE.replace(/__EXTJS_CONTROL_PORT__/g, String(opts.controlPort)).replace(/__EXTJS_INSTANCE_ID__/g, String(opts.instanceId)).replace(/__EXTJS_CONTEXT__/g, String(opts.context || 'background'));
 }
-const inject_bridge_producer_BACKGROUND_ASSET = /(^|\/)background\/(?:service_worker|script)\.js$/i;
+const inject_bridge_producer_BACKGROUND_ASSET = /(^|\/)background\/(?:service_worker|scripts?)\.js$/i;
 class InjectBridgeProducer {
     apply(compiler) {
         const controlPort = parseInt(String(process.env.EXTENSION_CONTROL_PORT || ''), 10);