extension-develop 3.8.16 → 3.9.0-canary.231.7b387a7

package/dist/module.cjs

@@ -127131,6 +127131,124 @@ var __webpack_modules__ = {
         });
         module.exports = library;
     },
+    "./webpack/dev-server/messages.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            Df: ()=>autoExitForceKill,
+            Gc: ()=>ready,
+            Nq: ()=>bundlerFatalError,
+            UF: ()=>devServerStartTimeout,
+            VL: ()=>extensionJsRunnerError,
+            aO: ()=>portInUse,
+            bL: ()=>browserRunnerDisabled,
+            eP: ()=>bundlerRecompiling,
+            nI: ()=>noEntrypointsDetected,
+            o6: ()=>autoExitModeEnabled,
+            tJ: ()=>autoExitTriggered,
+            tl: ()=>spacerLine
+        });
+        var fs__rspack_import_0 = __webpack_require__("fs");
+        var pintor__rspack_import_1 = __webpack_require__("pintor");
+        var pintor__rspack_import_1_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_1);
+        function getLoggingPrefix(type) {
+            const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+            if (isAuthor) {
+                const base = 'error' === type ? 'ERROR Author says' : '►►► Author says';
+                return pintor__rspack_import_1_default().brightMagenta(base);
+            }
+            if ('error' === type) return pintor__rspack_import_1_default().red('ERROR');
+            if ('warn' === type) return pintor__rspack_import_1_default().brightYellow('►►►');
+            if ('info' === type) return pintor__rspack_import_1_default().gray('►►►');
+            return pintor__rspack_import_1_default().green('►►►');
+        }
+        function 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 = pintor__rspack_import_1_default().green('ready for ' + mode);
+            return `${getLoggingPrefix('info')} ${cap} ${extensionOutput} ${pretty}.`;
+        }
+        function readJsonRecord(filePath) {
+            try {
+                return JSON.parse(fs__rspack_import_0.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 ? `${pintor__rspack_import_1_default().gray(runId)}${pid ? ` · ${pintor__rspack_import_1_default().gray(`PID ${pid}`)}` : ''}` : pid ? pintor__rspack_import_1_default().gray(`PID ${pid}`) : pintor__rspack_import_1_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 [
+                ` 🧩 ${pintor__rspack_import_1_default().brightBlue('Extension.js')} ${pintor__rspack_import_1_default().gray(extensionJsVersion)}`,
+                `    Browser        ${pintor__rspack_import_1_default().gray(args.browserModeLabel || `${browserLabel} (build-only mode)`)}`,
+                `    Extension      ${pintor__rspack_import_1_default().gray(extensionLabel)}`,
+                `    Run ID         ${runLabel}`
+            ].join('\n');
+        }
+        function portInUse(requestedPort, newPort) {
+            return `Port: Requested port ${pintor__rspack_import_1_default().brightBlue(requestedPort.toString())} is in use; using ${pintor__rspack_import_1_default().brightBlue(newPort.toString())} instead.`;
+        }
+        function extensionJsRunnerError(error) {
+            return `Extension.js Runner Error:\n${pintor__rspack_import_1_default().red(String(error))}`;
+        }
+        function autoExitModeEnabled(ms) {
+            return `Auto-exit enabled. Will exit after ${pintor__rspack_import_1_default().brightBlue(ms.toString())} ms if idle.`;
+        }
+        function autoExitTriggered(ms) {
+            return `Auto-exit triggered after ${pintor__rspack_import_1_default().brightBlue(ms.toString())} ms. Cleaning up...`;
+        }
+        function autoExitForceKill(ms) {
+            return `Force-killing process after ${pintor__rspack_import_1_default().brightBlue(ms.toString())} ms to ensure exit.`;
+        }
+        function devServerStartTimeout(ms) {
+            return [
+                `Dev server startup is taking longer than expected (${pintor__rspack_import_1_default().brightBlue(ms.toString())} ms).`,
+                "The bundler may have encountered an error before emitting the first build.",
+                `If nothing else prints, try setting ${pintor__rspack_import_1_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${pintor__rspack_import_1_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:${pintor__rspack_import_1_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 ${pintor__rspack_import_1_default().brightBlue('EXTENSION_VERBOSE=1')} or review your extension config.`
+            ].join('\n');
+        }
+        function spacerLine() {
+            return ' ';
+        }
+    },
     "./webpack/feature-special-folders/folder-extensions/resolve-config.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -127425,6 +127543,22 @@ var __webpack_modules__ = {
             if ('string' != typeof value) return '';
             return value.trim();
         }
