extension-develop 4.0.7 → 4.0.8-canary.1783955851.8f7bd584

package/dist/0~dev-server.mjs

@@ -491,6 +491,9 @@ class BridgeBroker {
             case 'result':
                 if ('producer' === this.roles.get(conn)) this.onResult(frame);
                 return;
+            case 'reload-ack':
+                if ('producer' === this.roles.get(conn) && this.pendingReload?.reloadType === frame.reloadType) this.pendingReload = void 0;
+                return;
             default:
                 return;
         }
@@ -516,7 +519,7 @@ class BridgeBroker {
             conn.send(frame);
             notified++;
         } catch  {}
-        this.pendingReload = 0 === notified ? frame : void 0;
+        this.pendingReload = 0 === notified || "content-scripts" === frame.reloadType ? frame : void 0;
         return notified;
     }
     pingProducers() {

package/dist/0~rspack-config.mjs

@@ -17,7 +17,7 @@ import { isResourceUnderDirs, canonicalizeDir, toResourceKey } from "./93.mjs";
 import { getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, EXTENSIONJS_CONTENT_SCRIPT_LAYER, isCanonicalContentScriptAsset, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName } from "./291.mjs";
 import { stripBom, parseJsonSafe } from "./23.mjs";
 import { scrubBrand, makeSanitizedConsole } from "./0~branding.mjs";
-import { cssIntegrationsEnabled, cssConfigsDetected, missingSassDependency, isUsingIntegration, postCssPluginNotResolved } from "./845.mjs";
+import { cssIntegrationsEnabled, cssConfigsDetected, deadCssUrlRef, missingSassDependency, isUsingIntegration, postCssPluginNotResolved } from "./845.mjs";
 import { isUsingTypeScript, jsFrameworksIntegrationsEnabled, ensureTypeScriptConfig, ensureOptionalContractModuleLoaded, resolveDevelopInstallRoot, getUserTypeScriptConfigFile, isUsingCustomLoader, isUsingIntegration as messages_isUsingIntegration, loadOptionalContractModuleWithoutInstall, resolveOptionalContractPackageWithoutInstall, jsFrameworksHmrSummary, jsFrameworksConfigsDetected, hasDependency, resolveDevelopDistFile, optional_deps_resolver_ensureOptionalContractPackageResolved } from "./839.mjs";
 import { PROJECT_MANIFEST_FILENAMES, findNearestProjectManifestSync, readProjectDependencies } from "./80.mjs";
 import { injectedFileDependencyMissing, getURLDependencyMissing, staticImportDependencyMissing, backgroundIsRequiredMessageOnly, fetchedFileDependencyMissing, importScriptsDependencyMissing } from "./266.mjs";
@@ -293,6 +293,89 @@ function checkManifestInPublic(compilation, publicDir) {
         }
     } catch  {}
 }
