extension-develop 3.7.0 → 3.8.0

package/dist/module.cjs

@@ -127339,8 +127339,7 @@ var __webpack_modules__ = {
         });
         var path__rspack_import_0 = __webpack_require__("path");
         var path__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(path__rspack_import_0);
-        var fs__rspack_import_1 = __webpack_require__("fs");
-        var browser_extension_manifest_fields__rspack_import_2 = __webpack_require__("browser-extension-manifest-fields");
+        var browser_extension_manifest_fields__rspack_import_1 = __webpack_require__("browser-extension-manifest-fields");
         function isUnderPublicDir(entry, projectRoot, publicDir) {
             if (!entry) return false;
             const normalizedEntry = String(entry);
@@ -127366,14 +127365,14 @@ var __webpack_modules__ = {
         function getSpecialFoldersDataForCompiler(compiler) {
             const projectRoot = compiler.options.context || '';
             const publicDir = path__rspack_import_0_default().join(projectRoot, 'public');
-            const data = (0, browser_extension_manifest_fields__rspack_import_2.getSpecialFoldersData)({
+            const data = (0, browser_extension_manifest_fields__rspack_import_1.getSpecialFoldersData)({
                 manifestPath: path__rspack_import_0_default().join(projectRoot, 'package.json')
             });
             return finalizeSpecialFoldersData(data, projectRoot, publicDir);
         }
         function getSpecialFoldersDataForProjectRoot(projectRoot) {
             const publicDir = path__rspack_import_0_default().join(projectRoot, 'public');
-            const data = (0, browser_extension_manifest_fields__rspack_import_2.getSpecialFoldersData)({
+            const data = (0, browser_extension_manifest_fields__rspack_import_1.getSpecialFoldersData)({
                 manifestPath: path__rspack_import_0_default().join(projectRoot, 'package.json')
             });
             return finalizeSpecialFoldersData(data, projectRoot, publicDir);
@@ -127383,40 +127382,22 @@ var __webpack_modules__ = {
                 ...data,
                 pages: filterPublicEntrypoints(data.pages, projectRoot, publicDir),
                 scripts: filterPublicEntrypoints(data.scripts, projectRoot, publicDir),
-                extensions: getLocalExtensionsConfig(projectRoot)
+                extensions: void 0
             };
         }
-        function getLocalExtensionsConfig(projectRoot) {
-            if (!projectRoot) return;
-            const extensionsDir = path__rspack_import_0_default().join(projectRoot, 'extensions');
-            try {
-                if (fs__rspack_import_1.existsSync(extensionsDir) && fs__rspack_import_1.statSync(extensionsDir).isDirectory()) return {
-                    dir: './extensions'
-                };
-            } catch  {}
-        }
     },
     "./webpack/plugin-browsers/browsers-lib/banner.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
-            a: ()=>printDevBannerOnce,
-            M: ()=>printProdBannerOnce
+            M: ()=>printProdBannerOnce,
+            a: ()=>printDevBannerOnce
         });
-        var external_fs_ = __webpack_require__("fs");
-        var external_path_ = __webpack_require__("path");
-        var messages = __webpack_require__("./webpack/plugin-browsers/browsers-lib/messages.ts");
-        var webpack_lib_messages = __webpack_require__("./webpack/webpack-lib/messages.ts");
-        const sharedState = {
-            bannerPrinted: false,
-            pendingCompilationLine: ''
-        };
-        function markBannerPrinted() {
-            sharedState.bannerPrinted = true;
-            if (sharedState.pendingCompilationLine) {
-                console.log(sharedState.pendingCompilationLine);
-                sharedState.pendingCompilationLine = '';
-            }
-        }
+        var fs__rspack_import_0 = __webpack_require__("fs");
+        var path__rspack_import_1 = __webpack_require__("path");
+        var crypto__rspack_import_2 = __webpack_require__("crypto");
+        var _messages__rspack_import_3 = __webpack_require__("./webpack/plugin-browsers/browsers-lib/messages.ts");
+        var _webpack_lib_messages__rspack_import_4 = __webpack_require__("./webpack/webpack-lib/messages.ts");
+        var _plugin_compilation_compilation_lib_shared_state__rspack_import_5 = __webpack_require__("./webpack/plugin-compilation/compilation-lib/shared-state.ts");
         const printedKeys = new Set();
         function readUpdateSuffixOnce() {
             const suffix = process.env.EXTENSION_CLI_UPDATE_SUFFIX;
@@ -127427,17 +127408,67 @@ var __webpack_modules__ = {
         function keyFor(browser, outPath, hp) {
             const host = (hp?.host || '127.0.0.1').toString();
             const port = hp?.port == null ? '' : String(hp.port);
-            return `${browser}::${external_path_.resolve(outPath)}::${host}:${port}`;
+            return `${browser}::${path__rspack_import_1.resolve(outPath)}::${host}:${port}`;
+        }
+        function toNormalizedId(value) {
+            if ('string' != typeof value) return '';
+            return value.trim();
+        }
+        function deriveChromiumExtensionIdFromManifest(manifest) {
+            const key = toNormalizedId(manifest?.key);
+            if (!key) return '';
+            try {
+                const decodedKey = Buffer.from(key.replace(/\s+/g, ''), 'base64');
+                if (!decodedKey.length) return '';
+                const digest = (0, crypto__rspack_import_2.createHash)('sha256').update(decodedKey).digest().subarray(0, 16);
+                let extensionId = '';
+                for (const byte of digest){
+                    extensionId += String.fromCharCode(97 + (byte >> 4 & 0x0f));
+                    extensionId += String.fromCharCode(97 + (0x0f & byte));
+                }
+                return extensionId;
+            } catch  {
+                return '';
+            }
+        }
+        function deriveFirefoxExtensionIdFromManifest(manifest) {
+            const fromBrowserSpecificSettings = toNormalizedId(manifest?.browser_specific_settings?.gecko?.id);
+            if (fromBrowserSpecificSettings) return fromBrowserSpecificSettings;
+            return toNormalizedId(manifest?.applications?.gecko?.id);
+        }
+        function resolveExtensionId(args) {
+            const fromInfo = toNormalizedId(args.info?.extensionId);
+            if (fromInfo) return fromInfo;
+            const fromFallback = toNormalizedId(args.fallback?.extensionId);
+            if (fromFallback) return fromFallback;
+            if ('chrome' === args.browser || 'edge' === args.browser || 'chromium' === args.browser || 'chromium-based' === args.browser) return deriveChromiumExtensionIdFromManifest(args.manifest);
+            if ('firefox' === args.browser || 'firefox-based' === args.browser) return deriveFirefoxExtensionIdFromManifest(args.manifest);
+            return '';
         }
         async function printDevBannerOnce(opts) {
             const k = keyFor(opts.browser, opts.outPath, opts.hostPort);
             if (printedKeys.has(k)) return false;
-            const info = await opts.getInfo() || null;
-            const manifestPath = external_path_.join(opts.outPath, 'manifest.json');
+            const manifestPath = path__rspack_import_1.join(opts.outPath, 'manifest.json');
             const updateSuffix = readUpdateSuffixOnce();
-            if (!external_fs_.existsSync(manifestPath)) return false;
-            const manifest = JSON.parse(external_fs_.readFileSync(manifestPath, 'utf-8'));
-            const extensionId = info?.extensionId || opts.fallback?.extensionId || '(temporary)';
+            if (!fs__rspack_import_0.existsSync(manifestPath)) return false;
+            const manifest = JSON.parse(fs__rspack_import_0.readFileSync(manifestPath, 'utf-8'));
+            const manifestDerivedExtensionId = resolveExtensionId({
+                browser: opts.browser,
+                info: null,
+                fallback: opts.fallback,
+                manifest
+            });
+            const info = manifestDerivedExtensionId ? await Promise.race([
+                opts.getInfo().catch(()=>null),
+                new Promise((resolve)=>setTimeout(()=>resolve(null), 250))
+            ]) : await opts.getInfo().catch(()=>null);
+            const extensionId = resolveExtensionId({
+                browser: opts.browser,
+                info,
+                fallback: opts.fallback,
+                manifest
+            });
+            if (!extensionId) return false;
             const name = info?.name || opts.fallback?.name || manifest.name;
             const version1 = info?.version || opts.fallback?.version || manifest.version;
             const message = {
@@ -127449,10 +127480,10 @@ var __webpack_modules__ = {
                     }
                 }
             };
-            console.log(messages.io8());
-            console.log(messages.e_P(manifest, opts.browser, message, opts.browserVersionLine, updateSuffix || void 0));
-            console.log(messages.io8());
-            markBannerPrinted();
+            console.log(_messages__rspack_import_3.io8());
+            console.log(_messages__rspack_import_3.e_P(manifest, opts.browser, message, opts.browserVersionLine, updateSuffix || void 0));
+            console.log(_messages__rspack_import_3.io8());
+            (0, _plugin_compilation_compilation_lib_shared_state__rspack_import_5.If)();
             process.env.EXTENSION_CLI_BANNER_PRINTED = 'true';
             printedKeys.add(k);
             return true;
@@ -127463,23 +127494,33 @@ var __webpack_modules__ = {
             const browserLabel = opts.browserVersionLine && opts.browserVersionLine.trim().length > 0 ? opts.browserVersionLine.trim() : String(opts.browser || 'unknown');
             const updateSuffix = readUpdateSuffixOnce();
             try {
-                const manifestPath = external_path_.join(opts.outPath, 'manifest.json');
-                const manifest = JSON.parse(external_fs_.readFileSync(manifestPath, 'utf-8'));
-                if (opts.runtime && opts.runtime.extensionId) {
+                const manifestPath = path__rspack_import_1.join(opts.outPath, 'manifest.json');
+                const manifest = JSON.parse(fs__rspack_import_0.readFileSync(manifestPath, 'utf-8'));
+                const runtimeInfo = opts.runtime ? {
+                    extensionId: opts.runtime.extensionId,
+                    name: opts.runtime.name,
+                    version: opts.runtime.version
+                } : null;
+                const resolvedExtensionId = resolveExtensionId({
+                    browser: opts.browser,
+                    info: runtimeInfo,
+                    manifest
+                });
+                if (resolvedExtensionId) {
                     const message = {
                         data: {
-                            id: opts.runtime.extensionId,
+                            id: resolvedExtensionId,
                             management: {
-                                name: opts.runtime.name || manifest.name,
-                                version: opts.runtime.version || manifest.version
+                                name: opts.runtime?.name || manifest.name,
+                                version: opts.runtime?.version || manifest.version
                             }
                         }
                     };
-                    console.log(messages.io8());
-                    console.log(messages.e_P(manifest, opts.browser, message, browserLabel, updateSuffix || void 0, {
+                    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
                     }));
-                    console.log(messages.io8());
+                    console.log(_messages__rspack_import_3.io8());
                 } else {
                     const message = {
                         data: {
@@ -127490,18 +127531,18 @@ var __webpack_modules__ = {
                             }
                         }
                     };
-                    console.log(messages.io8());
-                    console.log(messages.e_P(manifest, opts.browser, message, browserLabel, updateSuffix || void 0, {
+                    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
                     }));
-                    console.log(messages.io8());
+                    console.log(_messages__rspack_import_3.io8());
                 }
             } catch  {
-                console.log(messages.io8());
-                console.log(webpack_lib_messages.Al(opts.outPath, browserLabel));
-                console.log(messages.io8());
+                console.log(_messages__rspack_import_3.io8());
+                console.log(_webpack_lib_messages__rspack_import_4.Al(opts.outPath, browserLabel));
+                console.log(_messages__rspack_import_3.io8());
             }
-            markBannerPrinted();
+            (0, _plugin_compilation_compilation_lib_shared_state__rspack_import_5.If)();
             process.env.EXTENSION_CLI_BANNER_PRINTED = 'true';
             printedKeys.add(k);
             return true;
@@ -127886,24 +127927,11 @@ var __webpack_modules__ = {
             else if ('chrome' === browser || 'chromium' === browser || 'firefox' === browser || 'edge' === browser) browserNorm = browser;
             const finalCachePath = browserNorm && cacheDir ? path__rspack_import_0.join(cacheDir, browserNorm) : cacheDir;
             try {
-                if (finalCachePath && finalCachePath.trim().length > 0) {
-                    const lines = cleaned.split(/\r?\n/);
-                    const idx = lines.findIndex((l)=>/npx\s+@puppeteer\/browsers\s+install\s+/i.test(l));
-                    if (-1 !== idx && !/--path\s+/i.test(lines[idx])) {
-                        lines[idx] = `${lines[idx].trim()} --path "${finalCachePath}"`;
-                        cleaned = lines.join('\n');
-                    }
-                    try {
-                        const pwIdx = lines.findIndex((l)=>/npx\s+playwright\s+install(\s+.+)?/i.test(l));
-                        if (-1 !== pwIdx) {
-                            if (finalCachePath && finalCachePath.trim().length > 0) {
-                                const cmd = lines[pwIdx].trim();
-                                const withEnv = 'win32' === process.platform ? `set PLAYWRIGHT_BROWSERS_PATH="${finalCachePath}" && ${cmd}` : `PLAYWRIGHT_BROWSERS_PATH="${finalCachePath}" ${cmd}`;
-                                lines[pwIdx] = withEnv;
-                                cleaned = lines.join('\n');
-                            }
-                        }
-                    } catch  {}
+                const lines = cleaned.split(/\r?\n/);
+                const idx = lines.findIndex((l)=>/npx\s+@puppeteer\/browsers\s+install\s+|npx\s+playwright\s+install(\s+.+)?/i.test(l));
+                if (-1 !== idx) {
+                    lines[idx] = `npx extension install ${browserNorm}`;
+                    cleaned = lines.join('\n');
                 }
             } catch  {}
             body.push(cleaned);
@@ -128218,7 +128246,7 @@ var __webpack_modules__ = {
             const displayName = String(manifestName);
             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) lines.push(`    Extension ID   ${pintor__rspack_import_4_default().gray(cleanId)}`);
+            if (includeExtensionId && cleanId) lines.push(`    Extension ID   ${pintor__rspack_import_4_default().gray(cleanId)}`);
             return lines.join('\n');
         }
         function emptyLine() {
@@ -128956,9 +128984,6 @@ var __webpack_modules__ = {
                     ...isWin ? {
                         windowsHide: true
                     } : {},
-                    ...isWin && /\s/.test(bin) ? {
-                        shell: true
-                    } : {},
                     ...'win32' !== process.platform && {
                         group: process.getgid?.()
                     }
@@ -129103,7 +129128,7 @@ var __webpack_modules__ = {
                     try {
                         return (0, external_chrome_location2_.getInstallGuidance)();
                     } catch  {
-                        return 'npx @puppeteer/browsers install chrome@stable';
+                        return 'npx extension install chrome';
                     }
                 };
                 switch(browser){
@@ -129186,7 +129211,7 @@ var __webpack_modules__ = {
                                         try {
                                             return (0, external_edge_location_.getInstallGuidance)();
                                         } catch  {
-                                            return 'npx playwright install msedge';
+                                            return 'npx extension install edge';
                                         }
                                     })();
                                     this.printEnhancedPuppeteerInstallHint(compilation, guidance, 'edge');
@@ -129201,7 +129226,7 @@ var __webpack_modules__ = {
                                 try {
                                     return (0, external_edge_location_.getInstallGuidance)();
                                 } catch  {
-                                    return 'npx playwright install msedge';
+                                    return 'npx extension install edge';
                                 }
                             })();
                             const fallback = resolveWslWindowsBinary(browser);
@@ -129287,7 +129312,7 @@ var __webpack_modules__ = {
                                 try {
                                     return (0, external_chromium_location_.getInstallGuidance)();
                                 } catch  {
-                                    return 'npx @puppeteer/browsers install chromium';
+                                    return 'npx extension install chromium';
                                 }
                             })();
                             this.printEnhancedPuppeteerInstallHint(compilation, chromiumGuidance, 'chromium');
@@ -130147,6 +130172,9 @@ var __webpack_modules__ = {
                 const args = [
                     '--no-remote',
                     '--new-instance',
+                    ...'win32' === process.platform ? [
+                        '-wait-for-browser'
+                    ] : [],
                     '-profile',
                     profilePath,
                     ...debugPort > 0 ? [
@@ -130357,7 +130385,7 @@ var __webpack_modules__ = {
                                 try {
                                     return (0, external_firefox_location2_.getInstallGuidance)();
                                 } catch  {
-                                    return 'npx @puppeteer/browsers install firefox';
+                                    return 'npx extension install firefox';
                                 }
                             })();
                             this.printInstallHint(compilation, guidance);
@@ -130454,6 +130482,9 @@ var __webpack_modules__ = {
                             '-start-debugger-server',
                             String(debugPort)
                         ] : [],
+                        ...'win32' === process.platform ? [
+                            '-wait-for-browser'
+                        ] : [],
                         '--foreground',
                         '--disable-background-timer-throttling',
                         '--disable-backgrounding-occluded-windows',
@@ -130499,9 +130530,7 @@ var __webpack_modules__ = {
                         this.watchTimeout = void 0;
                     }
                     if ('true' === process.env.EXTENSION_AUTHOR_MODE) this.ctx.logger?.info?.(messages.Tho(this.host.browser));
-                    this.cleanupInstance().finally(()=>{
-                        process.exit();
-                    });
+                    this.cleanupInstance().catch(()=>{});
                 });
                 if ('true' === process.env.EXTENSION_AUTHOR_MODE && child) {
                     child.stdout?.pipe(process.stdout);
@@ -130615,7 +130644,7 @@ var __webpack_modules__ = {
                         host: '127.0.0.1'
                     },
                     getInfo: async ()=>({
-                            extensionId: extensionId || '(temporary)',
+                            extensionId,
                             name: manifest.name,
                             version: manifest.version
                         }),
@@ -131382,6 +131411,31 @@ var __webpack_modules__ = {
             }
         }
     },
+    "./webpack/plugin-compilation/compilation-lib/shared-state.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            FF: ()=>setPendingCompilationLine,
+            If: ()=>markBannerPrinted,
+            TC: ()=>isBannerPrinted
+        });
+        const sharedState = {
+            bannerPrinted: false,
+            pendingCompilationLine: ''
+        };
+        function markBannerPrinted() {
+            sharedState.bannerPrinted = true;
+            if (sharedState.pendingCompilationLine) {
+                console.log(sharedState.pendingCompilationLine);
+                sharedState.pendingCompilationLine = '';
+            }
+        }
+        function isBannerPrinted() {
+            return sharedState.bannerPrinted;
+        }
+        function setPendingCompilationLine(line) {
+            sharedState.pendingCompilationLine = line;
+        }
+    },
     "./webpack/plugin-css/css-lib/integrations.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -131875,20 +131929,35 @@ var __webpack_modules__ = {
             }
             return false;
         }
+        function resolveLessLoader(projectPath) {
+            const extensionRoot = (0, _css_lib_integrations__rspack_import_3.He)();
+            const paths = [
+                projectPath,
+                extensionRoot || void 0,
+                process.cwd()
+            ].filter(Boolean);
+            try {
+                return require.resolve('less-loader', {
+                    paths
+                });
+            } catch  {
+                return;
+            }
+        }
         async function maybeUseLess(projectPath, manifestPath) {
             const resolvedManifestPath = manifestPath || path__rspack_import_0.join(projectPath, 'manifest.json');
             if (!isUsingLess(projectPath)) return [];
-            try {
-                require.resolve('less-loader');
-            } catch (e) {
+            let lessLoaderPath = resolveLessLoader(projectPath);
+            if (!lessLoaderPath) {
                 const lessDependencies = [
                     'less',
                     'less-loader'
                 ];
                 const didInstall = await (0, _css_lib_integrations__rspack_import_3.tm)('LESS', lessDependencies);
                 if (!didInstall) throw new Error('[LESS] Optional dependencies failed to install.');
-                console.log(_css_lib_messages__rspack_import_2.Jv('LESS'));
-                process.exit(0);
+                lessLoaderPath = resolveLessLoader(projectPath);
+                if (!lessLoaderPath) throw new Error('[LESS] less-loader could not be resolved after optional dependency installation.');
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_css_lib_messages__rspack_import_2.Jv('LESS'));
             }
             return [
                 {
@@ -131896,7 +131965,7 @@ var __webpack_modules__ = {
                     exclude: /\.module\.less$/,
                     use: [
                         {
-                            loader: require.resolve('less-loader'),
+                            loader: lessLoaderPath,
                             options: {
                                 sourceMap: true
                             }
@@ -131907,7 +131976,7 @@ var __webpack_modules__ = {
                     test: /\.module\.less$/,
                     use: [
                         {
-                            loader: require.resolve('less-loader'),
+                            loader: lessLoaderPath,
                             options: {
                                 sourceMap: true
                             }
@@ -132112,6 +132181,24 @@ var __webpack_modules__ = {
             return false;
         }
         async function maybeUsePostCss(projectPath, opts) {
+            const getResolutionPaths = ()=>{
+                const extensionRoot = (0, _css_lib_integrations__rspack_import_5.He)();
+                const paths = [
+                    projectPath,
+                    extensionRoot || void 0,
+                    process.cwd()
+                ].filter(Boolean);
+                return Array.from(new Set(paths));
+            };
+            const resolvePostCssLoader = ()=>{
+                try {
+                    return require.resolve('postcss-loader', {
+                        paths: getResolutionPaths()
+                    });
+                } catch  {
+                    return;
+                }
+            };
             const userPostCssConfig = findPostCssConfig(projectPath);
             const userConfigMentionsTailwind = userConfigMentionsTailwindPlugin(userPostCssConfig);
             const userConfigUsesDirectTailwindReference = userConfigUsesDirectTailwindPluginReference(userPostCssConfig);
@@ -132134,9 +132221,8 @@ var __webpack_modules__ = {
             const tailwindPresent = (0, _tailwind__rspack_import_6.F)(projectPath);
             const tailwindConfigured = tailwindPresent || userConfigMentionsTailwind;
             if (!userPostCssConfig && !pkgHasPostCss && !tailwindPresent) return {};
-            try {
-                require.resolve('postcss-loader');
-            } catch (_error) {
+            let resolvedPostCssLoader = resolvePostCssLoader();
+            if (!resolvedPostCssLoader) {
                 if (!(0, _sass__rspack_import_7.fZ)(projectPath) && !(0, _less__rspack_import_8.K)(projectPath)) {
                     const postCssDependencies = [
                         'postcss',
@@ -132145,8 +132231,9 @@ var __webpack_modules__ = {
                     const didInstall = await (0, _css_lib_integrations__rspack_import_5.tm)('PostCSS', postCssDependencies);
                     if (!didInstall) throw new Error('[PostCSS] Optional dependencies failed to install.');
                 }
-                console.log(_css_lib_messages__rspack_import_4.Jv('PostCSS'));
-                process.exit(0);
+                resolvedPostCssLoader = resolvePostCssLoader();
+                if (!resolvedPostCssLoader) throw new Error('[PostCSS] postcss-loader could not be resolved after optional dependency installation.');
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_css_lib_messages__rspack_import_4.Jv('PostCSS'));
             }
             let pluginsFromOptions;
             const shouldInjectTailwindPlugin = tailwindConfigured && !pkgHasPostCss && (!userPostCssConfig || userConfigIsCjsInEsm || userConfigMentionsTailwind);
@@ -132255,7 +132342,7 @@ var __webpack_modules__ = {
             return {
                 test: /\.css$/,
                 type: 'css',
-                loader: require.resolve('postcss-loader'),
+                loader: resolvedPostCssLoader,
                 options: {
                     postcssOptions,
                     sourceMap: 'development' === opts.mode
@@ -132287,6 +132374,21 @@ var __webpack_modules__ = {
             }
             return false;
         }
+        function resolveSassLoader(projectPath) {
+            const extensionRoot = (0, _css_lib_integrations__rspack_import_4.He)();
+            const paths = [
+                projectPath,
+                extensionRoot || void 0,
+                process.cwd()
+            ].filter(Boolean);
+            try {
+                return require.resolve('sass-loader', {
+                    paths
+                });
+            } catch  {
+                return;
+            }
+        }
         function resolveSassImplementation(projectPath) {
             const bases = [
                 projectPath,
@@ -132321,9 +132423,8 @@ var __webpack_modules__ = {
         }
         async function maybeUseSass(projectPath) {
             if (!isUsingSass(projectPath)) return [];
-            try {
-                require.resolve('sass-loader');
-            } catch (e) {
+            let sassLoaderPath = resolveSassLoader(projectPath);
+            if (!sassLoaderPath) {
                 const postCssDependencies = [
                     'postcss-loader',
                     'postcss-scss',
@@ -132336,8 +132437,9 @@ var __webpack_modules__ = {
                 ];
                 const didInstallSass = await (0, _css_lib_integrations__rspack_import_4.tm)('SASS', sassDependencies);
                 if (!didInstallSass) throw new Error('[SASS] Optional dependencies failed to install.');
-                console.log(_css_lib_messages__rspack_import_3.Jv('SASS'));
-                process.exit(0);
+                sassLoaderPath = resolveSassLoader(projectPath);
+                if (!sassLoaderPath) throw new Error('[SASS] sass-loader could not be resolved after optional dependency installation.');
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_css_lib_messages__rspack_import_3.Jv('SASS'));
             }
             return [
                 {
@@ -132345,7 +132447,7 @@ var __webpack_modules__ = {
                     exclude: /\.module\.(sass|scss)$/,
                     use: [
                         {
-                            loader: require.resolve('sass-loader'),
+                            loader: sassLoaderPath,
                             options: createSassLoaderOptions(projectPath, 'development')
                         }
                     ]
@@ -132354,7 +132456,7 @@ var __webpack_modules__ = {
                     test: /\.module\.(sass|scss)$/,
                     use: [
                         {
-                            loader: require.resolve('sass-loader'),
+                            loader: sassLoaderPath,
                             options: createSassLoaderOptions(projectPath, 'development')
                         }
                     ]
@@ -132398,6 +132500,7 @@ var __webpack_modules__ = {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
             Dy: ()=>_plugin_css_css_lib_integrations__rspack_import_0.Dy,
+            He: ()=>_plugin_css_css_lib_integrations__rspack_import_0.He,
             qQ: ()=>isUsingJSFramework,
             tm: ()=>_plugin_css_css_lib_integrations__rspack_import_0.tm,
             ws: ()=>_plugin_css_css_lib_integrations__rspack_import_0.ws
@@ -132515,14 +132618,33 @@ var __webpack_modules__ = {
         var _js_frameworks_lib_messages__rspack_import_3 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
         var _frameworks_lib_integrations__rspack_import_4 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
         let userMessageDelivered = false;
-        let cachedPreactRefreshPlugin;
-        function getPreactRefreshPlugin() {
-            if (cachedPreactRefreshPlugin) return cachedPreactRefreshPlugin;
+        function resolveWithRuntimePaths(id, projectPath) {
+            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_4.He)();
+            const paths = [
+                projectPath,
+                extensionRoot || void 0,
+                process.cwd()
+            ].filter(Boolean);
             try {
-                const mod = __webpack_require__("@rspack/plugin-preact-refresh");
+                return require.resolve(id, {
+                    paths
+                });
+            } catch  {
+                return;
+            }
+        }
+        function getPreactRefreshPlugin(projectPath) {
+            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_4.He)();
+            const bases = [
+                projectPath,
+                extensionRoot || void 0,
+                process.cwd()
+            ].filter(Boolean);
+            for (const base of bases)try {
+                const req = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(base, 'package.json'));
+                const mod = req('@rspack/plugin-preact-refresh');
                 const plugin = mod && mod.default || mod;
-                cachedPreactRefreshPlugin = plugin;
-                return cachedPreactRefreshPlugin;
+                if (plugin) return plugin;
             } catch  {}
         }
         function isUsingPreact(projectPath) {
@@ -132537,9 +132659,8 @@ var __webpack_modules__ = {
         }
         async function maybeUsePreact(projectPath) {
             if (!isUsingPreact(projectPath)) return;
-            try {
-                require.resolve('@rspack/plugin-preact-refresh');
-            } catch (e) {
+            let preactRefreshPath = resolveWithRuntimePaths('@rspack/plugin-preact-refresh', projectPath);
+            if (!preactRefreshPath) {
                 const preactDependencies = [
                     '@prefresh/core',
                     '@prefresh/utils',
@@ -132548,10 +132669,11 @@ var __webpack_modules__ = {
                 ];
                 const didInstall = await (0, _frameworks_lib_integrations__rspack_import_4.tm)('Preact', preactDependencies);
                 if (!didInstall) throw new Error('[Preact] Optional dependencies failed to install.');
-                console.log(_js_frameworks_lib_messages__rspack_import_3.Jv('Preact'));
-                process.exit(0);
+                preactRefreshPath = resolveWithRuntimePaths('@rspack/plugin-preact-refresh', projectPath);
+                if (!preactRefreshPath) throw new Error('[Preact] @rspack/plugin-preact-refresh could not be resolved after optional dependency installation.');
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_3.Jv('Preact'));
             }
-            const PreactRefreshPlugin = getPreactRefreshPlugin();
+            const PreactRefreshPlugin = getPreactRefreshPlugin(projectPath);
             if (!PreactRefreshPlugin) throw new Error('[Preact] @rspack/plugin-preact-refresh is installed but its plugin could not be resolved.');
             const preactPlugins = [
                 new PreactRefreshPlugin({})
@@ -132596,14 +132718,33 @@ var __webpack_modules__ = {
         var _js_frameworks_lib_messages__rspack_import_3 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
         var _frameworks_lib_integrations__rspack_import_4 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
         let userMessageDelivered = false;
-        let cachedReactRefreshPlugin;
-        function getReactRefreshPlugin() {
-            if (cachedReactRefreshPlugin) return cachedReactRefreshPlugin;
+        function resolveWithRuntimePaths(id, projectPath) {
+            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_4.He)();
+            const paths = [
+                projectPath,
+                extensionRoot || void 0,
+                process.cwd()
+            ].filter(Boolean);
             try {
-                const mod = __webpack_require__("@rspack/plugin-react-refresh");
+                return require.resolve(id, {
+                    paths
+                });
+            } catch  {
+                return;
+            }
+        }
+        function getReactRefreshPlugin(projectPath) {
+            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_4.He)();
+            const bases = [
+                projectPath,
+                extensionRoot || void 0,
+                process.cwd()
+            ].filter(Boolean);
+            for (const base of bases)try {
+                const req = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(base, 'package.json'));
+                const mod = req('@rspack/plugin-react-refresh');
                 const plugin = mod && mod.default || mod;
-                cachedReactRefreshPlugin = plugin;
-                return cachedReactRefreshPlugin;
+                if (plugin) return plugin;
             } catch  {}
         }
         function isUsingReact(projectPath) {
@@ -132618,19 +132759,19 @@ var __webpack_modules__ = {
         }
         async function maybeUseReact(projectPath) {
             if (!isUsingReact(projectPath)) return;
-            try {
-                require.resolve('react-refresh');
-            } catch (e) {
+            let reactRefreshPath = resolveWithRuntimePaths('react-refresh', projectPath);
+            if (!reactRefreshPath) {
                 const reactDependencies = [
                     'react-refresh',
                     '@rspack/plugin-react-refresh'
                 ];
                 const didInstall = await (0, _frameworks_lib_integrations__rspack_import_4.tm)('React', reactDependencies);
                 if (!didInstall) throw new Error('[React] Optional dependencies failed to install.');
-                console.log(_js_frameworks_lib_messages__rspack_import_3.Jv('React'));
-                process.exit(0);
+                reactRefreshPath = resolveWithRuntimePaths('react-refresh', projectPath);
+                if (!reactRefreshPath) throw new Error('[React] react-refresh could not be resolved after optional dependency installation.');
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_3.Jv('React'));
             }
-            const ReactRefreshPlugin = getReactRefreshPlugin();
+            const ReactRefreshPlugin = getReactRefreshPlugin(projectPath);
             if (!ReactRefreshPlugin) throw new Error('[React] @rspack/plugin-react-refresh is installed but its plugin could not be resolved.');
             const reactPlugins = [
                 new ReactRefreshPlugin({
@@ -132683,6 +132824,21 @@ var __webpack_modules__ = {
         var _frameworks_lib_integrations__rspack_import_3 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
         var _js_frameworks_lib_load_loader_options__rspack_import_4 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/load-loader-options.ts");
         let userMessageDelivered = false;
+        function resolveWithRuntimePaths(id, projectPath) {
+            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_3.He)();
+            const paths = [
+                projectPath,
+                extensionRoot || void 0,
+                process.cwd()
+            ].filter(Boolean);
+            try {
+                return require.resolve(id, {
+                    paths
+                });
+            } catch  {
+                return;
+            }
+        }
         function resolveFromProject(id, projectPath) {
             try {
                 return require.resolve(id, {
@@ -132705,9 +132861,8 @@ var __webpack_modules__ = {
         }
         async function maybeUseSvelte(projectPath, mode) {
             if (!isUsingSvelte(projectPath)) return;
-            try {
-                resolveFromProject('svelte-loader', projectPath) || require.resolve('svelte-loader');
-            } catch (e) {
+            let svelteLoaderPath = resolveFromProject('svelte-loader', projectPath) || resolveWithRuntimePaths('svelte-loader', projectPath);
+            if (!svelteLoaderPath) {
                 const typeScriptDependencies = [
                     "typescript"
                 ];
@@ -132718,27 +132873,22 @@ var __webpack_modules__ = {
                 ];
                 const didInstallSvelte = await (0, _frameworks_lib_integrations__rspack_import_3.tm)('Svelte', svelteDependencies);
                 if (!didInstallSvelte) throw new Error('[Svelte] Optional dependencies failed to install.');
-                console.log(_js_frameworks_lib_messages__rspack_import_2.Jv('Svelte'));
-                process.exit(0);
+                svelteLoaderPath = resolveFromProject('svelte-loader', projectPath) || resolveWithRuntimePaths('svelte-loader', projectPath);
+                if (!svelteLoaderPath) throw new Error('[Svelte] svelte-loader could not be resolved after optional dependency installation.');
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_2.Jv('Svelte'));
             }
-            try {
-                require.resolve("typescript", {
-                    paths: [
-                        projectPath,
-                        process.cwd()
-                    ]
-                });
-            } catch (e) {
+            const resolvedTypescript = resolveFromProject("typescript", projectPath) || resolveWithRuntimePaths("typescript", projectPath);
+            if (!resolvedTypescript) {
                 const typeScriptDependencies = [
                     "typescript"
                 ];
                 const didInstallTs = await (0, _frameworks_lib_integrations__rspack_import_3.tm)('TypeScript', typeScriptDependencies);
                 if (!didInstallTs) throw new Error('[TypeScript] Optional dependencies failed to install.');
-                console.log(_js_frameworks_lib_messages__rspack_import_2.Jv('TypeScript'));
-                process.exit(0);
+                const reResolvedTypescript = resolveFromProject("typescript", projectPath) || resolveWithRuntimePaths("typescript", projectPath);
+                if (!reResolvedTypescript) throw new Error('[TypeScript] TypeScript could not be resolved after optional dependency installation.');
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_2.Jv('TypeScript'));
             }
             const customOptions = await (0, _js_frameworks_lib_load_loader_options__rspack_import_4.g)(projectPath, 'svelte');
-            const svelteLoaderPath = resolveFromProject('svelte-loader', projectPath) || require.resolve('svelte-loader');
             const defaultLoaders = [
                 {
                     test: /\.svelte\.ts$/,
@@ -132953,16 +133103,33 @@ var __webpack_modules__ = {
         var _frameworks_lib_integrations__rspack_import_5 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
         var _js_frameworks_lib_load_loader_options__rspack_import_6 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/load-loader-options.ts");
         let userMessageDelivered = false;
-        let cachedVueLoaderPlugin;
-        function getVueLoaderPlugin() {
-            if (cachedVueLoaderPlugin) return cachedVueLoaderPlugin;
+        function resolveWithRuntimePaths(id, projectPath) {
+            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_5.He)();
+            const paths = [
+                projectPath,
+                extensionRoot || void 0,
+                process.cwd()
+            ].filter(Boolean);
             try {
-                const mod = __webpack_require__("vue-loader");
+                return require.resolve(id, {
+                    paths
+                });
+            } catch  {
+                return;
+            }
+        }
+        function getVueLoaderPlugin(projectPath) {
+            const extensionRoot = (0, _frameworks_lib_integrations__rspack_import_5.He)();
+            const bases = [
+                projectPath,
+                extensionRoot || void 0,
+                process.cwd()
+            ].filter(Boolean);
+            for (const base of bases)try {
+                const req = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(base, 'package.json'));
+                const mod = req('vue-loader');
                 const plugin = mod && mod.VueLoaderPlugin || mod && mod.default && mod.default.VueLoaderPlugin;
-                if (plugin) {
-                    cachedVueLoaderPlugin = plugin;
-                    return cachedVueLoaderPlugin;
-                }
+                if (plugin) return plugin;
             } catch  {}
         }
         function isUsingVue(projectPath) {
@@ -132975,25 +133142,25 @@ var __webpack_modules__ = {
         }
         async function maybeUseVue(projectPath, mode = 'development') {
             if (!isUsingVue(projectPath)) return;
-            try {
-                require.resolve('vue-loader');
-            } catch (e) {
+            let vueLoaderPath = resolveWithRuntimePaths('vue-loader', projectPath);
+            if (!vueLoaderPath) {
                 const vueDependencies = [
                     'vue-loader',
                     '@vue/compiler-sfc'
                 ];
                 const didInstall = await (0, _frameworks_lib_integrations__rspack_import_5.tm)('Vue', vueDependencies);
                 if (!didInstall) throw new Error('[Vue] Optional dependencies failed to install.');
-                console.log(_js_frameworks_lib_messages__rspack_import_4.Jv('Vue'));
-                process.exit(0);
+                vueLoaderPath = resolveWithRuntimePaths('vue-loader', projectPath);
+                if (!vueLoaderPath) throw new Error('[Vue] vue-loader could not be resolved after optional dependency installation.');
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_4.Jv('Vue'));
             }
-            const VueLoaderPlugin = getVueLoaderPlugin();
+            const VueLoaderPlugin = getVueLoaderPlugin(projectPath);
             if (!VueLoaderPlugin) throw new Error('[Vue] vue-loader is installed but VueLoaderPlugin could not be resolved.');
             const customOptions = await (0, _js_frameworks_lib_load_loader_options__rspack_import_6.g)(projectPath, 'vue');
             const defaultLoaders = [
                 {
                     test: /\.vue$/,
-                    loader: require.resolve('vue-loader'),
+                    loader: vueLoaderPath,
                     options: {
                         experimentalInlineMatchResource: true,
                         ...customOptions || {}
@@ -134172,11 +134339,15 @@ var __webpack_modules__ = {
             const invocation = buildSpawnInvocation(command, args);
             const env = buildExecEnv();
             const stdio = options?.stdio ?? 'ignore';
+            const useShell = 'win32' === process.platform && /\.(cmd|bat)$/i.test(invocation.command);
             return new Promise((resolve, reject)=>{
                 const child = (0, child_process__rspack_import_2.spawn)(invocation.command, invocation.args, {
                     cwd: options?.cwd,
                     stdio,
-                    env: env || process.env
+                    env: env || process.env,
+                    ...useShell ? {
+                        shell: true
+                    } : {}
                 });
                 child.on('close', (code)=>{
                     if (0 !== code) reject(new Error(`Install failed with exit code ${code}`));
@@ -134231,7 +134402,8 @@ var __webpack_modules__ = {
                     if (fs__rspack_import_0.existsSync(path__rspack_import_1.join(nm, '.pnpm'))) return false;
                     if (fs__rspack_import_0.existsSync(path__rspack_import_1.join(nm, '.modules.yaml'))) return false;
                     if (hasMarker) try {
-                        if (fs__rspack_import_0.readdirSync(nm).length > 0) return false;
+                        const entries = fs__rspack_import_0.readdirSync(nm).filter((name)=>'.bin' !== name && !name.startsWith('.cache'));
+                        if (entries.length > 0) return false;
                     } catch  {}
                     const hasInstalledDep = [
                         ...deps,
@@ -134375,14 +134547,6 @@ var __webpack_modules__ = {
         "use strict";
         module.exports = require("@rspack/dev-server");
     },
-    "@rspack/plugin-preact-refresh" (module) {
-        "use strict";
-        module.exports = require("@rspack/plugin-preact-refresh");
-    },
-    "@rspack/plugin-react-refresh" (module) {
-        "use strict";
-        module.exports = require("@rspack/plugin-react-refresh");
-    },
     "adm-zip" (module) {
         "use strict";
         module.exports = require("adm-zip");
@@ -134487,10 +134651,6 @@ var __webpack_modules__ = {
         "use strict";
         module.exports = require("util");
     },
-    "vue-loader" (module) {
-        "use strict";
-        module.exports = require("vue-loader");
-    },
     "webpack-merge" (module) {
         "use strict";
         module.exports = require("webpack-merge");
@@ -134501,7 +134661,7 @@ var __webpack_modules__ = {
     },
     "./package.json" (module) {
         "use strict";
-        module.exports = JSON.parse('{"rE":"3.7.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"}}');
+        module.exports = JSON.parse('{"rE":"3.8.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__ = {};
@@ -134700,6 +134860,8 @@ var __webpack_exports__ = {};
         if (isUrl(pathOrRemoteUrl)) {
             const url = new URL(pathOrRemoteUrl);
             if (url.protocol.startsWith('http')) {
+                const pathname = url.pathname.toLowerCase();
+                if (pathname.endsWith('.zip')) return await importUrlSourceFromZip(pathOrRemoteUrl);
                 if ('https://github.com' !== url.origin) {
                     const urlSource = await importUrlSourceFromZip(pathOrRemoteUrl);
                     return urlSource;
@@ -134866,6 +135028,77 @@ var __webpack_exports__ = {};
             'install'
         ];
     }
+    function findNearestWorkspaceRoot(startDir) {
+        let current = external_path_.resolve(startDir);
+        while(true){
+            const workspaceFile = external_path_.join(current, 'pnpm-workspace.yaml');
+            if (external_fs_.existsSync(workspaceFile)) return current;
+            const parent = external_path_.dirname(current);
+            if (parent === current) return;
+            current = parent;
+        }
+    }
+    function toRelativePath(baseDir, targetDir) {
+        return external_path_.relative(baseDir, targetDir).split(external_path_.sep).join('/');
+    }
+    function parseWorkspacePatterns(workspaceFilePath) {
+        try {
+            const raw = external_fs_.readFileSync(workspaceFilePath, 'utf8');
+            const lines = raw.split(/\r?\n/);
+            const patterns = [];
+            let inPackages = false;
+            for (const line of lines){
+                const trimmed = line.trim();
+                if (!inPackages) {
+                    if ('packages:' === trimmed) inPackages = true;
+                    continue;
+                }
+                if (0 === trimmed.length || trimmed.startsWith('#')) continue;
+                if (!trimmed.startsWith('-')) break;
+                const value = trimmed.slice(1).trim();
+                const unquoted = value.replace(/^['"]|['"]$/g, '');
+                if (unquoted.length > 0) patterns.push(unquoted);
+            }
+            return patterns;
+        } catch  {
+            return [];
+        }
+    }
+    function globToRegExp(glob) {
+        const normalized = glob.replace(/^\.\//, '').replace(/^!/, '').replace(/\/+$/, '');
+        let pattern = '';
+        for(let i = 0; i < normalized.length; i++){
+            const char = normalized[i];
+            if ('*' === char) {
+                if ('*' === normalized[i + 1]) {
+                    pattern += '.*';
+                    i += 1;
+                } else pattern += '[^/]*';
+                continue;
+            }
+            if (/[|\\{}()[\]^$+?.]/.test(char)) pattern += `\\${char}`;
+            else pattern += char;
+        }
+        return new RegExp(`^${pattern}$`);
+    }
+    function isProjectIncludedByWorkspace(workspaceRoot, projectPath) {
+        const workspaceFile = external_path_.join(workspaceRoot, 'pnpm-workspace.yaml');
+        const patterns = parseWorkspacePatterns(workspaceFile);
+        if (0 === patterns.length) return true;
+        const relativeProjectPath = toRelativePath(workspaceRoot, projectPath);
+        let included = false;
+        for (const pattern of patterns){
+            const isNegated = pattern.startsWith('!');
+            const matcher = globToRegExp(pattern);
+            if (matcher.test(relativeProjectPath)) included = !isNegated;
+        }
+        return included;
+    }
+    function shouldUsePnpmIsolatedInstall(projectPath) {
+        const workspaceRoot = findNearestWorkspaceRoot(projectPath);
+        if (!workspaceRoot) return false;
+        return !isProjectIncludedByWorkspace(workspaceRoot, projectPath);
+    }
     async function hasDependenciesToInstall(projectPath) {
         try {
             const raw = await external_fs_.promises.readFile(external_path_.join(projectPath, 'package.json'), 'utf8');
@@ -134893,6 +135126,11 @@ var __webpack_exports__ = {};
                 ...dependenciesArgs,
                 '--include=dev'
             ];
+            if ('pnpm' === pm.name && shouldUsePnpmIsolatedInstall(projectPath)) dependenciesArgs = [
+                ...dependenciesArgs,
+                '--ignore-workspace',
+                '--lockfile=false'
+            ];
             await external_fs_.promises.mkdir(nodeModulesPath, {
                 recursive: true
             });
@@ -135297,8 +135535,9 @@ var __webpack_exports__ = {};
                         console.error(err.stack || err);
                         return reject(err);
                     }
+                    if (!stats || 'function' != typeof stats.hasErrors) return reject(new Error('Build failed: bundler returned invalid stats output (no reliable compilation result).'));
                     if (!buildOptions?.silent && stats) console.log(messages.I(manifestDir, stats, browser));
-                    if (stats?.hasErrors()) {
+                    if (stats.hasErrors()) {
                         handleStatsErrors(stats);
                         if (!shouldExitOnError) return reject(new Error('Build failed with errors'));
                         process.exit(1);