+        function readReadyMetadata(readyPath) {
+            if (!readyPath) return null;
+            try {
+                return JSON.parse(fs__rspack_import_0.readFileSync(readyPath, 'utf-8'));
+            } catch  {
+                return null;
+            }
+        }
+        function resolveRunLabel(ready) {
+            const runId = toNormalizedId(ready?.runId);
+            const pid = 'number' == typeof ready?.pid && Number.isFinite(ready.pid) ? String(ready.pid) : '';
+            if (runId && pid) return `${runId} · PID ${pid}`;
+            if (runId) return runId;
+            if (pid) return `PID ${pid}`;
+            return '';
+        }
         function deriveChromiumExtensionIdFromManifest(manifest) {
             const key = toNormalizedId(manifest?.key);
             if (!key) return '';
@@ -127507,6 +127641,8 @@ var __webpack_modules__ = {
             try {
                 const manifestPath = path__rspack_import_1.join(opts.outPath, 'manifest.json');
                 const manifest = JSON.parse(fs__rspack_import_0.readFileSync(manifestPath, 'utf-8'));
+                const ready = readReadyMetadata(opts.readyPath);
+                const runLabel = opts.includeRunId ? resolveRunLabel(ready) : '';
                 const runtimeInfo = opts.runtime ? {
                     extensionId: opts.runtime.extensionId,
                     name: opts.runtime.name,
@@ -127529,7 +127665,8 @@ var __webpack_modules__ = {
                     };
                     console.log(_messages__rspack_import_3.io8());
                     console.log(_messages__rspack_import_3.e_P(manifest, opts.browser, message, browserLabel, updateSuffix || void 0, {
-                        includeExtensionId: opts.includeExtensionId
+                        includeExtensionId: opts.includeExtensionId,
+                        runLabel
                     }));
                     console.log(_messages__rspack_import_3.io8());
                 } else {
@@ -127544,7 +127681,8 @@ var __webpack_modules__ = {
                     };
                     console.log(_messages__rspack_import_3.io8());
                     console.log(_messages__rspack_import_3.e_P(manifest, opts.browser, message, browserLabel, updateSuffix || void 0, {
-                        includeExtensionId: opts.includeExtensionId
+                        includeExtensionId: opts.includeExtensionId,
+                        runLabel
                     }));
                     console.log(_messages__rspack_import_3.io8());
                 }
@@ -127656,6 +127794,7 @@ var __webpack_modules__ = {
             VkK: ()=>enhancedProcessManagementCleanup,
             WVu: ()=>addonInstallError,
             WVz: ()=>sourceInspectorHTMLOutputFooter,
+            WsE: ()=>chromiumHardReloadFailed,
             Ww: ()=>sourceInspectorTargetCreated,
             X6h: ()=>firefoxRemoteDebuggingReady,
             XHr: ()=>enhancedProcessManagementTerminating,
@@ -128258,6 +128397,7 @@ var __webpack_modules__ = {
             const displayVersion = String(version1 || manifest.version || '');
             lines.push(` 🧩 ${pintor__rspack_import_4_default().brightBlue('Extension.js')} ${pintor__rspack_import_4_default().gray(`${extensionVersion}`)}${updateNotice}`, `    Browser        ${pintor__rspack_import_4_default().gray(browserLabel)}`, `    Extension      ${pintor__rspack_import_4_default().gray(displayVersion ? `${displayName} ${displayVersion}` : displayName)}`);
             if (includeExtensionId && cleanId) lines.push(`    Extension ID   ${pintor__rspack_import_4_default().gray(cleanId)}`);
+            if (opts?.runLabel) lines.push(`    Run ID         ${pintor__rspack_import_4_default().gray(opts.runLabel)}`);
             return lines.join('\n');
         }
         function emptyLine() {
@@ -128327,6 +128467,11 @@ var __webpack_modules__ = {
             exts = 'edge' === browser ? pintor__rspack_import_4_default().underline('edge://extensions') : pintor__rspack_import_4_default().underline('chrome://extensions');
             return `${getLoggingPrefix('warn')} Configuration required\nEnable ${pintor__rspack_import_4_default().yellow('Developer mode')} in ${exts} for reliable reloads.\nWithout it, hard reloads may disable your unpacked extension.`;
         }
+        function chromiumHardReloadFailed(browser) {
+            let exts = '';
+            exts = 'edge' === browser ? pintor__rspack_import_4_default().underline('edge://extensions') : pintor__rspack_import_4_default().underline('chrome://extensions');
+            return `${getLoggingPrefix('warn')} Reload failed\nChromium could not reload your unpacked extension.\nIf you are using an existing profile, verify ${pintor__rspack_import_4_default().yellow('Developer mode')} is enabled in ${exts}.`;
+        }
     },
     "./webpack/plugin-browsers/browsers-lib/output-binaries-resolver.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
@@ -128656,6 +128801,7 @@ var __webpack_modules__ = {
         var output_binaries_resolver = __webpack_require__("./webpack/plugin-browsers/browsers-lib/output-binaries-resolver.ts");
         var shared_utils = __webpack_require__("./webpack/plugin-browsers/browsers-lib/shared-utils.ts");
         var banner = __webpack_require__("./webpack/plugin-browsers/browsers-lib/banner.ts");
+        var dev_server_messages = __webpack_require__("./webpack/dev-server/messages.ts");
         var external_path_ = __webpack_require__("path");
         const masterPreferences = {
             alternate_error_pages: {
@@ -128945,6 +129091,7 @@ var __webpack_modules__ = {
             console.log(messages.E8B(chromiumConfig.join(' ')));
         }
         var extension_output_path = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-launch/extension-output-path.ts");
+        var manifest_readiness = __webpack_require__("./webpack/plugin-browsers/run-chromium/manifest-readiness.ts");
         var external_os_ = __webpack_require__("os");
         function isWslEnv() {
             if ('linux' !== process.platform) return false;
@@ -129036,26 +129183,17 @@ var __webpack_modules__ = {
             else obj[key] = value;
             return obj;
         }
-        async function waitForManifest(outPath, timeoutMs = 8000) {
-            const manifestPath = `${outPath}/manifest.json`;
-            const start = Date.now();
-            while(Date.now() - start < timeoutMs){
-                try {
-                    if (external_fs_.existsSync(manifestPath)) return true;
-                } catch  {}
-                await new Promise((resolve)=>setTimeout(resolve, 150));
-            }
-            return false;
-        }
         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;
-            const ready = await waitForManifest(extensionOutputPath, 10000);
+            const ready = await (0, manifest_readiness.f)(extensionOutputPath, {
+                timeoutMs: 10000
+            });
             if (!ready) return;
+            if (args.enableCdp) return;
             await (0, banner.a)({
                 browser: args.browser,
                 outPath: extensionOutputPath,
@@ -129088,7 +129226,7 @@ var __webpack_modules__ = {
                         if (this.didLaunch) return;
                         await this.launchChromium(stats.compilation);
                         this.didLaunch = true;
-                        this.logger.info(messages.ACl(this.options.browser, stats.compilation.options.mode));
+                        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));
@@ -129142,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)({
@@ -129181,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));
@@ -129201,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) {
@@ -129376,6 +129515,10 @@ var __webpack_modules__ = {
                 });
                 if (this.options.dryRun) return void logChromiumDryRun(browserBinaryLocation, chromiumConfig);
                 await this.launchWithDirectSpawn(browserBinaryLocation, chromiumConfig);
+                if ('development' === compilation.options.mode && !this.didReportReady) {
+                    console.log(dev_server_messages.Gc(compilation.options.mode, this.options.browser));
+                    this.didReportReady = true;
+                }
                 try {
                     let browserVersionLine;
                     try {
@@ -129485,12 +129628,96 @@ var __webpack_modules__ = {
                 _define_property(this, "options", void 0);
                 _define_property(this, "ctx", void 0);
                 _define_property(this, "didLaunch", void 0);
+                _define_property(this, "didReportReady", void 0);
                 _define_property(this, "logger", void 0);
                 this.options = options;
                 this.ctx = ctx;
                 this.didLaunch = false;
+                this.didReportReady = false;
+            }
+        }
+    },
+    "./webpack/plugin-browsers/run-chromium/manifest-readiness.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            f: ()=>waitForStableManifest
+        });
+        var fs__rspack_import_0 = __webpack_require__("fs");
+        var path__rspack_import_1 = __webpack_require__("path");
+        function sleep(ms) {
+            return new Promise((resolve)=>setTimeout(resolve, ms));
+        }
+        function readValidManifest(manifestPath) {
+            try {
+                const content = fs__rspack_import_0.readFileSync(manifestPath, 'utf-8');
+                if (!content.trim()) return;
+                JSON.parse(content);
+                return content;
+            } catch  {
+                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;
+            const stableReadsRequired = options?.stableReadsRequired ?? 2;
+            const manifestPath = path__rspack_import_1.join(outPath, 'manifest.json');
+            const start = Date.now();
+            let lastValidContent;
+            let stableReads = 0;
+            while(Date.now() - start < timeoutMs){
+                const currentContent = readValidManifest(manifestPath);
+                if (currentContent && hasRequiredManifestFiles(outPath, currentContent)) {
+                    if (currentContent === lastValidContent) stableReads += 1;
+                    else {
+                        lastValidContent = currentContent;
+                        stableReads = 1;
+                    }
+                    if (stableReads >= stableReadsRequired) return true;
+                } else {
+                    lastValidContent = void 0;
+                    stableReads = 0;
+                }
+                await sleep(pollIntervalMs);
+            }
+            return false;
+        }
     },
     "./webpack/plugin-browsers/run-firefox/firefox-context/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
@@ -129556,6 +129783,7 @@ var __webpack_modules__ = {
         var output_binaries_resolver = __webpack_require__("./webpack/plugin-browsers/browsers-lib/output-binaries-resolver.ts");
         var shared_utils = __webpack_require__("./webpack/plugin-browsers/browsers-lib/shared-utils.ts");
         var instance_registry = __webpack_require__("./webpack/plugin-browsers/browsers-lib/instance-registry.ts");
+        var dev_server_messages = __webpack_require__("./webpack/dev-server/messages.ts");
         var external_child_process_ = __webpack_require__("child_process");
         function setupFirefoxProcessHandlers(browser, childRef, cleanupInstance) {
             let isCleaningUp = false;
@@ -130305,7 +130533,10 @@ var __webpack_modules__ = {
                     debug: (...a)=>console?.debug?.(...a)
                 };
                 await this.launch(compilation, options);
-                this.ctx.logger?.info?.(messages.ACl(this.host.browser, options.mode));
+                if ('development' === options.mode) {
+                    this.ctx.logger?.info?.(messages.ACl(this.host.browser, options.mode));
+                    this.ctx.logger?.info?.(dev_server_messages.Gc(options.mode, this.host.browser));
+                }
                 this.ctx.didLaunch = true;
             }
             apply(compiler) {
@@ -130328,6 +130559,7 @@ var __webpack_modules__ = {
                             port: this.host.port
                         });
                         this.ctx.logger?.info?.(messages.ACl(this.host.browser, stats.compilation.options.mode));
+                        this.ctx.logger?.info?.(dev_server_messages.Gc(stats.compilation.options.mode, this.host.browser));
                         this.ctx.didLaunch = true;
                     } catch (error) {
                         this.ctx.logger?.error?.(messages.MQS(error));
@@ -131452,16 +131684,20 @@ var __webpack_modules__ = {
         __webpack_require__.d(__webpack_exports__, {
             Dy: ()=>installOptionalDependenciesBatch,
             He: ()=>resolveDevelopInstallRoot,
+            Iy: ()=>resolveOptionalInstallRoot,
             tm: ()=>installOptionalDependencies,
             ws: ()=>hasDependency
         });
         var path__rspack_import_0 = __webpack_require__("path");
         var fs__rspack_import_1 = __webpack_require__("fs");
-        var _messages__rspack_import_2 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
-        var pintor__rspack_import_3 = __webpack_require__("pintor");
-        var pintor__rspack_import_3_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_3);
-        var _webpack_lib_check_build_dependencies__rspack_import_4 = __webpack_require__("./webpack/webpack-lib/check-build-dependencies.ts");
-        var _webpack_lib_package_manager__rspack_import_5 = __webpack_require__("./webpack/webpack-lib/package-manager.ts");
+        var os__rspack_import_2 = __webpack_require__("os");
+        var _messages__rspack_import_3 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
+        var pintor__rspack_import_4 = __webpack_require__("pintor");
+        var pintor__rspack_import_4_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_4);
+        var _package_json__rspack_import_5 = __webpack_require__("./package.json");
+        var _webpack_lib_check_build_dependencies__rspack_import_6 = __webpack_require__("./webpack/webpack-lib/check-build-dependencies.ts");
+        var _webpack_lib_optional_dependencies__rspack_import_7 = __webpack_require__("./webpack/webpack-lib/optional-dependencies.ts");
+        var _webpack_lib_package_manager__rspack_import_8 = __webpack_require__("./webpack/webpack-lib/package-manager.ts");
         function parseJsonSafe(text) {
             const s = text && 0xfeff === text.charCodeAt(0) ? text.slice(1) : text;
             return JSON.parse(s || '{}');
@@ -131569,13 +131805,13 @@ var __webpack_modules__ = {
         }
         async function execInstallWithFallback(command, options) {
             try {
-                await (0, _webpack_lib_package_manager__rspack_import_5.Qt)(command.command, command.args, {
+                await (0, _webpack_lib_package_manager__rspack_import_8.Qt)(command.command, command.args, {
                     cwd: options.cwd,
                     stdio: 'inherit'
                 });
                 return;
             } catch (error) {
-                if (options.fallbackNpmCommand && (isMissingManagerError(error) || options.allowFallbackOnFailure && isInstallExitFailure(error))) return void await (0, _webpack_lib_package_manager__rspack_import_5.Qt)(options.fallbackNpmCommand.command, options.fallbackNpmCommand.args, {
+                if (options.fallbackNpmCommand && (isMissingManagerError(error) || options.allowFallbackOnFailure && isInstallExitFailure(error))) return void await (0, _webpack_lib_package_manager__rspack_import_8.Qt)(options.fallbackNpmCommand.command, options.fallbackNpmCommand.args, {
                     cwd: options.cwd,
                     stdio: 'inherit'
                 });
@@ -131583,7 +131819,7 @@ var __webpack_modules__ = {
             }
         }
         function resolveDevelopInstallRoot() {
-            const directRoot = (0, _webpack_lib_check_build_dependencies__rspack_import_4.w1)();
+            const directRoot = (0, _webpack_lib_check_build_dependencies__rspack_import_6.w1)();
             if (directRoot) return directRoot;
             try {
                 const candidateRoot = findDevelopRootFrom(__dirname);
@@ -131600,43 +131836,67 @@ var __webpack_modules__ = {
                 return;
             }
         }
+        function getExtensionJsCacheBaseDir() {
+            const override = process.env.EXTENSION_JS_CACHE_DIR;
+            if (override) return path__rspack_import_0.resolve(override);
+            if ('win32' === process.platform && process.env.LOCALAPPDATA) return path__rspack_import_0.join(process.env.LOCALAPPDATA, 'extensionjs');
+            if (process.env.XDG_CACHE_HOME) return path__rspack_import_0.join(process.env.XDG_CACHE_HOME, 'extensionjs');
+            return path__rspack_import_0.join(os__rspack_import_2.homedir(), '.cache', 'extensionjs');
+        }
+        function resolveOptionalInstallRoot() {
+            return path__rspack_import_0.join(getExtensionJsCacheBaseDir(), 'optional-deps', _package_json__rspack_import_5.rE);
+        }
+        function ensureOptionalInstallBaseDir(installBaseDir) {
+            fs__rspack_import_1.mkdirSync(installBaseDir, {
+                recursive: true
+            });
+            const packageJsonPath = path__rspack_import_0.join(installBaseDir, 'package.json');
+            if (!fs__rspack_import_1.existsSync(packageJsonPath)) fs__rspack_import_1.writeFileSync(packageJsonPath, JSON.stringify({
+                name: `extensionjs-optional-deps-${_package_json__rspack_import_5.rE}`,
+                private: true,
+                version: _package_json__rspack_import_5.rE
+            }, null, 2) + '\n');
+        }
         function getOptionalInstallCommand(pm, dependencies, installBaseDir) {
             const pmName = pm.name;
-            if ('yarn' === pmName) return (0, _webpack_lib_package_manager__rspack_import_5.tj)(pm, [
+            const dependencySpecs = (0, _webpack_lib_optional_dependencies__rspack_import_7.ad)(dependencies);
+            if ('yarn' === pmName) return (0, _webpack_lib_package_manager__rspack_import_8.tj)(pm, [
                 '--silent',
                 'add',
-                ...dependencies,
+                ...dependencySpecs,
                 '--cwd',
                 installBaseDir,
                 '--optional'
             ]);
-            if ('npm' === pmName) return (0, _webpack_lib_package_manager__rspack_import_5.tj)(pm, [
+            if ('npm' === pmName) return (0, _webpack_lib_package_manager__rspack_import_8.tj)(pm, [
                 '--silent',
                 'install',
-                ...dependencies,
+                ...dependencySpecs,
                 '--prefix',
                 installBaseDir,
                 '--save-optional'
             ]);
-            if ('pnpm' === pmName) return (0, _webpack_lib_package_manager__rspack_import_5.tj)(pm, [
+            if ('pnpm' === pmName) return (0, _webpack_lib_package_manager__rspack_import_8.tj)(pm, [
                 'add',
-                ...dependencies,
+                ...dependencySpecs,
                 '--dir',
                 installBaseDir,
                 '--save-optional',
+                '--ignore-workspace',
+                '--lockfile=false',
                 '--silent'
             ]);
-            if ('bun' === pmName) return (0, _webpack_lib_package_manager__rspack_import_5.tj)(pm, [
+            if ('bun' === pmName) return (0, _webpack_lib_package_manager__rspack_import_8.tj)(pm, [
                 'add',
-                ...dependencies,
+                ...dependencySpecs,
                 '--cwd',
                 installBaseDir,
                 '--optional'
             ]);
-            return (0, _webpack_lib_package_manager__rspack_import_5.tj)(pm, [
+            return (0, _webpack_lib_package_manager__rspack_import_8.tj)(pm, [
                 '--silent',
                 'install',
-                ...dependencies,
+                ...dependencySpecs,
                 '--cwd',
                 installBaseDir,
                 '--optional'
@@ -131657,26 +131917,28 @@ var __webpack_modules__ = {
                 '--prefix',
                 installBaseDir
             ] : [];
-            if ('yarn' === pmName) return (0, _webpack_lib_package_manager__rspack_import_5.tj)(pm, [
+            if ('yarn' === pmName) return (0, _webpack_lib_package_manager__rspack_import_8.tj)(pm, [
                 'install',
                 '--silent',
                 ...dirArgs
             ]);
-            if ('npm' === pmName) return (0, _webpack_lib_package_manager__rspack_import_5.tj)(pm, [
+            if ('npm' === pmName) return (0, _webpack_lib_package_manager__rspack_import_8.tj)(pm, [
                 'install',
                 '--silent',
                 ...dirArgs
             ]);
-            if ('pnpm' === pmName) return (0, _webpack_lib_package_manager__rspack_import_5.tj)(pm, [
+            if ('pnpm' === pmName) return (0, _webpack_lib_package_manager__rspack_import_8.tj)(pm, [
                 'install',
                 '--silent',
-                ...dirArgs
+                ...dirArgs,
+                '--ignore-workspace',
+                '--lockfile=false'
             ]);
-            if ('bun' === pmName) return (0, _webpack_lib_package_manager__rspack_import_5.tj)(pm, [
+            if ('bun' === pmName) return (0, _webpack_lib_package_manager__rspack_import_8.tj)(pm, [
                 'install',
                 ...dirArgs
             ]);
-            return (0, _webpack_lib_package_manager__rspack_import_5.tj)(pm, [
+            return (0, _webpack_lib_package_manager__rspack_import_8.tj)(pm, [
                 'install',
                 '--silent',
                 ...dirArgs
@@ -131688,15 +131950,15 @@ var __webpack_modules__ = {
             let wslContext;
             let installBaseDir;
             try {
-                installBaseDir = resolveDevelopInstallRoot();
-                if (!installBaseDir) throw new Error(_messages__rspack_import_2.eG(integration));
-                pm = (0, _webpack_lib_package_manager__rspack_import_5._c)({
+                installBaseDir = resolveOptionalInstallRoot();
+                ensureOptionalInstallBaseDir(installBaseDir);
+                pm = (0, _webpack_lib_package_manager__rspack_import_8._c)({
                     cwd: installBaseDir
                 });
                 wslContext = resolveWslContext(installBaseDir);
                 if (!wslContext.useWsl) pm = await preferCorepackFallback(pm);
                 const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-                const setupMessages = _messages__rspack_import_2._j([
+                const setupMessages = _messages__rspack_import_3._j([
                     integration
                 ], integration, isAuthor);
                 const setupMessage = setupMessages[0];
@@ -131704,31 +131966,28 @@ var __webpack_modules__ = {
                 const setupMessageWithIndex = hasIndex ? setupMessage.replace('►►► ', `►►► [${options?.index}/${options?.total}] `) : setupMessage;
                 if (isAuthor) console.warn(setupMessageWithIndex);
                 else console.log(setupMessageWithIndex);
-                for (const dependency of dependencies){
-                    const installCommand = getOptionalInstallCommand(pm, [
-                        dependency
-                    ], wslContext.installDir || installBaseDir);
-                    const execCommand = wrapCommandForWsl(installCommand, wslContext);
-                    const fallbackNpmCommand = wslContext.useWsl ? void 0 : (0, _webpack_lib_package_manager__rspack_import_5.sX)([
-                        '--silent',
-                        'install',
-                        dependency,
-                        '--prefix',
-                        installBaseDir,
-                        '--save-optional'
-                    ]);
-                    await execInstallWithFallback(execCommand, {
-                        cwd: wslContext.useWsl ? void 0 : installBaseDir,
-                        fallbackNpmCommand,
-                        allowFallbackOnFailure: !wslContext.useWsl && 'npm' !== pm.name && void 0 !== fallbackNpmCommand
-                    });
-                }
+                const installCommand = getOptionalInstallCommand(pm, dependencies, wslContext.installDir || installBaseDir);
+                const execCommand = wrapCommandForWsl(installCommand, wslContext);
+                const fallbackNpmCommand = wslContext.useWsl ? void 0 : (0, _webpack_lib_package_manager__rspack_import_8.sX)([
+                    '--silent',
+                    'install',
+                    ...(0, _webpack_lib_optional_dependencies__rspack_import_7.ad)(dependencies),
+                    '--prefix',
+                    installBaseDir,
+                    '--save-optional'
+                ]);
+                await execInstallWithFallback(execCommand, {
+                    cwd: wslContext.useWsl ? void 0 : installBaseDir,
+                    fallbackNpmCommand,
+                    allowFallbackOnFailure: !wslContext.useWsl && 'npm' !== pm.name && void 0 !== fallbackNpmCommand
+                });
                 await new Promise((resolve)=>setTimeout(resolve, 500));
-                if (isAuthor) {
-                    console.log(_messages__rspack_import_2.cr(integration));
+                const needsRootRelink = isAuthor || dependencies.length > 1;
+                if (needsRootRelink) {
+                    if (isAuthor) console.log(_messages__rspack_import_3.cr(integration));
                     const rootInstall = getRootInstallCommand(pm, wslContext.useWsl ? wslContext.installDir : void 0);
                     const rootCommand = wrapCommandForWsl(rootInstall, wslContext);
-                    const rootFallbackCommand = wslContext.useWsl ? void 0 : (0, _webpack_lib_package_manager__rspack_import_5.sX)([
+                    const rootFallbackCommand = wslContext.useWsl ? void 0 : (0, _webpack_lib_package_manager__rspack_import_8.sX)([
                         '--silent',
                         'install',
                         '--prefix',
@@ -131739,7 +131998,7 @@ var __webpack_modules__ = {
                         fallbackNpmCommand: rootFallbackCommand,
                         allowFallbackOnFailure: !wslContext.useWsl && 'npm' !== pm.name && void 0 !== rootFallbackCommand
                     });
-                    console.log(_messages__rspack_import_2.ys(integration));
+                    if (isAuthor) console.log(_messages__rspack_import_3.ys(integration));
                 }
                 return true;
             } catch (error) {
@@ -131757,17 +132016,19 @@ var __webpack_modules__ = {
                     npm_config_userconfig: process.env.npm_config_userconfig,
                     installBaseDir,
                     wslContext,
-                    pm
+                    pm,
+                    errorCode: error?.code,
+                    errorMessage: error instanceof Error ? error.message : String(error || 'unknown error')
                 });
                 const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-                if (isMissingManagerError(error)) console.error(_messages__rspack_import_2.Vo(integration));
-                else console.error(_messages__rspack_import_2.DX(integration, error, isAuthor));
+                if (isMissingManagerError(error)) console.error(_messages__rspack_import_3.Vo(integration));
+                else console.error(_messages__rspack_import_3.DX(integration, error, isAuthor));
                 return false;
             }
         }
         async function installOptionalDependenciesBatch(plans) {
             if (!plans.length) return;
-            console.log(`${pintor__rspack_import_3_default().gray('►►►')} Found ${pintor__rspack_import_3_default().yellow(String(plans.length))} specialized integration${1 === plans.length ? '' : 's'} needing installation...`);
+            console.log(`${pintor__rspack_import_4_default().gray('►►►')} Found ${pintor__rspack_import_4_default().yellow(String(plans.length))} specialized integration${1 === plans.length ? '' : 's'} needing installation...`);
             for (const [index, plan] of plans.entries()){
                 const didInstall = await installOptionalDependencies(plan.integration, plan.dependencies, {
                     index: index + 1,
@@ -131834,7 +132095,6 @@ var __webpack_modules__ = {
             Vo: ()=>optionalInstallManagerMissing,
             _j: ()=>optionalToolingSetup,
             cr: ()=>optionalToolingRootInstall,
-            eG: ()=>optionalInstallRootMissing,
             fD: ()=>cssConfigsDetected,
             uo: ()=>cssIntegrationsEnabled,
             ys: ()=>optionalToolingReady,
@@ -131871,14 +132131,6 @@ var __webpack_modules__ = {
             const prefix = isAuthor ? pintor__rspack_import_0_default().brightMagenta('ERROR Author says') : pintor__rspack_import_0_default().red('ERROR');
             return `${prefix} [${integration}] Failed to install dependencies.\n${pintor__rspack_import_0_default().red(String(error?.message || error))}`;
         }
-        function optionalInstallRootMissing(integration) {
-            const prefix = pintor__rspack_import_0_default().red('ERROR');
-            return [
-                `${prefix} [${integration}] Failed to locate the extension-develop runtime.`,
-                'Optional tooling must install into the extension-develop package, not the user project.',
-                'Reinstall Extension.js or run the command from a valid Extension.js installation.'
-            ].join('\n');
-        }
         function optionalInstallManagerMissing(integration) {
             const prefix = pintor__rspack_import_0_default().red('ERROR');
             return [
@@ -133934,12 +134186,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 manifestPath = path__rspack_import_1.join(projectDir, 'manifest.json');
+            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`;
@@ -134000,32 +134257,34 @@ 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')}.`;
         }
         function buildWarningsDetails(warnings) {
             if (!Array.isArray(warnings) || 0 === warnings.length) return '';
-            const lines = [];
+            const blocks = [];
             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 lines.push(`- Warning ${index + 1}: details were suppressed by tool output.`, `  Source: ${source}`, "  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 ? ` (${artifact})` : '';
-                lines.push(`- ${category}: ${oneLine}${artifactSuffix}`, `  Source: ${source}`, `  Action: ${action}`);
+                const artifactSuffix = artifact ? ` ${pintor__rspack_import_2_default().gray(`(${artifact})`)}` : '';
+                blocks.push(`${getLoggingPrefix('warn')} ${category}: ${oneLine}${artifactSuffix}\n${formatWarningLabelLine('Source', pintor__rspack_import_2_default().gray(source))}\n${formatWarningLabelLine('Hint', hint)}`);
             });
-            return lines.join('\n');
+            return blocks.join('\n\n');
         }
         function fetchingProjectPath(owner, project) {
             return fmt.block('Fetching project', [
@@ -134127,6 +134386,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)}.`;
         }
@@ -134174,6 +134476,50 @@ var __webpack_modules__ = {
             return `${getLoggingPrefix('error')} Your project declares dependencies that are managed by ${pintor__rspack_import_2_default().blue('Extension.js')} and referenced in ${pintor__rspack_import_2_default().underline('extension.config.js')}\n${pintor__rspack_import_2_default().red('This can cause version conflicts and break the development/build process.')}\n\n${pintor__rspack_import_2_default().gray('Managed dependencies (remove these from your package.json):')}\n${list}\n\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(userPackageJsonPath)}\nIf you need a different version, open an issue so we can consider bundling it safely.\nOperation aborted.`;
         }
     },
+    "./webpack/webpack-lib/optional-dependencies.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            ad: ()=>resolveOptionalDependencySpecs,
+            oR: ()=>getOptionalDependenciesSignature
+        });
+        var fs__rspack_import_0 = __webpack_require__("fs");
+        var path__rspack_import_1 = __webpack_require__("path");
+        var crypto__rspack_import_2 = __webpack_require__("crypto");
+        function getOptionalDependenciesPath() {
+            const candidates = [
+                path__rspack_import_1.join(__dirname, 'optional-dependencies.json'),
+                path__rspack_import_1.resolve(__dirname, '..', 'webpack', 'webpack-lib', 'optional-dependencies.json')
+            ];
+            for (const candidate of candidates)if (fs__rspack_import_0.existsSync(candidate)) return candidate;
+            return candidates[0];
+        }
+        function loadOptionalDependencies() {
+            const metadataPath = getOptionalDependenciesPath();
+            if (!fs__rspack_import_0.existsSync(metadataPath)) throw new Error(`optional-dependencies.json not found at ${metadataPath}. This indicates a corrupted installation.`);
+            try {
+                const content = fs__rspack_import_0.readFileSync(metadataPath, 'utf8');
+                const parsed = JSON.parse(content);
+                if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) throw new Error('optional-dependencies.json must contain an object');
+                return parsed;
+            } catch (error) {
+                throw new Error(`Failed to load optional-dependencies.json: ${error.message}`);
+            }
+        }
+        function resolveOptionalDependencySpecs(dependencies) {
+            const metadata = loadOptionalDependencies();
+            const missingFromMetadata = dependencies.filter((dep)=>!(dep in metadata));
+            if (missingFromMetadata.length > 0) throw new Error(`Dependencies not found in optional-dependencies.json: ${missingFromMetadata.join(', ')}`);
+            return dependencies.map((dep)=>`${dep}@${metadata[dep]}`);
+        }
+        function getOptionalDependenciesSignature() {
+            const metadata = loadOptionalDependencies();
+            const stable = JSON.stringify(Object.keys(metadata).sort().reduce((acc, key)=>{
+                acc[key] = metadata[key];
+                return acc;
+            }, {}));
+            return (0, crypto__rspack_import_2.createHash)('sha1').update(stable).digest('hex');
+        }
+    },
     "./webpack/webpack-lib/optional-deps-resolver.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -134187,12 +134533,15 @@ var __webpack_modules__ = {
         var _plugin_css_css_lib_integrations__rspack_import_3 = __webpack_require__("./webpack/plugin-css/css-lib/integrations.ts");
         const installSingleFlight = new Map();
         function getResolutionBases(projectPath) {
+            const optionalInstallRoot = (0, _plugin_css_css_lib_integrations__rspack_import_3.Iy)();
             const extensionRoot = (0, _plugin_css_css_lib_integrations__rspack_import_3.He)();
             const bases = [
                 projectPath,
+                optionalInstallRoot && fs__rspack_import_0.existsSync(optionalInstallRoot) ? optionalInstallRoot : void 0,
                 extensionRoot || void 0,
                 process.cwd()
             ].filter(Boolean);
+            if (optionalInstallRoot && optionalInstallRoot.includes('.pnpm')) bases.push(path__rspack_import_1.join(optionalInstallRoot, '..', '..'));
             if (extensionRoot && extensionRoot.includes('.pnpm')) bases.push(path__rspack_import_1.join(extensionRoot, '..', '..'));
             return Array.from(new Set(bases));
         }
@@ -134364,7 +134713,7 @@ var __webpack_modules__ = {
             }
         }
         async function ensureInstalledAndVerified(input) {
-            const installRoot = (0, _plugin_css_css_lib_integrations__rspack_import_3.He)();
+            const installRoot = (0, _plugin_css_css_lib_integrations__rspack_import_3.Iy)();
             const key = [
                 installRoot || 'missing-install-root',
                 ...input.installDependencies.slice().sort()
@@ -134387,7 +134736,7 @@ var __webpack_modules__ = {
             }
         }
         function resolveOptionalDependencySync(dependencyId, projectPath) {
-            const installRoot = (0, _plugin_css_css_lib_integrations__rspack_import_3.He)();
+            const installRoot = (0, _plugin_css_css_lib_integrations__rspack_import_3.Iy)();
             const resolved = resolveFromKnownLocations(dependencyId, projectPath, installRoot);
             if (resolved) return resolved;
             const bases = getResolutionBases(projectPath);
@@ -134398,7 +134747,7 @@ var __webpack_modules__ = {
                 input.dependencyId
             ];
             const verifyPackageIds = input.verifyPackageIds || installDependencies;
-            const installRoot = (0, _plugin_css_css_lib_integrations__rspack_import_3.He)();
+            const installRoot = (0, _plugin_css_css_lib_integrations__rspack_import_3.Iy)();
             const resolvedBeforeInstall = resolveFromKnownLocations(input.dependencyId, input.projectPath, installRoot);
             const missingBeforeInstall = resolvedBeforeInstall ? getModuleContextMissingDependencies(resolvedBeforeInstall, verifyPackageIds, input.dependencyId, {
                 integration: input.integration
@@ -134475,7 +134824,7 @@ var __webpack_modules__ = {
                         integration: input.integration,
                         dependencyId: input.dependencyId,
                         projectPath: input.projectPath,
-                        installRoot: (0, _plugin_css_css_lib_integrations__rspack_import_3.He)(),
+                        installRoot: (0, _plugin_css_css_lib_integrations__rspack_import_3.Iy)(),
                         installDependencies: input.installDependencies || [
                             input.dependencyId
                         ],
@@ -134593,7 +134942,7 @@ var __webpack_modules__ = {
         }
         function getPackageManagerOverride() {
             const name = normalizePackageManager(process.env.EXTENSION_JS_PACKAGE_MANAGER);
-            const execPath = process.env.EXTENSION_JS_PM_EXEC_PATH;
+            const execPath = process.env.EXTENSION_JS_PM_EXEC_PATH || process.env.npm_execpath || process.env.NPM_EXEC_PATH;
             if (!name && !execPath) return;
             const inferredName = name || inferPackageManagerFromPath(execPath) || 'npm';
             return {
@@ -134603,19 +134952,23 @@ var __webpack_modules__ = {
         }
         function detectPackageManagerFromEnv() {
             const userAgent = process.env.npm_config_user_agent || '';
+            const execPath = process.env.npm_execpath || process.env.NPM_EXEC_PATH || '';
             if (userAgent.includes('pnpm')) return {
-                name: 'pnpm'
+                name: 'pnpm',
+                execPath: execPath || void 0
             };
             if (userAgent.includes('yarn')) return {
-                name: 'yarn'
+                name: 'yarn',
+                execPath: execPath || void 0
             };
             if (userAgent.includes('bun')) return {
-                name: 'bun'
+                name: 'bun',
+                execPath: execPath || void 0
             };
             if (userAgent.includes('npm')) return {
-                name: 'npm'
+                name: 'npm',
+                execPath: execPath || void 0
             };
-            const execPath = process.env.npm_execpath || process.env.NPM_EXEC_PATH || '';
             if (execPath) {
                 const inferred = inferPackageManagerFromPath(execPath) || 'npm';
                 return {
@@ -135106,7 +135459,7 @@ var __webpack_modules__ = {
     },
     "./package.json" (module) {
         "use strict";
-        module.exports = JSON.parse('{"rE":"3.8.16","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-canary.231.7b387a7","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__ = {};
@@ -135667,6 +136020,7 @@ var __webpack_exports__ = {};
     var external_pintor_ = __webpack_require__("pintor");
     var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_);
     var external_crypto_ = __webpack_require__("crypto");
+    var optional_dependencies = __webpack_require__("./webpack/webpack-lib/optional-dependencies.ts");
     function getPreflightCacheDir(packageRoot) {
         return external_path_.join(packageRoot, '.cache', 'extensionjs', 'preflight');
     }
@@ -135677,12 +136031,12 @@ var __webpack_exports__ = {};
         return external_path_.join(cacheDir, 'version.json');
     }
     function getProjectDepsHash(projectPath) {
-        const lockfileSignature = getNearestLockfileSignature(projectPath);
+        const optionalDepsSignature = (0, optional_dependencies.oR)();
         try {
             const packageJsonPath = external_path_.join(projectPath, 'package.json');
             if (!external_fs_.existsSync(packageJsonPath)) return (0, external_crypto_.createHash)('sha1').update(JSON.stringify({
                 packageJson: 'no-package-json',
-                lockfile: lockfileSignature
+                optionalDeps: optionalDepsSignature
             })).digest('hex');
             const raw = external_fs_.readFileSync(packageJsonPath, 'utf8');
             const parsed = JSON.parse(raw || '{}');
@@ -135697,42 +136051,16 @@ var __webpack_exports__ = {};
             const stable = JSON.stringify({
                 dependencies: normalize(deps),
                 devDependencies: normalize(devDeps),
-                lockfile: lockfileSignature
+                optionalDeps: optionalDepsSignature
             });
             return (0, external_crypto_.createHash)('sha1').update(stable).digest('hex');
         } catch  {
             return (0, external_crypto_.createHash)('sha1').update(JSON.stringify({
                 packageJson: 'invalid-package-json',
-                lockfile: lockfileSignature
+                optionalDeps: optionalDepsSignature
             })).digest('hex');
         }
     }
-    function getNearestLockfileSignature(projectPath) {
-        const lockfileNames = [
-            'pnpm-lock.yaml',
-            'package-lock.json',
-            'yarn.lock',
-            'bun.lock',
-            'bun.lockb'
-        ];
-        let current = external_path_.resolve(projectPath);
-        while(true){
-            for (const lockfileName of lockfileNames){
-                const lockfilePath = external_path_.join(current, lockfileName);
-                if (external_fs_.existsSync(lockfilePath)) try {
-                    const content = external_fs_.readFileSync(lockfilePath);
-                    const digest = (0, external_crypto_.createHash)('sha1').update(content).digest('hex');
-                    return `${lockfileName}:${digest}`;
-                } catch  {
-                    return `${lockfileName}:unreadable`;
-                }
-            }
-            const parent = external_path_.dirname(current);
-            if (parent === current) break;
-            current = parent;
-        }
-        return 'none';
-    }
     function ensureCacheVersion(cacheDir) {
         const versionPath = getCacheVersionPath(cacheDir);
         const expectedVersion = package_0.rE;
@@ -135820,12 +136148,15 @@ var __webpack_exports__ = {};
     var postcss = __webpack_require__("./webpack/plugin-css/css-tools/postcss.ts");
     var js_frameworks_lib_messages = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
     function getResolutionPaths(projectPath) {
+        const optionalInstallRoot = (0, integrations.Iy)();
         const extensionRoot = (0, integrations.He)();
         const paths = [
             projectPath || void 0,
+            optionalInstallRoot && external_fs_.existsSync(optionalInstallRoot) ? optionalInstallRoot : void 0,
             extensionRoot || void 0,
             process.cwd()
         ].filter(Boolean);
+        if (optionalInstallRoot && optionalInstallRoot.includes('.pnpm')) paths.push(external_path_.join(optionalInstallRoot, '..', '..'));
         if (extensionRoot && extensionRoot.includes('.pnpm')) paths.push(external_path_.join(extensionRoot, '..', '..'));
         return Array.from(new Set(paths));
     }
@@ -136008,7 +136339,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("535")
+                    __webpack_require__.e("270")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./webpack/webpack-config.ts"))
             ]);
             const debug = isAuthor;
@@ -136045,6 +136376,7 @@ var __webpack_exports__ = {};
                 plugins: allPluginsButBrowserRunners
             });
             const compilerConfig = merge(userConfig);
+            compilerConfig.stats = false;
             const compiler = rspack(compilerConfig);
             let summary = {
                 browser,
@@ -136152,8 +136484,8 @@ var __webpack_exports__ = {};
             if ('true' === process.env.EXTENSION_DEV_DRY_RUN) return;
             const { devServer } = await Promise.all([
                 __webpack_require__.e("215"),
-                __webpack_require__.e("535"),
-                __webpack_require__.e("928")
+                __webpack_require__.e("270"),
+                __webpack_require__.e("324")
             ]).then(__webpack_require__.bind(__webpack_require__, "./webpack/dev-server/index.ts"));
             await devServer(projectStructure, {
                 ...devOptions,
@@ -136280,7 +136612,9 @@ var __webpack_exports__ = {};
             await (0, banner.M)({
                 browser: opts.browser,
                 outPath: opts.outPath,
-                includeExtensionId: false
+                includeExtensionId: true,
+                includeRunId: false,
+                readyPath: opts.readyPath
             });
             return;
         }
@@ -136299,10 +136633,18 @@ var __webpack_exports__ = {};
                 geckoBinary: opts.geckoBinary,
                 port: opts.port
             });
+            await (0, banner.M)({
+                browser: opts.browser,
+                outPath: opts.outPath,
+                includeExtensionId: true,
+                includeRunId: false,
+                readyPath: opts.readyPath
+            });
             return;
         }
         throw new Error(`Unsupported browser: ${String(opts.browser)}`);
     }
+    var dev_server_messages = __webpack_require__("./webpack/dev-server/messages.ts");
     async function extensionPreview(pathOrRemoteUrl, previewOptions) {
         const projectStructure = await getProjectStructure(pathOrRemoteUrl);
         const debug = 'true' === process.env.EXTENSION_AUTHOR_MODE;
@@ -136337,6 +136679,14 @@ var __webpack_exports__ = {};
         if (previewOptions.noBrowser) {
             console.log(messages.k4(browser));
             metadata.writeReady();
+            console.log(dev_server_messages.tl());
+            const browserLabel = String(browser || 'unknown');
+            console.log(dev_server_messages.bL({
+                browser: browserLabel,
+                manifestPath: projectStructure.manifestPath,
+                readyPath: metadata.readyPath,
+                browserModeLabel: `${browserLabel.charAt(0).toUpperCase() + browserLabel.slice(1)} (no-browser mode)`
+            }));
             return;
         }
         const safeBrowserConfig = (0, sanitize.a)(browserConfig);
@@ -136373,6 +136723,7 @@ var __webpack_exports__ = {};
             browser,
             outPath: outputPath,
             contextDir: packageJsonDir,
+            readyPath: metadata.readyPath,
             extensionsToLoad: unpackedExtensionDirsToLoad,
             noOpen: merged.noOpen,
             profile: merged.profile,