extension-develop 3.8.16 → 3.9.0-canary.231.7b387a7

package/dist/323.cjs

@@ -268,20 +268,7 @@ exports.modules = {
         class CDPExtensionController {
             async connect() {
                 if (this.cdp) return;
-                this.cdp = await connectToChromeCdp(this.cdpPort);
-                try {
-                    await this.cdp.sendCommand('Target.setDiscoverTargets', {
-                        discover: true
-                    });
-                    await this.cdp.sendCommand('Target.setAutoAttach', {
-                        autoAttach: true,
-                        waitForDebuggerOnStart: false,
-                        flatten: true
-                    });
-                } catch (error) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.wXK(String(error?.message || error)));
-                }
-                registerAutoEnableLogging(this.cdp, ()=>this.extensionId);
+                await this.connectFreshClient();
             }
             async ensureLoaded() {
                 if (!this.cdp) throw new Error('CDP not connected');
@@ -387,14 +374,72 @@ exports.modules = {
                 } catch  {}
                 return null;
             }
+            getDeveloperModeStatus() {
+                if (!this.profilePath) return 'unknown';
+                const prefCandidates = [];
+                const seen = new Set();
+                const addPrefCandidate = (dir)=>{
+                    const prefPath = external_path_.join(dir, 'Preferences');
+                    if (!external_fs_.existsSync(prefPath)) return;
+                    const dedupeKey = external_path_.resolve(prefPath);
+                    if (seen.has(dedupeKey)) return;
+                    seen.add(dedupeKey);
+                    prefCandidates.push(prefPath);
+                };
+                try {
+                    addPrefCandidate(this.profilePath);
+                    addPrefCandidate(external_path_.join(this.profilePath, 'Default'));
+                    for (const entry of external_fs_.readdirSync(this.profilePath))if (/^Profile\s+\d+$/i.test(entry)) addPrefCandidate(external_path_.join(this.profilePath, entry));
+                } catch  {}
+                for (const prefPath of prefCandidates)try {
+                    const prefs = JSON.parse(external_fs_.readFileSync(prefPath, 'utf-8'));
+                    const uiFlag = prefs?.extensions?.ui?.developer_mode;
+                    if ('boolean' == typeof uiFlag) return uiFlag ? 'enabled' : 'disabled';
+                    const legacyFlag = prefs?.extensions?.developer_mode;
+                    if ('boolean' == typeof legacyFlag) return legacyFlag ? 'enabled' : 'disabled';
+                } catch  {}
+                return 'unknown';
+            }
             async hardReload() {
-                if (!this.cdp || !this.extensionId) return false;
+                if (!this.extensionId) return false;
+                try {
+                    if (!this.cdp) await this.connectFreshClient();
+                    if (this.cdp && await this.cdp.forceReloadExtension(this.extensionId)) return true;
+                } catch  {}
                 try {
-                    return await this.cdp.forceReloadExtension(this.extensionId);
+                    await this.reconnectForReload();
+                    return Boolean(this.cdp && this.extensionId && await this.cdp.forceReloadExtension(this.extensionId));
                 } catch  {
                     return false;
                 }
             }
