extension-develop 3.9.0-next.3 → 3.9.0

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');
@@ -414,13 +401,45 @@ exports.modules = {
                 return 'unknown';
             }
             async hardReload() {
-                if (!this.cdp || !this.extensionId) return false;
+                if (!this.extensionId) return false;
                 try {
-                    return await this.cdp.forceReloadExtension(this.extensionId);
+                    if (!this.cdp) await this.connectFreshClient();
+                    if (this.cdp && await this.cdp.forceReloadExtension(this.extensionId)) return true;
+                } catch  {}
+                try {
+                    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/324.cjs

@@ -7,7 +7,10 @@ exports.modules = {
         __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");
@@ -88,7 +91,6 @@ exports.modules = {
                 this.basePort = basePort;
             }
         }
-        var external_fs_ = __webpack_require__("fs");
         function hasDependency(projectPath, dependency) {
             const findNearestPackageJsonDirectory = (startPath)=>{
                 let currentDirectory = startPath;
@@ -213,6 +215,139 @@ exports.modules = {
         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;
@@ -272,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'),
@@ -280,7 +418,13 @@ exports.modules = {
                 manifestPath,
                 port
             });
-            (0, compiler_hooks.N)(compiler);
+            (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,
@@ -332,16 +476,6 @@ exports.modules = {
                 }, START_TIMEOUT_MS);
                 await devServer.start();
                 if (startTimeout) clearTimeout(startTimeout);
-                if (devOptions.noBrowser) {
-                    console.log(messages.Gc('development', devOptions.browser));
-                    console.log(messages.tl());
-                    console.log(messages.bL({
-                        browser: String(devOptions.browser || 'chromium'),
-                        manifestPath,
-                        readyPath: metadata.readyPath
-                    }));
-                }
-                console.log(messages.tl());
             } catch (error) {
                 if (startTimeout) clearTimeout(startTimeout);
                 metadata.writeError('dev_server_start_failed', error instanceof Error ? error.message : String(error));

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;

package/dist/module.cjs

@@ -129186,7 +129186,6 @@ var __webpack_modules__ = {
         async function maybePrintDevBanner(args) {
             const mode = args.compilation?.options?.mode || 'development';
             if ('development' !== mode) return;
-            if (args.enableCdp) return;
             const loadExtensionFlag = args.chromiumConfig.find((flag)=>flag.startsWith('--load-extension='));
             const extensionOutputPath = (0, extension_output_path.W)(args.compilation, loadExtensionFlag);
             if (!extensionOutputPath) return;
@@ -129194,6 +129193,7 @@ var __webpack_modules__ = {
                 timeoutMs: 10000
             });
             if (!ready) return;
+            if (args.enableCdp) return;
             await (0, banner.a)({
                 browser: args.browser,
                 outPath: extensionOutputPath,
@@ -129226,7 +129226,7 @@ var __webpack_modules__ = {
                         if (this.didLaunch) return;
                         await this.launchChromium(stats.compilation);
                         this.didLaunch = true;
-                        if (!this.didReportReady) this.logger.info(dev_server_messages.Gc(stats.compilation.options.mode, this.options.browser));
+                        if (!this.didReportReady) console.log(dev_server_messages.Gc(stats.compilation.options.mode, this.options.browser));
                     } catch (error) {
                         try {
                             this.logger.error(messages._D4(this.options.browser, error));
@@ -129280,9 +129280,10 @@ var __webpack_modules__ = {
                         return 'npx extension install chrome';
                     }
                 };
+                const isAuthorMode = 'true' === process.env.EXTENSION_AUTHOR_MODE;
                 switch(browser){
                     case 'chrome':
-                        console.log(messages.GqE(browser));
+                        if (isAuthorMode) console.log(messages.GqE(browser));
                         if (!skipDetection) try {
                             try {
                                 const located = (0, external_chrome_location2_.locateChromeOrExplain)({
@@ -129319,7 +129320,7 @@ var __webpack_modules__ = {
                         }
                         break;
                     case 'chromium':
-                        console.log(messages.GqE(browser));
+                        if (isAuthorMode) console.log(messages.GqE(browser));
                         browserBinaryLocation = this.options?.chromiumBinary || null;
                         if (this.options?.chromiumBinary) {
                             const normalized = normalizePath(String(this.options.chromiumBinary));
@@ -129339,7 +129340,7 @@ var __webpack_modules__ = {
                         if (!browserBinaryLocation) browserBinaryLocation = resolveWslWindowsBinary(browser);
                         break;
                     case 'edge':
-                        console.log(messages.GqE(browser));
+                        if (isAuthorMode) console.log(messages.GqE(browser));
                         try {
                             const override = String(process.env.EDGE_BINARY || '').trim();
                             if (override) {
@@ -129515,7 +129516,7 @@ var __webpack_modules__ = {
                 if (this.options.dryRun) return void logChromiumDryRun(browserBinaryLocation, chromiumConfig);
                 await this.launchWithDirectSpawn(browserBinaryLocation, chromiumConfig);
                 if ('development' === compilation.options.mode && !this.didReportReady) {
-                    this.logger.info(dev_server_messages.Gc(compilation.options.mode, this.options.browser));
+                    console.log(dev_server_messages.Gc(compilation.options.mode, this.options.browser));
                     this.didReportReady = true;
                 }
                 try {
@@ -129656,6 +129657,42 @@ var __webpack_modules__ = {
                 return;
             }
         }
+        function normalizeManifestFile(filePath) {
+            if ('string' != typeof filePath) return;
+            const normalized = filePath.trim().replace(/^\/+/, '');
+            if (!normalized) return;
+            if (/^(https?:)?\/\//i.test(filePath)) return;
+            if (/[*?[\]{}]/.test(normalized)) return;
+            return normalized;
+        }
+        function getManifestRequiredFiles(content) {
+            try {
+                const manifest = JSON.parse(content);
+                const requiredFiles = new Set();
+                const addFile = (filePath)=>{
+                    const normalized = normalizeManifestFile(filePath);
+                    if (normalized) requiredFiles.add(normalized);
+                };
+                addFile(manifest.background?.service_worker);
+                addFile(manifest.background?.page);
+                if (Array.isArray(manifest.background?.scripts)) for (const script of manifest.background?.scripts || [])addFile(script);
+                addFile(manifest.side_panel?.default_path);
+                if (Array.isArray(manifest.content_scripts)) for (const contentScript of manifest.content_scripts){
+                    if (Array.isArray(contentScript?.js)) for (const jsFile of contentScript.js)addFile(jsFile);
+                    if (Array.isArray(contentScript?.css)) for (const cssFile of contentScript.css)addFile(cssFile);
+                }
+                return [
+                    ...requiredFiles
+                ];
+            } catch  {
+                return [];
+            }
+        }
+        function hasRequiredManifestFiles(outPath, content) {
+            const requiredFiles = getManifestRequiredFiles(content);
+            for (const relativeFile of requiredFiles)if (!fs__rspack_import_0.existsSync(path__rspack_import_1.join(outPath, relativeFile))) return false;
+            return true;
+        }
         async function waitForStableManifest(outPath, options) {
             const timeoutMs = options?.timeoutMs ?? 8000;
             const pollIntervalMs = options?.pollIntervalMs ?? 150;
@@ -129666,7 +129703,7 @@ var __webpack_modules__ = {
             let stableReads = 0;
             while(Date.now() - start < timeoutMs){
                 const currentContent = readValidManifest(manifestPath);
-                if (currentContent) {
+                if (currentContent && hasRequiredManifestFiles(outPath, currentContent)) {
                     if (currentContent === lastValidContent) stableReads += 1;
                     else {
                         lastValidContent = currentContent;
@@ -134154,13 +134191,17 @@ var __webpack_modules__ = {
             return `${getLoggingPrefix('success')} Dependencies installed. Run the command again to proceed.`;
         }
         function buildWebpack(projectDir, stats, browser) {
-            const statsJson = stats?.toJson();
+            const statsJson = stats?.toJson({
+                all: false,
+                assets: true,
+                time: true
+            });
             const outputPath = 'string' == typeof stats?.compilation?.outputOptions?.path ? stats.compilation.outputOptions.path : '';
             const manifestPath = outputPath ? path__rspack_import_1.join(outputPath, 'manifest.json') : path__rspack_import_1.join(projectDir, 'manifest.json');
             const manifest = JSON.parse(fs__rspack_import_0.readFileSync(manifestPath, 'utf8'));
             const assets = statsJson?.assets;
             const heading = `${getLoggingPrefix('info')} Building ${pintor__rspack_import_2_default().blue(manifest.name)} extension using ${capitalizedBrowserName(browser)} defaults...\n`;
-            const buildTime = `\nBuild completed in ${((statsJson?.time || 0) / 1000).toFixed(2)} seconds.`;
+            const buildTime = `\nBuild completed in ${((statsJson?.time || 0) / 1000).toFixed(2)} seconds.\n`;
             const buildTarget = `Build Target: ${pintor__rspack_import_2_default().gray(capitalizedBrowserName(browser))}\n`;
             const buildStatus = `Build Status: ${stats?.hasErrors() ? pintor__rspack_import_2_default().red('Failed') : pintor__rspack_import_2_default().green('Success')}\n`;
             const version1 = `\nVersion: ${pintor__rspack_import_2_default().gray(manifest.version)}\n`;
@@ -134221,13 +134262,13 @@ var __webpack_modules__ = {
             if (haystack.includes('runtime') || haystack.includes('will fail') || haystack.includes('cannot resolve') || haystack.includes('service_worker')) return 'Runtime-risk';
             return 'Warning';
         }
-        function suggestedActionForWarning(category) {
-            if ('Performance' === category) return 'Split optional features and lazy-load heavy paths. Tune thresholds only if large assets are intentional.';
-            if ('Deprecation' === category) return 'Move to the supported API/plugin path to avoid breakage in future updates.';
+        function suggestedHintForWarning(category) {
+            if ('Performance' === category) return 'Inspect the largest startup bundles and split optional code paths.';
+            if ('Deprecation' === category) return 'Move to the supported API or plugin path before the next update.';
             if ('Configuration' === category) return 'Review extension and bundler config keys, then remove or rename invalid options.';
             if ('Compatibility' === category) return 'Verify browser target and manifest compatibility for this build.';
-            if ('Runtime-risk' === category) return 'Address this warning before release; it may fail or degrade at runtime.';
-            return 'Re-run with verbose output to inspect warning details and apply targeted fixes.';
+            if ('Runtime-risk' === category) return 'Address this before release; it may fail or degrade at runtime.';
+            return 'Re-run with EXTENSION_VERBOSE=1 to inspect full warning details.';
         }
         function buildSuccessWithWarnings(warningCount) {
             return `${getLoggingPrefix('warn')} Build succeeded with ${warningCount} warning(s). Your extension is ${pintor__rspack_import_2_default().green('ready for deployment')}.`;
@@ -134235,19 +134276,20 @@ var __webpack_modules__ = {
         function buildWarningsDetails(warnings) {
             if (!Array.isArray(warnings) || 0 === warnings.length) return '';
             const blocks = [];
-            const sectionHeader = `${getLoggingPrefix('warn')} Warning details\n`;
             warnings.forEach((warning, index)=>{
                 const message = getWarningMessage(warning);
                 const source = getWarningSource(warning);
                 const artifact = getWarningArtifact(warning);
                 const category = classifyWarning(message, source);
-                const action = suggestedActionForWarning(category);
-                if (!message) return void blocks.push(`  ${pintor__rspack_import_2_default().brightYellow('Warning ' + (index + 1))}: details were suppressed by tool output.\n  ${fmt.label('SOURCE')} ${pintor__rspack_import_2_default().gray(source)}\n  ${fmt.label('ACTION')} Re-run with EXTENSION_VERBOSE=1 to inspect full warning messages.`);
+                const hint = suggestedHintForWarning(category);
+                if (!message) return void blocks.push(`${getLoggingPrefix('warn')} Warning ${index + 1}: details were suppressed by tool output.\n${formatWarningLabelLine('Source', pintor__rspack_import_2_default().gray(source))}\n${formatWarningLabelLine('Hint', 'Re-run with EXTENSION_VERBOSE=1 to inspect full warning messages.')}`);
+                const performanceWarning = parsePerformanceWarning(warning, source, artifact);
+                if (performanceWarning) return void blocks.push(performanceWarning);
                 const oneLine = message.replace(/\s+/g, ' ').trim();
                 const artifactSuffix = artifact ? ` ${pintor__rspack_import_2_default().gray(`(${artifact})`)}` : '';
-                blocks.push(`  ${pintor__rspack_import_2_default().brightYellow(category)}: ${oneLine}${artifactSuffix}\n  ${fmt.label('SOURCE')} ${pintor__rspack_import_2_default().gray(source)}\n  ${fmt.label('ACTION')} ${action}`);
+                blocks.push(`${getLoggingPrefix('warn')} ${category}: ${oneLine}${artifactSuffix}\n${formatWarningLabelLine('Source', pintor__rspack_import_2_default().gray(source))}\n${formatWarningLabelLine('Hint', hint)}`);
             });
-            return sectionHeader + blocks.join('\n\n');
+            return blocks.join('\n\n');
         }
         function fetchingProjectPath(owner, project) {
             return fmt.block('Fetching project', [
@@ -134349,6 +134391,49 @@ var __webpack_modules__ = {
             });
             return `.\n${printTree(assetTree)}`;
         }
+        function formatWarningLabelLine(label, value) {
+            return `${pintor__rspack_import_2_default().gray('│')}  ${pintor__rspack_import_2_default().gray(`${label}:`)} ${value}`;
+        }
+        function parsePerformanceWarning(warning, source, _artifact) {
+            const normalized = getWarningBody(warning).replace(/\r/g, '');
+            const lower = normalized.toLowerCase();
+            const threshold = normalized.match(/\(([\d.]+\s(?:KiB|MiB|GiB|KB|MB|GB))\)/)?.[1] || '';
+            if (lower.includes('asset size limit')) return formatPerformanceWarningBlock({
+                title: 'asset size limit exceeded',
+                threshold,
+                impact: 'Large emitted files can increase package size and slow extension startup.',
+                source,
+                hint: 'Inspect the largest startup bundles and split optional code paths.'
+            });
+            if (lower.includes('entrypoint size limit')) return formatPerformanceWarningBlock({
+                title: 'entrypoint size limit exceeded',
+                threshold,
+                impact: 'Startup entrypoints are heavier than recommended.',
+                source,
+                hint: 'Keep startup entrypoints thin and defer non-critical code.'
+            });
+        }
+        function formatPerformanceWarningBlock(options) {
+            const lines = [
+                `${getLoggingPrefix('warn')} Performance: ${options.title}`
+            ];
+            if (options.threshold) lines.push(formatWarningLabelLine('Threshold', options.threshold));
+            lines.push(formatWarningLabelLine('Impact', options.impact));
+            lines.push(pintor__rspack_import_2_default().gray('│'));
+            lines.push(formatWarningLabelLine('Source', pintor__rspack_import_2_default().gray(options.source)));
+            lines.push(formatWarningLabelLine('Hint', options.hint));
+            return lines.join('\n');
+        }
+        function getWarningBody(warning) {
+            if (!warning) return '';
+            if ('string' == typeof warning) return warning;
+            return [
+                warning.message,
+                warning.details,
+                warning.reason,
+                warning.description
+            ].filter((value)=>'string' == typeof value && value.trim().length > 0).join('\n');
+        }
         function isUsingExperimentalConfig(integration) {
             return `${getLoggingPrefix('info')} Using ${pintor__rspack_import_2_default().yellow(integration)}.`;
         }
@@ -135379,7 +135464,7 @@ var __webpack_modules__ = {
     },
     "./package.json" (module) {
         "use strict";
-        module.exports = JSON.parse('{"rE":"3.9.0-next.3","El":{"@rspack/core":"^1.7.5","@rspack/dev-server":"^1.1.5","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.1","case-sensitive-paths-webpack-plugin":"^2.4.0","chrome-location2":"4.0.0","chromium-location":"2.0.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","edge-location":"2.2.0","extension-from-store":"^0.1.1","firefox-location2":"3.0.0","go-git-it":"^5.1.1","ignore":"^7.0.5","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5":"^8.0.0","parse5-utilities":"^1.0.0","pintor":"0.3.0","schema-utils":"^4.3.3","tiny-glob":"^0.2.9","unique-names-generator":"^4.7.1","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3","ws":"^8.19.0"}}');
+        module.exports = JSON.parse('{"rE":"3.9.0","El":{"@rspack/core":"^1.7.5","@rspack/dev-server":"^1.1.5","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.1","case-sensitive-paths-webpack-plugin":"^2.4.0","chrome-location2":"4.0.0","chromium-location":"2.0.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","edge-location":"2.2.0","extension-from-store":"^0.1.1","firefox-location2":"3.0.0","go-git-it":"^5.1.1","ignore":"^7.0.5","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5":"^8.0.0","parse5-utilities":"^1.0.0","pintor":"0.3.0","schema-utils":"^4.3.3","tiny-glob":"^0.2.9","unique-names-generator":"^4.7.1","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3","ws":"^8.19.0"}}');
     }
 };
 var __webpack_module_cache__ = {};
@@ -136259,7 +136344,7 @@ var __webpack_exports__ = {};
                 __webpack_require__.e("552").then(__webpack_require__.bind(__webpack_require__, "./webpack/webpack-lib/stats-handler.ts")),
                 Promise.all([
                     __webpack_require__.e("215"),
-                    __webpack_require__.e("946")
+                    __webpack_require__.e("270")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./webpack/webpack-config.ts"))
             ]);
             const debug = isAuthor;
@@ -136296,6 +136381,7 @@ var __webpack_exports__ = {};
                 plugins: allPluginsButBrowserRunners
             });
             const compilerConfig = merge(userConfig);
+            compilerConfig.stats = false;
             const compiler = rspack(compilerConfig);
             let summary = {
                 browser,
@@ -136403,7 +136489,7 @@ var __webpack_exports__ = {};
             if ('true' === process.env.EXTENSION_DEV_DRY_RUN) return;
             const { devServer } = await Promise.all([
                 __webpack_require__.e("215"),
-                __webpack_require__.e("946"),
+                __webpack_require__.e("270"),
                 __webpack_require__.e("324")
             ]).then(__webpack_require__.bind(__webpack_require__, "./webpack/dev-server/index.ts"));
             await devServer(projectStructure, {