+function isFromFilepathList(filePath, filepathList) {
+    return Object.values(filepathList || {}).some((value)=>value === filePath);
+}
+function getFilename(feature, filePath) {
+    const entryExt = __rspack_external_path.extname(filePath);
+    let fileOutputpath = feature;
+    if ([
+        '.js',
+        '.jsx',
+        '.tsx',
+        '.ts',
+        '.vue',
+        '.svelte'
+    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.js');
+    if ([
+        '.html',
+        '.njk',
+        '.nunjucks'
+    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.html');
+    if ([
+        '.css',
+        '.scss',
+        '.sass',
+        '.less'
+    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.css');
+    return unixify(fileOutputpath || '');
+}
+function unixify(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+function resolveRootAbsoluteRef(ref, projectRoot, publicRoot) {
+    if (!ref || !ref.startsWith('/')) return;
+    if (projectRoot && ref.startsWith(projectRoot)) return;
+    if (ref.startsWith('//')) return;
+    const trimmed = ref.replace(/^\/+/, '');
+    if (!trimmed) return;
+    if (publicRoot && __rspack_external_fs.existsSync(__rspack_external_path.join(publicRoot, trimmed))) return;
+    const candidate = __rspack_external_path.resolve(projectRoot, trimmed);
+    const rel = __rspack_external_path.relative(projectRoot, candidate);
+    if (rel.startsWith('..') || __rspack_external_path.isAbsolute(rel)) return;
+    if (!__rspack_external_fs.existsSync(candidate) || !__rspack_external_fs.statSync(candidate).isFile()) return;
+    return candidate;
+}
+function collectRootAbsoluteRefs(source) {
+    const refs = new Set();
+    const attrRe = /(?:src|href)\s*=\s*["'](\/[^"'#?]*)["']/gi;
+    const urlRe = /url\(\s*["']?(\/[^"')#?]+)["']?\s*\)/gi;
+    let m;
+    while(m = attrRe.exec(source))refs.add(m[1]);
+    while(m = urlRe.exec(source))refs.add(m[1]);
+    return refs;
+}
+function emitRootAbsoluteRefs(compilation, context, publicDir) {
+    const scanned = new Set();
+    for(let pass = 0; pass < 10; pass++){
+        const refs = new Set();
+        for (const asset of compilation.getAssets()){
+            if (!/\.(html|css)$/i.test(asset.name)) continue;
+            if (scanned.has(asset.name)) continue;
+            scanned.add(asset.name);
+            let source;
+            try {
+                source = String(asset.source.source());
+            } catch  {
+                continue;
+            }
+            for (const ref of collectRootAbsoluteRefs(source))refs.add(ref);
+        }
+        if (0 === refs.size) return;
+        let emitted = 0;
+        for (const ref of refs){
+            const outputName = ref.replace(/^\/+/, '');
+            if (compilation.getAsset(outputName)) continue;
+            const sourcePath = resolveRootAbsoluteRef(ref, context, publicDir);
+            if (sourcePath) try {
+                compilation.emitAsset(outputName, new rspack.sources.RawSource(__rspack_external_fs.readFileSync(sourcePath)));
+                compilation.fileDependencies.add(sourcePath);
+                emitted++;
+            } catch  {}
+        }
+        if (0 === emitted) return;
+    }
+}
 class SpecialFoldersPlugin {
     static name = 'plugin-special-folders';
     options;
@@ -303,6 +386,14 @@ class SpecialFoldersPlugin {
         const { manifestPath } = this.options;
         const context = compiler.options.context || __rspack_external_path.dirname(manifestPath);
         const publicDir = __rspack_external_path.join(context, 'public');
+        compiler.hooks.thisCompilation.tap(SpecialFoldersPlugin.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: `${SpecialFoldersPlugin.name}:root-absolute-refs`,
+                stage: compilation.constructor.PROCESS_ASSETS_STAGE_SUMMARIZE
+            }, ()=>{
+                emitRootAbsoluteRefs(compilation, __rspack_external_path.dirname(manifestPath), publicDir);
+            });
+        });
         if (__rspack_external_fs.existsSync(publicDir) && __rspack_external_fs.statSync(publicDir).isDirectory()) {
             compiler.hooks.thisCompilation.tap(SpecialFoldersPlugin.name, (compilation)=>{
                 compilation.hooks.processAssets.tap({
@@ -380,36 +471,6 @@ function envInjectedPublicVars(count) {
 function envNoMatchingFile(browser, mode, presentFiles, expectedCandidates) {
     return `Found ${presentFiles.map((file)=>pintor.yellow(file)).join(', ')} but none match browser ${pintor.yellow(browser)} (mode ${pintor.yellow(mode)}), so EXTENSION_PUBLIC_* variables read from code will be ${pintor.yellow('undefined')} in this build.\nMatching names, in priority order: ${expectedCandidates.map((file)=>pintor.gray(file)).join(', ')}.\nFamily names apply to every family member — e.g. ${pintor.yellow('.env.chrome')} also matches ${pintor.yellow('chromium')} and ${pintor.yellow('edge')} targets.`;
 }
-function isFromFilepathList(filePath, filepathList) {
-    return Object.values(filepathList || {}).some((value)=>value === filePath);
-}
-function getFilename(feature, filePath) {
-    const entryExt = __rspack_external_path.extname(filePath);
-    let fileOutputpath = feature;
-    if ([
-        '.js',
-        '.jsx',
-        '.tsx',
-        '.ts',
-        '.vue',
-        '.svelte'
-    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.js');
-    if ([
-        '.html',
-        '.njk',
-        '.nunjucks'
-    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.html');
-    if ([
-        '.css',
-        '.scss',
-        '.sass',
-        '.less'
-    ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.css');
-    return unixify(fileOutputpath || '');
-}
-function unixify(filePath) {
-    return filePath.replace(/\\/g, '/');
-}
 function background_background(manifest) {
     return manifest.background && manifest.background.scripts && {
         background: {
@@ -2159,12 +2220,14 @@ async function buildCssRules(projectPath, mode, usage, opts) {
                 test: /\.(sass|scss)$/,
                 exclude: /\.module\.(sass|scss)$/,
                 type: nonModuleType,
-                loader: null
+                loader: null,
+                missingTool: 'sass'
             },
             {
                 test: /\.module\.(sass|scss)$/,
                 type: 'css/module',
-                loader: null
+                loader: null,
+                missingTool: 'sass'
             }
         ],
         ...useLess ? [
@@ -2184,16 +2247,18 @@ async function buildCssRules(projectPath, mode, usage, opts) {
                 test: /\.less$/,
                 exclude: /\.module\.less$/,
                 type: nonModuleType,
-                loader: null
+                loader: null,
+                missingTool: 'less'
             },
             {
                 test: /\.module\.less$/,
                 type: 'css/module',
-                loader: null
+                loader: null,
+                missingTool: 'less'
             }
         ]
     ];
-    return Promise.all(fileTypes.map(async ({ test, exclude, type, loader })=>{
+    return Promise.all(fileTypes.map(async ({ test, exclude, type, loader, missingTool })=>{
         const use = loader ? await commonStyleLoaders(projectPath, {
             mode: mode,
             loader,
@@ -2203,6 +2268,9 @@ async function buildCssRules(projectPath, mode, usage, opts) {
         }) : await commonStyleLoaders(projectPath, {
             mode: mode
         });
+        if (missingTool) use.push({
+            loader: resolveDevelopDistFile('preprocessor-passthrough-loader')
+        });
         return {
             test,
             exclude,
@@ -2302,7 +2370,53 @@ class CssPlugin {
             console.log(cssConfigsDetected(postcssConfig, tailwindConfig, browserslistSource));
         }
     }
+    tolerateDeadUrlRefs(compiler) {
+        const manifestDir = __rspack_external_path.dirname(this.manifestPath);
+        const projectPath = compiler.options.context || process.cwd();
+        const roots = [
+            __rspack_external_path.join(projectPath, 'public'),
+            manifestDir
+        ];
+        const assetExt = /\.(png|jpe?g|gif|webp|svg|avif|ico|bmp|cur|woff2?|ttf|otf|eot|mp3|mp4|webm|ogg|wav)$/i;
+        let compilation = null;
+        const warned = new Set();
+        if (!compiler.hooks?.thisCompilation?.tap || !compiler.hooks?.normalModuleFactory?.tap) return;
+        compiler.hooks.thisCompilation.tap(`${CssPlugin.name}:dead-url`, (c)=>{
+            compilation = c;
+            warned.clear();
+        });
+        compiler.hooks.normalModuleFactory.tap(`${CssPlugin.name}:dead-url`, (nmf)=>{
+            nmf.hooks.beforeResolve.tap(`${CssPlugin.name}:dead-url`, (data)=>{
+                const issuer = String(data?.contextInfo?.issuer || '').split('?')[0];
+                if (!/\.(css|scss|sass|less)$/i.test(issuer)) return;
+                const raw = String(data?.request || '');
+                const req = raw.split('?')[0].split('#')[0];
+                if (!req || req.startsWith('//') || /^[a-z][a-z0-9+.-]*:/i.test(req)) return;
+                if (req.startsWith('~') || req.startsWith('@')) return;
+                const isRootRef = req.startsWith('/');
+                const isRelativeRef = req.startsWith('./') || req.startsWith('../');
+                const isBareAssetRef = !isRootRef && !isRelativeRef && assetExt.test(req);
+                if (!isRootRef && !isRelativeRef && !isBareAssetRef) return;
+                const issuerDir = data?.context || __rspack_external_path.dirname(issuer);
+                const candidates = isRootRef ? roots.map((root)=>__rspack_external_path.join(root, req.slice(1))) : [
+                    __rspack_external_path.resolve(issuerDir, req),
+                    ...isBareAssetRef ? roots.map((root)=>__rspack_external_path.join(root, req)) : []
+                ];
+                if (candidates.some((candidate)=>__rspack_external_fs.existsSync(candidate))) return;
+                if ('true' === process.env.EXTENSION_STRICT_REFS) return;
+                const key = `${issuer}|${req}`;
+                if (!warned.has(key) && compilation?.warnings) {
+                    warned.add(key);
+                    const warning = new core_WebpackError(deadCssUrlRef(__rspack_external_path.relative(manifestDir, issuer) || issuer, raw));
+                    warning.file = __rspack_external_path.relative(manifestDir, issuer);
+                    compilation.warnings.push(warning);
+                }
+                return false;
+            });
+        });
+    }
     async apply(compiler) {
+        this.tolerateDeadUrlRefs(compiler);
         const mode = compiler.options.mode || 'development';
         if ('production' === mode) return void compiler.hooks.beforeRun.tapPromise(CssPlugin.name, ()=>this.configureOptions(compiler));
         const configuring = this.configureOptions(compiler);
@@ -2353,7 +2467,7 @@ class StaticAssetsPlugin {
             rules: []
         };
         compiler.options.module.rules = compiler.options.module.rules || [];
-        const filenamePattern = 'production' === this.mode ? 'assets/[name].[contenthash:8][ext]' : 'assets/[name][ext]';
+        const filenamePattern = 'assets/[name].[contenthash:8][ext]';
         const defaultSvgRule = {
             test: /\.svg$/i,
             type: 'asset',
@@ -3872,8 +3986,7 @@ function emitDirectoryAsAssets(compilation, absDir, baseDir) {
     walk(absDir);
 }
 function emitFileAsAsset(compilation, absPath) {
-    const mode = compilation.options?.mode || 'development';
-    const filenamePattern = 'production' === mode ? 'assets/[name].[contenthash:8][ext]' : 'assets/[name][ext]';
+    const filenamePattern = 'assets/[name].[contenthash:8][ext]';
     const ext = __rspack_external_path.extname(absPath);
     const name = __rspack_external_path.basename(absPath, ext);
     const content = __rspack_external_fs.readFileSync(absPath);
@@ -4306,15 +4419,32 @@ const DEV_CONNECT_SOURCES = [
     'http://127.0.0.1:*',
     'http://localhost:*'
 ];
+const LOOPBACK_HOSTS = new Set([
+    '127.0.0.1',
+    'localhost',
+    '[::1]',
+    '::1'
+]);
+function devConnectSources() {
+    const sources = [
+        ...DEV_CONNECT_SOURCES
+    ];
+    const raw = String(process.env.EXTENSION_DEV_SERVER_CONNECTABLE_HOST || '').trim();
+    if (!raw || LOOPBACK_HOSTS.has(raw)) return sources;
+    const host = raw.includes(':') && !raw.startsWith('[') ? `[${raw}]` : raw;
+    sources.push(`ws://${host}:*`, `http://${host}:*`);
+    return sources;
+}
 function loosenConnectSrcForDev(csp) {
+    const devSources = devConnectSources();
     const connectSrc = csp.get('connect-src');
     const defaultSrc = csp.get('default-src');
     if (connectSrc) {
-        for (const source of DEV_CONNECT_SOURCES)if (!connectSrc.includes(source)) connectSrc.push(source);
+        for (const source of devSources)if (!connectSrc.includes(source)) connectSrc.push(source);
         csp.set('connect-src', connectSrc);
     } else if (defaultSrc) csp.set('connect-src', [
         ...defaultSrc,
-        ...DEV_CONNECT_SOURCES
+        ...devSources
     ]);
 }
 function patchV2CSP(manifest) {
@@ -4779,6 +4909,7 @@ function javaScriptError(errorSourcePath, missingFilePath, opts) {
     lines.push(`Missing script file in ${pintor.underline(errorSourcePath)}.`);
     lines.push(`Update your ${pintor.yellow("<script>")} src to point to a file that exists.`);
     if (opts?.publicRootHint) lines.push(`Paths starting with '/' are resolved from the extension output root (served from ${pintor.yellow('public/')}), not your source directory.`);
+    if (opts?.deadRefHint) lines.push(`Chrome loads the page anyway and 404s this reference silently — likely dead code. Set ${pintor.yellow('EXTENSION_STRICT_REFS=true')} to make this a build error.`);
     lines.push('');
     lines.push(`${pintor.red('NOT FOUND')} ${pintor.underline(missingFilePath)}`);
     return lines.join('\n');
@@ -4788,6 +4919,7 @@ function cssError(errorSourcePath, missingFilePath, opts) {
     lines.push(`Missing stylesheet in ${pintor.underline(errorSourcePath)}.`);
     lines.push(`Update your ${pintor.yellow('<link>')} href to point to a file that exists.`);
     if (opts?.publicRootHint) lines.push(`Paths starting with '/' are resolved from the extension output root (served from ${pintor.yellow('public/')}), not your source directory.`);
+    if (opts?.deadRefHint) lines.push(`Chrome loads the page anyway and 404s this reference silently — likely dead code. Set ${pintor.yellow('EXTENSION_STRICT_REFS=true')} to make this a build error.`);
     lines.push('');
     lines.push(`${pintor.red('NOT FOUND')} ${pintor.underline(missingFilePath)}`);
     return lines.join('\n');
@@ -4799,6 +4931,7 @@ function staticAssetError(errorSourcePath, missingFilePath, opts) {
     const ref = opts?.refLabel || '*' + extname;
     lines.push(`Update the ${pintor.yellow(ref)} reference to point to a file that exists.`);
     if (opts?.publicRootHint) lines.push(`Paths starting with '/' are resolved from the extension output root (served from ${pintor.yellow('public/')}), not your source directory.`);
+    if (opts?.deadRefHint) lines.push(`Chrome loads the page anyway and 404s this reference silently — likely dead code. Set ${pintor.yellow('EXTENSION_STRICT_REFS=true')} to make this a build error.`);
     lines.push('');
     lines.push(`${pintor.red('NOT FOUND')} ${pintor.underline(missingFilePath)}`);
     return lines.join('\n');
@@ -5127,6 +5260,7 @@ function warnMissingPublicRootResources(params) {
         const trimmed = publicRootUrl.replace(/^\//, '');
         const publicRootAbs = __rspack_external_path.join(publicRootForResource, trimmed);
         const outputRootAssetAbs = __rspack_external_path.join(outputRoot, trimmed);
+        if (resolveRootAbsoluteRef(publicRootUrl, projectRoot, publicRootForResource)) return;
         if (!__rspack_external_fs.existsSync(publicRootAbs) && !__rspack_external_fs.existsSync(outputRootAssetAbs)) {
             const displayPath = __rspack_external_path.join(outputRoot, trimmed);
             reportToCompilation(compilation, compiler, fileNotFound(resource, displayPath, {
@@ -5140,12 +5274,15 @@ function warnMissingPublicRootResources(params) {
 }
 function checkMissingLocalEntries(params) {
     const { compilation, compiler, resource, manifestDir, projectRoot, js, css } = params;
+    const strictRefs = 'true' === process.env.EXTENSION_STRICT_REFS;
     const check = (url)=>{
         if (!url || isHttpLike(url) || isSpecialScheme(url)) return;
-        if (url.startsWith('/') && !__rspack_external_path.isAbsolute(url)) return;
+        if (url.startsWith('/') && !url.startsWith(projectRoot)) return;
         if (!__rspack_external_fs.existsSync(url)) {
             const displayFile = __rspack_external_path.relative(manifestDir, resource);
-            reportToCompilation(compilation, compiler, fileNotFound(displayFile, url), 'error', displayFile);
+            reportToCompilation(compilation, compiler, fileNotFound(displayFile, url, {
+                deadRefHint: !strictRefs
+            }), strictRefs ? 'error' : 'warning', displayFile);
         }
     };
     js?.forEach(check);
@@ -5315,12 +5452,15 @@ function isClassicScript(filePath) {
     }
 }
 function classicConcatEntry(feature, jsFiles) {
+    const deduped = [
+        ...new Set(jsFiles)
+    ];
     const queryData = encodeURIComponent(JSON.stringify({
         feature,
-        js: jsFiles,
+        js: deduped,
         css: []
     }));
-    return `${jsFiles[0]}?__extensionjs_classic_concat__=${queryData}`;
+    return `${deduped[0]}?__extensionjs_classic_concat__=${queryData}`;
 }
 const WILDCARD_HOSTS = new Set([
     '0.0.0.0',
@@ -5426,8 +5566,6 @@ class AddScriptsAndStylesToCompilation {
         const htmlEntries = this.includeList || {};
         const manifestDir = __rspack_external_path.dirname(this.manifestPath);
         const projectRoot = compiler.options.context || manifestDir;
-        const publicDir = __rspack_external_path.join(projectRoot, 'public');
-        const hasPublicDir = __rspack_external_fs.existsSync(publicDir);
         const devServerHmrImports = 'development' === compiler.options.mode ? getDevServerHmrImports(compiler) : [];
         for (const field of Object.entries(htmlEntries)){
             const [feature, resource] = field;
@@ -5435,9 +5573,10 @@ class AddScriptsAndStylesToCompilation {
                 if (!__rspack_external_fs.existsSync(resource)) continue;
                 const htmlAssets = getAssetsFromHtml(resource);
                 const isRemoteUrl = (p)=>/^(https?:)?\/\//i.test(p);
-                const looksLikePublicRootUrl = (p)=>p.startsWith('/public/') || p.startsWith('/') && !p.startsWith(projectRoot) && hasPublicDir;
-                const jsAssets = (htmlAssets?.js || []).filter((asset)=>!looksLikePublicRootUrl(asset) && !isRemoteUrl(asset));
-                const cssAssets = (htmlAssets?.css || []).filter((asset)=>!looksLikePublicRootUrl(asset) && !isRemoteUrl(asset));
+                const looksLikePublicRootUrl = (p)=>p.startsWith('/public/') || p.startsWith('/') && !p.startsWith(projectRoot);
+                const isMissingLocalFile = (p)=>__rspack_external_path.isAbsolute(p) && !__rspack_external_fs.existsSync(p);
+                const jsAssets = (htmlAssets?.js || []).filter((asset)=>!looksLikePublicRootUrl(asset) && !isRemoteUrl(asset) && !isMissingLocalFile(asset));
+                const cssAssets = (htmlAssets?.css || []).filter((asset)=>!looksLikePublicRootUrl(asset) && !isRemoteUrl(asset) && !isMissingLocalFile(asset));
                 const moduleJsAssets = new Set(htmlAssets?.moduleJs || []);
                 const concatenateClassic = jsAssets.length > 1 && jsAssets.every((asset)=>!moduleJsAssets.has(asset) && /\.(js|cjs)$/i.test(asset) && isClassicScript(asset));
                 const jsImports = concatenateClassic ? [
@@ -5935,7 +6074,8 @@ const isScriptsFolderFeature = (feature)=>feature.startsWith("scripts/");
 const isBackgroundScriptsFeature = (feature)=>"background/scripts" === feature;
 function createSequentialEntryModule(feature, scriptImports) {
     const jsFiles = scriptImports;
-    const concatenateClassic = jsFiles.length > 1 && jsFiles.every(isClassicScript);
+    const concatEligible = (f)=>/\.(js|cjs|ts)$/i.test(f);
+    const concatenateClassic = jsFiles.length > 1 && jsFiles.every((f)=>concatEligible(f) && isClassicScript(f));
     if (concatenateClassic) return classicConcatEntry(feature, jsFiles);
     const source = [
         `/* extension.js sequential entry: ${feature} */`,
@@ -7873,6 +8013,16 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
         return;
       }
 
+      // Delivery ack for the broker: proves this SW's message pump actually
+      // processed the frame — a successful socket WRITE proves nothing when
+      // the worker is wedged-but-connected (bug 27). The broker latches a
+      // content-scripts reload until this ack and replays it to the next
+      // producer hello, so an edit that landed on a dead pump still converges.
+      // Sent on receipt (not after reinjection): the scripting-unavailable
+      // fallback restarts the whole extension, and an unacked latch would
+      // replay into the fresh SW and restart it a second time.
+      send({type: "reload-ack", reloadType: kind, label: label});
+
       announceReloadInTabs(announced);
       performDevReload(kind, function () {
         // Only the content-scripts path confirms from here (reinjection ran to
@@ -7984,31 +8134,56 @@ const BRIDGE_PRODUCER_SOURCE = `;(function () {
 
     // Multi-context console forwarding: other contexts (content scripts, surface
     // pages) can't reliably open ws://127.0.0.1 (page CSP / connect-src), so they
-    // relay console via chrome.runtime.sendMessage to this SW, which owns the WS.
-    // We enrich with the real tabId/url from the message sender.
+    // relay console to this SW, which owns the WS. The relay travels a NAMED
+    // runtime.Port — never runtime.sendMessage — because port traffic is
+    // invisible to the extension's own onMessage listeners. With sendMessage, an
+    // extension whose SW echoes every message back to its tabs (wild newtube:
+    // onMessage → tabs.sendMessage(msg) to all tabs) turned each relayed log
+    // into a new tab message, whose subject-side console.log became another
+    // relayed envelope — a self-sustaining dev-only message storm (25k rows/10min
+    // observed) that starved the extension system and wedged Chromium's DevTools
+    // endpoint (family B). We enrich with the real tabId/url from the port sender.
+    function shipRelayedLog(ev, sender) {
+      try {
+        send({
+          type: "log",
+          event: {
+            v: 1,
+            id: nowId(),
+            timestamp: Date.now(),
+            level: ev.level || "log",
+            context: ev.context || "content",
+            messageParts: Array.isArray(ev.messageParts) ? ev.messageParts : [],
+            url: ev.url || (sender ? sender.url : undefined),
+            tabId: sender && sender.tab ? sender.tab.id : undefined,
+            frameId: sender ? sender.frameId : undefined,
+            runId: INSTANCE_ID
+          }
+        });
+      } catch (e) {}
+    }
+    try {
+      var rtPort = g.chrome;
+      if (rtPort && rtPort.runtime && rtPort.runtime.onConnect) {
+        rtPort.runtime.onConnect.addListener(function (port) {
+          if (!port || port.name !== "__extjs-bridge-log__") return;
+          try {
+            port.onMessage.addListener(function (msg) {
+              if (!msg || !msg.__extjsBridgeLog) return;
+              shipRelayedLog(msg.__extjsBridgeLog, port.sender);
+            });
+          } catch (e) {}
+        });
+      }
+    } catch (e) {}
+    // Legacy sendMessage path: kept for any surface still relaying the old way
+    // (harmless one-predicate listener; new relays never use it).
     try {
       var rt = g.chrome;
       if (rt && rt.runtime && rt.runtime.onMessage) {
         rt.runtime.onMessage.addListener(function (msg, sender) {
           if (!msg || !msg.__extjsBridgeLog) return;
-          var ev = msg.__extjsBridgeLog;
-          try {
-            send({
-              type: "log",
-              event: {
-                v: 1,
-                id: nowId(),
-                timestamp: Date.now(),
-                level: ev.level || "log",
-                context: ev.context || "content",
-                messageParts: Array.isArray(ev.messageParts) ? ev.messageParts : [],
-                url: ev.url || (sender ? sender.url : undefined),
-                tabId: sender && sender.tab ? sender.tab.id : undefined,
-                frameId: sender ? sender.frameId : undefined,
-                runId: INSTANCE_ID
-              }
-            });
-          } catch (e) {}
+          shipRelayedLog(msg.__extjsBridgeLog, sender);
           // No async response.
         });
       }
@@ -8071,7 +8246,8 @@ const BRIDGE_RELAY_SOURCE = `;(function () {
 
     var CONTEXT = "__EXTJS_CONTEXT__";
     var chrome = g.chrome;
-    if (!chrome || !chrome.runtime || typeof chrome.runtime.sendMessage !== "function") return;
+    if (!chrome || !chrome.runtime) return;
+    var canRelay = typeof chrome.runtime.connect === "function";
 
     g.__extjsBridgeRelayInstalled = true;
     var consoleRef = g.console || {};
@@ -8093,14 +8269,39 @@ const BRIDGE_RELAY_SOURCE = `;(function () {
 
     function here() { try { return g.location ? g.location.href : undefined; } catch (e) { return undefined; } }
 
+    // Lazy named port to the SW producer. Connecting wakes an idle SW like
+    // sendMessage does, but port frames never reach the extension's own
+    // onMessage listeners (see the loop note above). Reconnect on demand: the
+    // SW idling out (or reloading) disconnects the port; the next log redials.
+    var logPort = null;
+    function getLogPort() {
+      if (!canRelay) return null;
+      if (logPort) return logPort;
+      try {
+        logPort = chrome.runtime.connect({name: "__extjs-bridge-log__"});
+        logPort.onDisconnect.addListener(function () {
+          try { void chrome.runtime.lastError; } catch (e) {}
+          logPort = null;
+        });
+      } catch (e) { logPort = null; }
+      return logPort;
+    }
+
     LEVELS.forEach(function (level) {
       var orig = typeof consoleRef[level] === "function" ? consoleRef[level].bind(consoleRef) : function () {};
       consoleRef[level] = function () {
         try {
-          chrome.runtime.sendMessage(
-            {__extjsBridgeLog: {level: level, context: CONTEXT, messageParts: sanitize([].slice.call(arguments)), url: here()}},
-            function () { void chrome.runtime.lastError; } // swallow "no receiver" while the SW wakes
-          );
+          var p = getLogPort();
+          if (p) {
+            try {
+              p.postMessage({__extjsBridgeLog: {level: level, context: CONTEXT, messageParts: sanitize([].slice.call(arguments)), url: here()}});
+            } catch (e) {
+              // stale port (SW restarted): drop it and redial once
+              logPort = null;
+              var p2 = getLogPort();
+              if (p2) { try { p2.postMessage({__extjsBridgeLog: {level: level, context: CONTEXT, messageParts: sanitize([].slice.call(arguments)), url: here()}}); } catch (e2) {} }
+            }
+          }
         } catch (e) {}
         return orig.apply(consoleRef, arguments);
       };
@@ -10524,6 +10725,26 @@ function webpackConfig(projectStructure, devOptions) {
                 'node_modules',
                 __rspack_external_path.join(process.cwd(), 'node_modules')
             ],
+            roots: [
+                __rspack_external_path.join(packageJsonDir, 'public'),
+                __rspack_external_path.dirname(manifestPath)
+            ],
+            extensionAlias: {
+                '.js': [
+                    '.ts',
+                    '.tsx',
+                    '.js',
+                    '.jsx'
+                ],
+                '.mjs': [
+                    '.mts',
+                    '.mjs'
+                ],
+                '.cjs': [
+                    '.cts',
+                    '.cjs'
+                ]
+            },
             extensions: [
                 '.js',
                 '.cjs',
@@ -10588,6 +10809,7 @@ function webpackConfig(projectStructure, devOptions) {
             hints: false
         },
         optimization: {
+            emitOnErrors: false,
             minimize: 'production' === devOptions.mode,
             sideEffects: true,
             usedExports: 'global',