+            async connectFreshClient() {
+                this.cdp = await connectToChromeCdp(this.cdpPort);
+                try {
+                    await this.cdp.sendCommand('Target.setDiscoverTargets', {
+                        discover: true
+                    });
+                    await this.cdp.sendCommand('Target.setAutoAttach', {
+                        autoAttach: true,
+                        waitForDebuggerOnStart: false,
+                        flatten: true
+                    });
+                } catch (error) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.wXK(String(error?.message || error)));
+                }
+                registerAutoEnableLogging(this.cdp, ()=>this.extensionId);
+            }
+            async reconnectForReload() {
+                try {
+                    this.cdp?.disconnect?.();
+                } catch  {}
+                this.cdp = null;
+                await this.connectFreshClient();
+                try {
+                    const derivedExtensionId = await this.deriveExtensionIdFromTargets(10, 150);
+                    if (derivedExtensionId) this.extensionId = derivedExtensionId;
+                } catch  {}
+            }
             onProtocolEvent(cb) {
                 if (!this.cdp) throw new Error('CDP not connected');
                 this.cdp.onProtocolEvent((raw)=>{

package/dist/{928.cjs → 324.cjs}

@@ -1,117 +1,20 @@
 "use strict";
 exports.ids = [
-    "928"
+    "324"
 ];
 exports.modules = {
     "./webpack/dev-server/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             devServer: ()=>dev_server_devServer
         });
+        var external_fs_ = __webpack_require__("fs");
+        var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_);
         var external_path_ = __webpack_require__("path");
+        var external_stream_ = __webpack_require__("stream");
         var core_ = __webpack_require__("@rspack/core");
         var dev_server_ = __webpack_require__("@rspack/dev-server");
         var external_webpack_merge_ = __webpack_require__("webpack-merge");
-        var external_fs_ = __webpack_require__("fs");
-        var external_pintor_ = __webpack_require__("pintor");
-        var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_);
-        function getLoggingPrefix(type) {
-            const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-            if (isAuthor) {
-                const base = 'error' === type ? 'ERROR Author says' : '►►► Author says';
-                return external_pintor_default().brightMagenta(base);
-            }
-            if ('error' === type) return external_pintor_default().red('ERROR');
-            if ('warn' === type) return external_pintor_default().brightYellow('►►►');
-            if ('info' === type) return external_pintor_default().gray('►►►');
-            return external_pintor_default().green('►►►');
-        }
-        function messages_ready(mode, browser) {
-            const extensionOutput = 'firefox' === browser || 'gecko-based' === browser || 'edge' === browser ? 'Add-on' : 'Extension';
-            const b = String(browser || '');
-            const cap = b.charAt(0).toUpperCase() + b.slice(1);
-            const pretty = external_pintor_default().green('ready for ' + mode);
-            return `${getLoggingPrefix('info')} ${cap} ${extensionOutput} ${pretty}.`;
-        }
-        function readJsonRecord(filePath) {
-            try {
-                return JSON.parse(external_fs_.readFileSync(filePath, 'utf8'));
-            } catch  {
-                return null;
-            }
-        }
-        function capitalizeToken(value) {
-            return value.split('-').filter(Boolean).map((token)=>token.charAt(0).toUpperCase() + token.slice(1)).join('-');
-        }
-        function getExtensionVersion() {
-            return process.env.EXTENSION_DEVELOP_VERSION || process.env.EXTENSION_CLI_VERSION || (()=>{
-                try {
-                    return __webpack_require__("./package.json").rE;
-                } catch  {
-                    return 'unknown';
-                }
-            })();
-        }
-        function browserRunnerDisabled(args) {
-            const manifest = readJsonRecord(args.manifestPath);
-            const ready = readJsonRecord(args.readyPath);
-            const browserLabel = capitalizeToken(String(args.browser || 'unknown'));
-            const runId = String(ready?.runId || '').trim();
-            const pid = Number.isInteger(ready?.pid) ? String(ready?.pid) : '';
-            const runLabel = runId ? `${external_pintor_default().gray(runId)}${pid ? ` · ${external_pintor_default().gray(`PID ${pid}`)}` : ''}` : pid ? external_pintor_default().gray(`PID ${pid}`) : external_pintor_default().gray('n/a');
-            const extensionName = String(manifest?.name || 'Extension');
-            const extensionVersion = String(manifest?.version || '').trim();
-            const extensionLabel = extensionVersion ? `${extensionName} ${extensionVersion}` : extensionName;
-            const extensionJsVersion = getExtensionVersion();
-            return [
-                ` 🧩 ${external_pintor_default().brightBlue('Extension.js')} ${external_pintor_default().gray(extensionJsVersion)}`,
-                `    Browser        ${external_pintor_default().gray(`${browserLabel} (build-only mode)`)}`,
-                `    Extension      ${external_pintor_default().gray(extensionLabel)}`,
-                `    Run ID         ${runLabel}`
-            ].join('\n');
-        }
-        function portInUse(requestedPort, newPort) {
-            return `Port: Requested port ${external_pintor_default().brightBlue(requestedPort.toString())} is in use; using ${external_pintor_default().brightBlue(newPort.toString())} instead.`;
-        }
-        function extensionJsRunnerError(error) {
-            return `Extension.js Runner Error:\n${external_pintor_default().red(String(error))}`;
-        }
-        function autoExitModeEnabled(ms) {
-            return `Auto-exit enabled. Will exit after ${external_pintor_default().brightBlue(ms.toString())} ms if idle.`;
-        }
-        function autoExitTriggered(ms) {
-            return `Auto-exit triggered after ${external_pintor_default().brightBlue(ms.toString())} ms. Cleaning up...`;
-        }
-        function autoExitForceKill(ms) {
-            return `Force-killing process after ${external_pintor_default().brightBlue(ms.toString())} ms to ensure exit.`;
-        }
-        function devServerStartTimeout(ms) {
-            return [
-                `Dev server startup is taking longer than expected (${external_pintor_default().brightBlue(ms.toString())} ms).`,
-                "The bundler may have encountered an error before emitting the first build.",
-                `If nothing else prints, try setting ${external_pintor_default().brightBlue('EXTENSION_VERBOSE=1')} for more logs.`
-            ].join('\n');
-        }
-        function bundlerFatalError(error) {
-            const text = error instanceof Error ? error.stack || error.message : String(error);
-            return `Build failed to start:\n${external_pintor_default().red(text)}`;
-        }
-        function bundlerRecompiling() {
-            return "Recompiling due to file changes…";
-        }
-        function noEntrypointsDetected(port) {
-            return [
-                "No entrypoints or assets were produced by the initial compilation.",
-                `The dev server is running on 127.0.0.1:${external_pintor_default().brightBlue(port.toString())}, but nothing is being built.`,
-                "Possible causes:",
-                "  • Empty or missing entry configuration.",
-                "  • Extension-related plugins are disabled (entries not derived from manifest).",
-                "  • All sources are ignored or excluded.",
-                `Try enabling verbose logs with ${external_pintor_default().brightBlue('EXTENSION_VERBOSE=1')} or review your extension config.`
-            ].join('\n');
-        }
-        function spacerLine() {
-            return ' ';
-        }
+        var messages = __webpack_require__("./webpack/dev-server/messages.ts");
         var external_crypto_ = __webpack_require__("crypto");
         var external_net_ = __webpack_require__("net");
         var shared_utils = __webpack_require__("./webpack/plugin-browsers/browsers-lib/shared-utils.ts");
@@ -224,60 +127,7 @@ exports.modules = {
         var resolve_config = __webpack_require__("./webpack/feature-special-folders/folder-extensions/resolve-config.ts");
         var get_data = __webpack_require__("./webpack/feature-special-folders/get-data.ts");
         var sanitize = __webpack_require__("./webpack/webpack-lib/sanitize.ts");
-        var branding = __webpack_require__("./webpack/webpack-lib/branding.ts");
-        function setupCompilerHooks(compiler, port) {
-            const verbose = '1' === String(process.env.EXTENSION_VERBOSE || '').trim();
-            let reportedNoEntries = false;
-            compiler.hooks.invalid.tap('extension.js:invalid', ()=>{
-                if (verbose) console.log(bundlerRecompiling());
-            });
-            compiler.hooks.failed.tap('extension.js:failed', (error)=>{
-                console.error(bundlerFatalError(error));
-            });
-            compiler.hooks.done.tap('extension.js:done', (stats)=>{
-                try {
-                    if (stats?.hasErrors?.()) {
-                        const str = stats?.toString?.({
-                            colors: true,
-                            all: false,
-                            errors: true,
-                            warnings: true
-                        });
-                        if (str) console.error((0, branding.h)(str));
-                    } else if (stats?.hasWarnings?.()) {
-                        const str = stats?.toString?.({
-                            colors: true,
-                            all: false,
-                            errors: false,
-                            warnings: true
-                        });
-                        if (str) console.warn((0, branding.h)(str));
-                    }
-                    if (!reportedNoEntries) {
-                        const info = stats.toJson({
-                            all: false,
-                            assets: true,
-                            entrypoints: true
-                        });
-                        const hasAssets = Array.isArray(info?.assets) && info.assets.length > 0;
-                        const entrypoints = info?.entrypoints || {};
-                        const hasEntrypoints = entrypoints && Object.keys(entrypoints).length > 0;
-                        if (!hasAssets && !hasEntrypoints) {
-                            reportedNoEntries = true;
-                            console.warn(noEntrypointsDetected(port));
-                        }
-                    }
-                } catch (error) {
-                    const str = stats?.toString({
-                        colors: true,
-                        all: false,
-                        errors: true,
-                        warnings: true
-                    });
-                    if (str) console.error((0, branding.h)(str));
-                }
-            });
-        }
+        var compiler_hooks = __webpack_require__("./webpack/dev-server/compiler-hooks.ts");
         function parseMilliseconds(value) {
             if ('number' == typeof value) return Number.isFinite(value) && value > 0 ? value : null;
             if ('string' == typeof value) {
@@ -292,11 +142,11 @@ exports.modules = {
             const autoExitMs = parseMilliseconds(autoExitMsRaw);
             if (null === autoExitMs) return ()=>{};
             try {
-                console.log(autoExitModeEnabled(autoExitMs));
+                console.log(messages.o6(autoExitMs));
             } catch  {}
             autoExitTimer = setTimeout(async ()=>{
                 try {
-                    console.log(autoExitTriggered(autoExitMs));
+                    console.log(messages.tJ(autoExitMs));
                 } catch  {}
                 await onCleanup();
             }, autoExitMs);
@@ -304,7 +154,7 @@ exports.modules = {
             const forceKillMs = null !== parsedForceKillMs && parsedForceKillMs > 0 ? parsedForceKillMs : autoExitMs + 4000;
             forceKillTimer = setTimeout(()=>{
                 try {
-                    console.log(autoExitForceKill(forceKillMs));
+                    console.log(messages.Df(forceKillMs));
                 } catch  {}
                 process.exit(0);
             }, forceKillMs);
@@ -325,7 +175,7 @@ exports.modules = {
                 await portManager.terminateCurrentInstance();
                 setTimeout(()=>process.exit(), 500);
             }).catch(async (error)=>{
-                console.log(extensionJsRunnerError(error));
+                console.log(messages.VL(error));
                 await portManager.terminateCurrentInstance();
                 setTimeout(()=>process.exit(1), 500);
             });
@@ -362,6 +212,142 @@ exports.modules = {
         }
         var plugin_playwright = __webpack_require__("./webpack/plugin-playwright/index.ts");
         var webpack_config = __webpack_require__("./webpack/webpack-config.ts");
+        function shouldWriteAssetToDisk(filePath) {
+            return !/(?:^|[/\\])manifest\.json$/i.test(filePath);
+        }
+        function isSamePath(left, right) {
+            return external_path_.resolve(left) === external_path_.resolve(right);
+        }
+        function isManifestTempPath(filePath) {
+            const base = external_path_.basename(filePath);
+            return base.startsWith('.manifest.') && base.endsWith('.tmp');
+        }
+        function createDiscardWriteStream() {
+            const stream = new external_stream_.Writable({
+                write (_chunk, _encoding, callback) {
+                    callback();
+                }
+            });
+            stream.on('finish', ()=>{
+                stream.emit('close');
+            });
+            process.nextTick(()=>{
+                stream.emit('open', 0);
+            });
+            return stream;
+        }
+        const guardedManifestDiskWritePaths = new Set();
+        let isManifestDiskWriteGuardInstalled = false;
+        function hasGuardedManifestDiskPath(filePath) {
+            if ('string' != typeof filePath) return false;
+            const resolvedPath = external_path_.resolve(filePath);
+            for (const guardedPath of guardedManifestDiskWritePaths)if (isSamePath(guardedPath, resolvedPath)) return true;
+            return false;
+        }
+        function suppressManifestOutputWrites(compiler, manifestOutputPath) {
+            const outputFileSystem = compiler?.outputFileSystem;
+            if (!outputFileSystem || outputFileSystem.__extensionjsManifestWriteGuard) return;
+            const isManifestPath = (filePath)=>'string' == typeof filePath && isSamePath(filePath, manifestOutputPath);
+            if ('function' == typeof outputFileSystem.writeFile) {
+                const originalWriteFile = outputFileSystem.writeFile.bind(outputFileSystem);
+                outputFileSystem.writeFile = (filePath, ...args)=>{
+                    if (isManifestPath(filePath)) {
+                        const callback = args[args.length - 1];
+                        if ('function' == typeof callback) callback(null);
+                        return;
+                    }
+                    return originalWriteFile(filePath, ...args);
+                };
+            }
+            if ('function' == typeof outputFileSystem.writeFileSync) {
+                const originalWriteFileSync = outputFileSystem.writeFileSync.bind(outputFileSystem);
+                outputFileSystem.writeFileSync = (filePath, ...args)=>{
+                    if (isManifestPath(filePath)) return;
+                    return originalWriteFileSync(filePath, ...args);
+                };
+            }
+            if ('function' == typeof outputFileSystem.createWriteStream) {
+                const originalCreateWriteStream = outputFileSystem.createWriteStream.bind(outputFileSystem);
+                outputFileSystem.createWriteStream = (filePath, ...args)=>{
+                    if (isManifestPath(filePath)) {
+                        const stream = createDiscardWriteStream();
+                        stream.path = filePath;
+                        return stream;
+                    }
+                    return originalCreateWriteStream(filePath, ...args);
+                };
+            }
+            if ('function' == typeof outputFileSystem?.promises?.writeFile) {
+                const originalPromiseWriteFile = outputFileSystem.promises.writeFile.bind(outputFileSystem.promises);
+                outputFileSystem.promises.writeFile = async (filePath, ...args)=>{
+                    if (isManifestPath(filePath)) return;
+                    return originalPromiseWriteFile(filePath, ...args);
+                };
+            }
+            outputFileSystem.__extensionjsManifestWriteGuard = true;
+        }
+        function installManifestDiskWriteGuard(manifestOutputPath) {
+            const guardKey = external_path_.resolve(manifestOutputPath);
+            guardedManifestDiskWritePaths.add(guardKey);
+            if (isManifestDiskWriteGuardInstalled) return;
+            const guardedFs = external_fs_default();
+            const isManifestPath = (filePath)=>hasGuardedManifestDiskPath(filePath);
+            const allowManifestRename = (fromPath, toPath)=>'string' == typeof fromPath && 'string' == typeof toPath && isManifestPath(toPath) && isManifestTempPath(fromPath);
+            const originalWriteFile = guardedFs.writeFile.bind(guardedFs);
+            guardedFs.writeFile = (filePath, ...args)=>{
+                if (isManifestPath(filePath)) {
+                    const callback = args[args.length - 1];
+                    if ('function' == typeof callback) callback(null);
+                    return;
+                }
+                return originalWriteFile(filePath, ...args);
+            };
+            const originalWriteFileSync = guardedFs.writeFileSync.bind(guardedFs);
+            guardedFs.writeFileSync = (filePath, ...args)=>{
+                if (isManifestPath(filePath)) return;
+                return originalWriteFileSync(filePath, ...args);
+            };
+            const originalCreateWriteStream = guardedFs.createWriteStream.bind(guardedFs);
+            guardedFs.createWriteStream = (filePath, ...args)=>{
+                if (isManifestPath(filePath)) {
+                    const stream = createDiscardWriteStream();
+                    stream.path = String(filePath);
+                    return stream;
+                }
+                return originalCreateWriteStream(filePath, ...args);
+            };
+            const originalOpen = guardedFs.open.bind(guardedFs);
+            guardedFs.open = (pathLike, flags, ...args)=>{
+                const nextPath = isManifestPath(pathLike) ? '/dev/null' : pathLike;
+                return originalOpen(nextPath, flags, ...args);
+            };
+            const originalOpenSync = guardedFs.openSync.bind(guardedFs);
+            guardedFs.openSync = (pathLike, flags, ...args)=>{
+                const nextPath = isManifestPath(pathLike) ? '/dev/null' : pathLike;
+                return originalOpenSync(nextPath, flags, ...args);
+            };
+            const originalRename = guardedFs.rename.bind(guardedFs);
+            guardedFs.rename = (oldPath, newPath, callback)=>{
+                if (isManifestPath(newPath) && !allowManifestRename(oldPath, newPath)) {
+                    if ('function' == typeof callback) callback(null);
+                    return;
+                }
+                return originalRename(oldPath, newPath, callback);
+            };
+            const originalRenameSync = guardedFs.renameSync.bind(guardedFs);
+            guardedFs.renameSync = (oldPath, newPath)=>{
+                if (isManifestPath(newPath) && !allowManifestRename(oldPath, newPath)) return;
+                return originalRenameSync(oldPath, newPath);
+            };
+            if (guardedFs.promises?.writeFile) {
+                const originalPromiseWriteFile = guardedFs.promises.writeFile.bind(guardedFs.promises);
+                guardedFs.promises.writeFile = async (filePath, ...args)=>{
+                    if (isManifestPath(filePath)) return;
+                    return originalPromiseWriteFile(filePath, ...args);
+                };
+            }
+            isManifestDiskWriteGuardInstalled = true;
+        }
         async function dev_server_devServer(projectStructure, devOptions) {
             process.env.EXTENSION_BROWSER_LAUNCH_ENABLED = devOptions.noBrowser ? '0' : '1';
             const { manifestPath, packageJsonPath } = projectStructure;
@@ -421,6 +407,9 @@ exports.modules = {
                 }
             };
             const compiler = (0, core_.rspack)(compilerConfig);
+            const manifestOutputPath = external_path_.join(packageJsonDir, 'dist', devOptions.browser, 'manifest.json');
+            installManifestDiskWriteGuard(manifestOutputPath);
+            suppressManifestOutputWrites(compiler, manifestOutputPath);
             const metadata = (0, plugin_playwright.Ih)({
                 packageJsonDir,
                 browser: String(devOptions.browser || 'chromium'),
@@ -429,8 +418,14 @@ exports.modules = {
                 manifestPath,
                 port
             });
-            setupCompilerHooks(compiler, portAllocation.port);
-            if (void 0 !== devOptions.port && devOptions.port !== port) console.log(portInUse(devOptions.port, port));
+            (0, compiler_hooks.NP)(compiler);
+            if (devOptions.noBrowser) (0, compiler_hooks.y1)({
+                compiler,
+                browser: String(devOptions.browser || 'chromium'),
+                manifestPath,
+                readyPath: metadata.readyPath
+            });
+            if (void 0 !== devOptions.port && devOptions.port !== port) console.log(messages.aO(devOptions.port, port));
             const serverConfig = {
                 host: devServerHost,
                 allowedHosts: 'all',
@@ -440,7 +435,7 @@ exports.modules = {
                 },
                 compress: false,
                 devMiddleware: {
-                    writeToDisk: true,
+                    writeToDisk: shouldWriteAssetToDisk,
                     stats: false
                 },
                 watchFiles: {
@@ -477,22 +472,14 @@ exports.modules = {
             let startTimeout;
             try {
                 startTimeout = setTimeout(()=>{
-                    console.error(devServerStartTimeout(START_TIMEOUT_MS));
+                    console.error(messages.UF(START_TIMEOUT_MS));
                 }, START_TIMEOUT_MS);
                 await devServer.start();
                 if (startTimeout) clearTimeout(startTimeout);
-                console.log(spacerLine());
-                console.log(messages_ready('development', devOptions.browser));
-                if (devOptions.noBrowser) console.log(browserRunnerDisabled({
-                    browser: String(devOptions.browser || 'chromium'),
-                    manifestPath,
-                    readyPath: metadata.readyPath
-                }));
-                console.log(spacerLine());
             } catch (error) {
                 if (startTimeout) clearTimeout(startTimeout);
                 metadata.writeError('dev_server_start_failed', error instanceof Error ? error.message : String(error));
-                console.log(extensionJsRunnerError(error));
+                console.log(messages.VL(error));
                 process.exit(1);
             }
             setupCleanupHandlers(devServer, portManager);

package/dist/552.cjs

@@ -11,7 +11,7 @@ exports.modules = {
         function scrubBrand(txt, brand = 'Extension.js') {
             if (!txt) return txt;
             const safeBrand = brand.replace(/\$/g, '$$$$');
-            return txt.replace(RegExp("(?<!@)\\bRspack\\b", "gi"), safeBrand).replace(RegExp("(?<!@)\\bWebpack\\b", "gi"), safeBrand).replace(RegExp("(?<!@)\\bwebpack-dev-server\\b", "gi"), `${safeBrand} dev server`).replace(RegExp("(?<!@)\\bRspackDevServer\\b", "gi"), `${safeBrand} dev server`).replace(/ModuleBuildError:\s*/g, '').replace(/ModuleParseError:\s*/g, '').replace(/Error:\s*Module\s+build\s+failed.*?\n/gi, '').replace(/\n{3,}/g, '\n\n');
+            return txt.replace(RegExp("(?<!@)\\bRspack\\b", "gi"), safeBrand).replace(RegExp("(?<!@)\\bWebpack\\b", "gi"), safeBrand).replace(RegExp("(?<!@)\\bwebpack-dev-server\\b", "gi"), `${safeBrand} dev server`).replace(RegExp("(?<!@)\\bRspackDevServer\\b", "gi"), `${safeBrand} dev server`).replace(/ModuleBuildError:\s*/g, '').replace(/ModuleParseError:\s*/g, '').replace(/Error:\s*Module\s+build\s+failed.*?\n/gi, '').replace(/\n{3,}/g, '\n\n').replace(/\n{2}(?=WARNING in )/g, '\n');
         }
         function makeSanitizedConsole(brand = 'Extension.js') {
             const sanitize = (a)=>'string' == typeof a ? scrubBrand(a, brand) : a;