extension-develop 3.5.1 → 3.6.0

package/dist/module.cjs

@@ -127122,6 +127122,280 @@ var __webpack_modules__ = {
         });
         module.exports = library;
     },
+    "./webpack/feature-special-folders/folder-extensions/resolve-config.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            R: ()=>resolveCompanionExtensionsConfig
+        });
+        var external_fs_ = __webpack_require__("fs");
+        var external_path_ = __webpack_require__("path");
+        const external_extension_from_store_namespaceObject = require("extension-from-store");
+        var utils = __webpack_require__("./webpack/feature-special-folders/folder-extensions/utils.ts");
+        function isPathLike(value) {
+            if (external_path_.isAbsolute(value)) return true;
+            if (value.startsWith('./') || value.startsWith('../')) return true;
+            return value.includes('/') || value.includes('\\');
+        }
+        function isSubpathOf(parent, child) {
+            const rel = external_path_.relative(parent, child);
+            return '' !== rel && !rel.startsWith('..') && !external_path_.isAbsolute(rel);
+        }
+        function getBrowserFolder(browser) {
+            if ('firefox' === browser || 'gecko-based' === browser || 'firefox-based' === browser) return 'firefox';
+            if ('edge' === browser) return 'edge';
+            return 'chrome';
+        }
+        function parseChromeWebStoreId(url) {
+            if ('chromewebstore.google.com' !== url.hostname) return null;
+            const match = url.pathname.match(/\/([a-z]{32})(?:\/|$)/i);
+            return match ? match[1] : null;
+        }
+        function parseEdgeAddonsId(url) {
+            if ('microsoftedge.microsoft.com' !== url.hostname) return null;
+            const match = url.pathname.match(/\/([a-z]{32})(?:\/|$)/i);
+            return match ? match[1] : null;
+        }
+        function parseAmoSlug(url) {
+            if ('addons.mozilla.org' !== url.hostname) return null;
+            const match = url.pathname.match(/\/addon\/([^/]+)(?:\/|$)/i);
+            return match ? match[1] : null;
+        }
+        function parseStoreUrl(raw) {
+            let url;
+            try {
+                url = new URL(raw);
+            } catch  {
+                return null;
+            }
+            const chromeId = parseChromeWebStoreId(url);
+            if (chromeId) return {
+                browser: 'chrome',
+                id: chromeId
+            };
+            const edgeId = parseEdgeAddonsId(url);
+            if (edgeId) return {
+                browser: 'edge',
+                id: edgeId
+            };
+            const amoSlug = parseAmoSlug(url);
+            if (amoSlug) return {
+                browser: 'firefox',
+                id: amoSlug
+            };
+            return null;
+        }
+        function ensurePathsUnderExtensions(projectRoot, paths) {
+            const extensionsRoot = external_path_.resolve(projectRoot, 'extensions');
+            return paths.map((p)=>{
+                const abs = (0, utils.A$)(projectRoot, p);
+                if (abs !== extensionsRoot && !isSubpathOf(extensionsRoot, abs) && external_path_.resolve(abs) !== extensionsRoot) throw new Error(`Companion extensions must be inside ${extensionsRoot}.\nInvalid path: ${abs}`);
+                return abs;
+            });
+        }
+        function findExtensionRoots(dir, maxDepth = 3) {
+            const found = [];
+            function walk(current, depth) {
+                if (depth > maxDepth) return;
+                if (!(0, utils.Q7)(current)) return;
+                if ((0, utils.Uy)(current)) return void found.push(current);
+                let entries = [];
+                try {
+                    entries = external_fs_.readdirSync(current, {
+                        withFileTypes: true
+                    });
+                } catch  {
+                    return;
+                }
+                for (const ent of entries)if (ent.isDirectory()) {
+                    if (!ent.name.startsWith('.')) walk(external_path_.join(current, ent.name), depth + 1);
+                }
+            }
+            walk(dir, 0);
+            return found;
+        }
+        async function runExtensionFromStore(url, outDir) {
+            const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+            await (0, external_extension_from_store_namespaceObject.fetchExtensionFromStore)(url, {
+                outDir,
+                extract: true,
+                logger: isAuthor ? {
+                    onInfo: (message)=>console.log(message),
+                    onWarn: (message)=>console.warn(message),
+                    onError: (message, error)=>console.error(message, error)
+                } : void 0
+            });
+        }
+        async function resolveStoreExtensionToPath(opts) {
+            const { projectRoot, storeUrl, browser, id } = opts;
+            const extensionsRoot = external_path_.resolve(projectRoot, 'extensions');
+            const targetRoot = external_path_.join(extensionsRoot, browser, id);
+            const manifestPath = external_path_.join(targetRoot, 'manifest.json');
+            if ((0, utils.fo)(manifestPath)) return targetRoot;
+            await runExtensionFromStore(storeUrl, external_path_.join(extensionsRoot, browser));
+            const candidates = findExtensionRoots(external_path_.join(extensionsRoot, browser));
+            let selected;
+            if (1 === candidates.length) selected = candidates[0];
+            else if (candidates.length > 1) {
+                const directMatch = candidates.find((c)=>external_path_.basename(c) === id);
+                const versionedMatch = candidates.find((c)=>external_path_.basename(c).startsWith(`${id}@`));
+                if (directMatch) selected = directMatch;
+                else if (versionedMatch) selected = versionedMatch;
+            }
+            if (!selected) throw new Error(`Could not locate an unpacked extension from ${storeUrl}.`);
+            external_fs_.mkdirSync(external_path_.dirname(targetRoot), {
+                recursive: true
+            });
+            if (external_path_.basename(selected).startsWith(`${id}@`)) external_fs_.renameSync(selected, targetRoot);
+            return targetRoot;
+        }
+        async function resolveCompanionExtensionsConfig(opts) {
+            const { projectRoot, browser, config } = opts;
+            if (!config) return;
+            const normalized = (0, utils.cz)(config);
+            const runtimeBrowser = getBrowserFolder(browser);
+            const resolvedPaths = [];
+            const localPaths = [];
+            for (const entry of normalized.paths){
+                const parsedStore = parseStoreUrl(entry);
+                if (parsedStore) {
+                    if (parsedStore.browser !== runtimeBrowser) continue;
+                    const resolvedPath = await resolveStoreExtensionToPath({
+                        projectRoot,
+                        storeUrl: entry,
+                        browser: parsedStore.browser,
+                        id: parsedStore.id
+                    });
+                    resolvedPaths.push(resolvedPath);
+                    continue;
+                }
+                if (isPathLike(entry)) localPaths.push(entry);
+            }
+            if (localPaths.length > 0) {
+                const absLocalPaths = ensurePathsUnderExtensions(projectRoot, localPaths);
+                resolvedPaths.push(...absLocalPaths);
+            }
+            const output = {};
+            if ('string' == typeof normalized.dir) {
+                const absDir = (0, utils.A$)(projectRoot, normalized.dir);
+                const extensionsRoot = external_path_.resolve(projectRoot, 'extensions');
+                if (absDir !== extensionsRoot && !isSubpathOf(extensionsRoot, absDir)) throw new Error(`extensions.dir must be inside ${extensionsRoot}.\nInvalid dir: ${absDir}`);
+                output.dir = normalized.dir;
+            }
+            if (resolvedPaths.length > 0) output.paths = resolvedPaths;
+            return output;
+        }
+    },
+    "./webpack/feature-special-folders/folder-extensions/utils.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            A$: ()=>toAbs,
+            Q7: ()=>isDir,
+            Uy: ()=>isValidExtensionRoot,
+            cz: ()=>normalizeCompanionConfig,
+            fo: ()=>isFile
+        });
+        var fs__rspack_import_0 = __webpack_require__("fs");
+        var path__rspack_import_1 = __webpack_require__("path");
+        function isDir(p) {
+            try {
+                return fs__rspack_import_0.existsSync(p) && fs__rspack_import_0.statSync(p).isDirectory();
+            } catch  {
+                return false;
+            }
+        }
+        function isFile(p) {
+            try {
+                return fs__rspack_import_0.existsSync(p) && fs__rspack_import_0.statSync(p).isFile();
+            } catch  {
+                return false;
+            }
+        }
+        function toAbs(projectRoot, p) {
+            return path__rspack_import_1.isAbsolute(p) ? p : path__rspack_import_1.resolve(projectRoot, p);
+        }
+        function isValidExtensionRoot(dir) {
+            if (!isDir(dir)) return false;
+            return isFile(path__rspack_import_1.join(dir, 'manifest.json'));
+        }
+        function normalizeCompanionConfig(config) {
+            const explicitPaths = [];
+            let scanDir;
+            if (Array.isArray(config)) explicitPaths.push(...config.filter((p)=>'string' == typeof p));
+            else if (config && 'object' == typeof config) {
+                if (Array.isArray(config.paths)) explicitPaths.push(...config.paths.filter((p)=>'string' == typeof p));
+                if ('string' == typeof config.dir && config.dir.trim().length > 0) scanDir = config.dir.trim();
+            }
+            return {
+                dir: scanDir,
+                paths: explicitPaths
+            };
+        }
+    },
+    "./webpack/feature-special-folders/get-data.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            B: ()=>getSpecialFoldersDataForCompiler,
+            H: ()=>getSpecialFoldersDataForProjectRoot
+        });
+        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");
+        function isUnderPublicDir(entry, projectRoot, publicDir) {
+            if (!entry) return false;
+            const normalizedEntry = String(entry);
+            const candidate = path__rspack_import_0_default().isAbsolute(normalizedEntry) ? normalizedEntry : path__rspack_import_0_default().join(projectRoot, normalizedEntry);
+            const rel = path__rspack_import_0_default().relative(publicDir, candidate);
+            return Boolean(rel && !rel.startsWith('..') && !path__rspack_import_0_default().isAbsolute(rel));
+        }
+        function filterPublicEntrypoints(list, projectRoot, publicDir) {
+            const next = {};
+            for (const [key, value] of Object.entries(list || {})){
+                if (Array.isArray(value)) {
+                    const filtered = value.filter((entry)=>!isUnderPublicDir(String(entry), projectRoot, publicDir));
+                    if (filtered.length > 0) next[key] = filtered;
+                    continue;
+                }
+                if ('string' == typeof value) {
+                    if (!isUnderPublicDir(value, projectRoot, publicDir)) next[key] = value;
+                    continue;
+                }
+            }
+            return next;
+        }
+        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)({
+                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)({
+                manifestPath: path__rspack_import_0_default().join(projectRoot, 'package.json')
+            });
+            return finalizeSpecialFoldersData(data, projectRoot, publicDir);
+        }
+        function finalizeSpecialFoldersData(data, projectRoot, publicDir) {
+            return {
+                ...data,
+                pages: filterPublicEntrypoints(data.pages, projectRoot, publicDir),
+                scripts: filterPublicEntrypoints(data.scripts, projectRoot, publicDir),
+                extensions: getLocalExtensionsConfig(projectRoot)
+            };
+        }
+        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__, {
@@ -129189,83 +129463,8 @@ var __webpack_modules__ = {
             if (Array.isArray(codeWanted)) return codeWanted.includes(code);
             return code === codeWanted;
         }
+        var firefox_utils = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/firefox-utils.ts");
         var external_path_ = __webpack_require__("path");
-        var banner = __webpack_require__("./webpack/plugin-browsers/browsers-lib/banner.ts");
-        async function waitForManifest(outPath, timeoutMs = 8000) {
-            const manifestPath = external_path_.join(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 printRunningInDevelopmentSummary(candidateAddonPaths, browser, extensionId, browserVersionLine) {
-            try {
-                let chosenPath = null;
-                for (const p of candidateAddonPaths){
-                    const isManager = /extensions\/[a-z-]+-manager/.test(String(p));
-                    const isDevtools = /extension-js-devtools/.test(String(p));
-                    const isThemePath = /extension-js-theme/.test(String(p));
-                    if (isManager || isDevtools || isThemePath) continue;
-                    const mp = external_path_.join(p, 'manifest.json');
-                    if (external_fs_.existsSync(mp)) {
-                        const mf = JSON.parse(external_fs_.readFileSync(mp, 'utf-8'));
-                        const name = mf?.name || '';
-                        const isThemeManifest = mf?.theme != null || 'theme' === String(mf?.type || '');
-                        if ('string' == typeof name && !/Extension\.js DevTools/i.test(name) && !/theme/i.test(name) && !isThemeManifest) {
-                            chosenPath = p;
-                            break;
-                        }
-                    }
-                }
-                if (!chosenPath && candidateAddonPaths.length > 0) chosenPath = candidateAddonPaths[candidateAddonPaths.length - 1];
-                if (!chosenPath) return false;
-                const manifestPath = external_path_.join(chosenPath, 'manifest.json');
-                if (!external_fs_.existsSync(manifestPath)) {
-                    const ready = await waitForManifest(chosenPath, 10000);
-                    if (!ready) return false;
-                }
-                const manifest = JSON.parse(external_fs_.readFileSync(manifestPath, 'utf-8'));
-                const printed = await (0, banner.a)({
-                    browser,
-                    outPath: chosenPath,
-                    hostPort: {
-                        host: '127.0.0.1'
-                    },
-                    getInfo: async ()=>({
-                            extensionId: extensionId || '(temporary)',
-                            name: manifest.name,
-                            version: manifest.version
-                        }),
-                    browserVersionLine
-                });
-                return printed;
-            } catch  {
-                return false;
-            }
-        }
-        function printSourceInspection(html) {
-            console.log(messages.sew());
-            console.log(messages.sew());
-            console.log(html);
-            console.log(messages.sew());
-        }
-        function printLogEventPretty(event, color, colorFns, showTs) {
-            const ts = showTs ? new Date(event.timestamp).toISOString() + ' ' : '';
-            const level = event.level;
-            const context = event.context;
-            const text = event.messageParts[0];
-            const url = event.url;
-            const arrow = 'error' === level ? color ? colorFns.red('►►►') : '►►►' : 'warn' === level ? color ? colorFns.yellow('►►►') : '►►►' : 'log' === level ? color ? colorFns.gray('►►►') : '►►►' : color ? colorFns.blue('►►►') : '►►►';
-            const where = url ? ` ${url}` : '';
-            console.log(`${arrow} ${ts}${context}${where} - ${text}`);
-        }
-        function printLogEventJson(event) {
-            console.log(JSON.stringify(event));
-        }
         function resolveAddonDirectory(baseDir, inputPath) {
             let candidate = inputPath.replace(/\"/g, '');
             if (!external_path_.isAbsolute(candidate)) candidate = external_path_.resolve(baseDir, candidate);
@@ -129279,9 +129478,6 @@ var __webpack_modules__ = {
             if (external_fs_.existsSync(external_path_.join(distFirefox, 'manifest.json'))) return distFirefox;
             return candidate;
         }
-        function normalizeFirefoxAddonPath(addonPath) {
-            return String(addonPath).replace(/\\/g, '/');
-        }
         async function getAddonsActorWithRetry(client, cached, tries = 40, delayMs = 250) {
             if (cached) return cached;
             let addonsActor;
@@ -129306,7 +129502,7 @@ var __webpack_modules__ = {
         }
         function computeCandidateAddonPaths(compilation, extensionsToLoad, projectContext) {
             const projectPath = compilation.options.context || projectContext || process.cwd();
-            return extensionsToLoad.map((ext)=>normalizeFirefoxAddonPath(resolveAddonDirectory(projectPath, ext)));
+            return extensionsToLoad.map((ext)=>resolveAddonDirectory(projectPath, ext));
         }
         async function waitForManagerWelcome(client) {
             for(let i = 0; i < 20; i++){
@@ -129320,12 +129516,22 @@ var __webpack_modules__ = {
         }
         async function installTemporaryAddon(client, addonsActor, addonPath, openDevTools) {
             if (!addonsActor) throw new Error(messages.WVu('firefox', 'No addonsActor available from Firefox RDP.'));
-            const clientResponse = await client.request({
-                to: addonsActor,
-                type: 'installTemporaryAddon',
-                addonPath,
-                openDevTools
-            });
+            const tryInstall = async (pathToUse)=>client.request({
+                    to: addonsActor,
+                    type: 'installTemporaryAddon',
+                    addonPath: pathToUse,
+                    openDevTools
+                });
+            let clientResponse;
+            try {
+                clientResponse = await tryInstall(addonPath);
+            } catch (error) {
+                if ('win32' === process.platform) {
+                    const winPath = String(addonPath).replace(/\//g, '\\');
+                    if (winPath !== addonPath) clientResponse = await tryInstall(winPath);
+                    else throw error;
+                } else throw error;
+            }
             return clientResponse;
         }
         async function deriveMozExtensionId(client) {
@@ -129338,99 +129544,7 @@ var __webpack_modules__ = {
                 } catch  {}
             } catch  {}
         }
-        var external_pintor_ = __webpack_require__("pintor");
-        var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_);
-        async function attachConsoleListeners(client) {
-            try {
-                const targets = await client.getTargets();
-                for (const t of targets || [])try {
-                    const resolved = await client.getTargetFromDescriptor(String(t.actor || ''));
-                    const consoleActor = resolved?.consoleActor || t.consoleActor || t.webConsoleActor;
-                    if (consoleActor) try {
-                        await client.request({
-                            to: consoleActor,
-                            type: 'startListeners',
-                            listeners: [
-                                'ConsoleAPI',
-                                'PageError',
-                                'NetworkActivity'
-                            ]
-                        });
-                    } catch  {}
-                } catch  {}
-            } catch  {}
-        }
-        function subscribeUnifiedLogging(client, opts) {
-            const levelMap = [
-                'trace',
-                'debug',
-                'log',
-                'info',
-                'warn',
-                'error'
-            ];
-            const wantLevel = String(opts.level || 'info').toLowerCase();
-            const wantIdx = Math.max(0, levelMap.indexOf(wantLevel));
-            const wantContexts = Array.isArray(opts.contexts) ? opts.contexts.map((s)=>String(s)) : void 0;
-            const urlFilter = String(opts.urlFilter || '');
-            const tabFilter = opts.tabFilter || '';
-            const fmt = opts.format || 'pretty';
-            const showTs = false !== opts.timestamps;
-            const color = !!opts.color;
-            const colorFns = {
-                red: (s)=>external_pintor_default().red ? external_pintor_default().red(s) : s,
-                yellow: (s)=>external_pintor_default().brightYellow ? external_pintor_default().brightYellow(s) : s,
-                gray: (s)=>external_pintor_default().gray ? external_pintor_default().gray(s) : s,
-                blue: (s)=>external_pintor_default().blue ? external_pintor_default().blue(s) : s
-            };
-            client.on('message', (message)=>{
-                try {
-                    const type = String(message?.type || '');
-                    if (!type) return;
-                    let level = 'info';
-                    let text = '';
-                    let url = '';
-                    let context = 'page';
-                    let tabId;
-                    if ('consoleAPICall' === type || 'logMessage' === type) {
-                        const a = message?.message || message;
-                        level = String(a.level || a.category || 'log').toLowerCase();
-                        const arg = a.arguments && a.arguments[0] || a.message || a.text;
-                        text = String(arg && (arg.value || arg.text || arg.message || arg) || '');
-                        url = String(a.filename || a.sourceName || '');
-                    } else if ('pageError' === type || 'networkEventUpdate' === type) {
-                        level = 'pageError' === type ? 'error' : 'info';
-                        text = String(message?.errorMessage || message?.cause || '');
-                        url = String(message?.url || message?.sourceURL || '');
-                    } else {
-                        if ('tabNavigated' !== type) return;
-                        level = 'debug';
-                        text = String(message?.url || '');
-                        url = String(message?.url || '');
-                    }
-                    context = 'string' == typeof url && url.startsWith('moz-extension://') ? 'background' : 'page';
-                    const idx = Math.max(0, levelMap.indexOf(level));
-                    if (idx < wantIdx) return;
-                    if (wantContexts && wantContexts.length && !wantContexts.includes(context)) return;
-                    if (urlFilter && !String(url || '').includes(urlFilter)) return;
-                    const msgTab = String(message?.from || '');
-                    if (tabFilter && msgTab && !msgTab.includes(tabFilter)) return;
-                    const event = {
-                        id: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
-                        timestamp: Date.now(),
-                        level,
-                        context,
-                        messageParts: [
-                            text
-                        ],
-                        url,
-                        tabId
-                    };
-                    if ('json' === fmt || 'ndjson' === fmt) return void printLogEventJson(event);
-                    printLogEventPretty(event, color, colorFns, showTs);
-                } catch  {}
-            });
-        }
+        var logging = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/logging.ts");
         var source_inspect = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/source-inspect.ts");
         function _define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
@@ -129496,6 +129610,9 @@ var __webpack_modules__ = {
                 let addonsActor = await getAddonsActorWithRetry(client, this.cachedAddonsActor);
                 if (addonsActor) this.cachedAddonsActor = addonsActor;
                 const candidateAddonPaths = computeCandidateAddonPaths(compilation, extensionsToLoad);
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) try {
+                    console.log('[plugin-browsers] Firefox add-on paths:', candidateAddonPaths);
+                } catch  {}
                 for (const [index, addonPath] of candidateAddonPaths.entries()){
                     const isManager = /extensions\/[a-z-]+-manager/.test(String(addonPath));
                     const isDevtoolsEnabled = 0 === index && Boolean(devtools);
@@ -129527,7 +129644,7 @@ var __webpack_modules__ = {
                     if (!this.derivedExtensionId) this.derivedExtensionId = await deriveMozExtensionId(client);
                 } catch  {}
                 this.lastInstalledAddonPath = candidateAddonPaths[0];
-                const bannerPrinted = await printRunningInDevelopmentSummary(candidateAddonPaths, 'firefox', this.derivedExtensionId, this.options.browserVersionLine);
+                const bannerPrinted = await (0, firefox_utils.Rv)(candidateAddonPaths, 'firefox', this.derivedExtensionId, this.options.browserVersionLine);
                 if (!bannerPrinted) throw new Error(messages.WVu(this.options.browser, 'Failed to print runningInDevelopment banner; add-on may not be installed.'));
             }
             markNeedsReinstall() {
@@ -129585,6 +129702,7 @@ var __webpack_modules__ = {
                     const normalized = (changedAssets || []).map((n)=>String(n || '')).map((n)=>n.replace(/\\/g, '/'));
                     const isManifestChanged = normalized.includes('manifest.json');
                     const isLocalesChanged = normalized.some((n)=>/(^|\/)__?locales\/.+\.json$/i.test(n));
+                    const isContentScriptChanged = normalized.some((n)=>/(^|\/)content_scripts\/content-\d+\.(js|css)$/i.test(n));
                     let isServiceWorkerChanged = false;
                     try {
                         const manifestAsset = compilation.getAsset?.('manifest.json');
@@ -129598,7 +129716,7 @@ var __webpack_modules__ = {
                             }
                         }
                     } catch  {}
-                    const critical = isManifestChanged || isLocalesChanged || isServiceWorkerChanged;
+                    const critical = isManifestChanged || isLocalesChanged || isServiceWorkerChanged || isContentScriptChanged;
                     if (!critical) return;
                     await this.reloadAddonOrReinstall(client);
                 } catch  {}
@@ -129612,7 +129730,7 @@ var __webpack_modules__ = {
                     if (!tab) return;
                     if (urlToInspect) await (0, source_inspect.VJ)(client, tab.actor, tab.consoleActor, urlToInspect);
                     const html = await (0, source_inspect.Lj)(client, tab.actor, tab.consoleActor) || '';
-                    printSourceInspection(html);
+                    (0, firefox_utils.z0)(html);
                 } catch (error) {
                     const err = error;
                     console.warn(messages.eO_(err?.message || String(err)));
@@ -129623,7 +129741,7 @@ var __webpack_modules__ = {
                     if (this.loggingAttached) return;
                     const rdpPort = this.resolveRdpPort();
                     const client = this.client || await this.connectClient(rdpPort);
-                    await attachConsoleListeners(client);
+                    await (0, logging.c)(client);
                     const wantLevel = String(opts.level || 'info').toLowerCase();
                     const wantContexts = Array.isArray(opts.contexts) ? opts.contexts.map((s)=>String(s)) : void 0;
                     const urlFilter = String(opts.urlFilter || '');
@@ -129631,7 +129749,7 @@ var __webpack_modules__ = {
                     const fmt = opts.format || 'pretty';
                     const showTs = false !== opts.timestamps;
                     const color = !!opts.color;
-                    subscribeUnifiedLogging(client, {
+                    (0, logging.g)(client, {
                         level: wantLevel,
                         contexts: wantContexts,
                         urlFilter,
@@ -129711,6 +129829,10 @@ var __webpack_modules__ = {
                     return await fn();
                 } catch (error) {
                     lastError = error;
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) try {
+                        const msg = error?.message || String(error);
+                        console.warn(`[plugin-browsers] Firefox RDP setup retry ${i + 1}/${attempts}: ${msg}`);
+                    } catch  {}
                     const ms = baseMs * Math.pow(2, i);
                     await new Promise((r)=>setTimeout(r, ms));
                 }
@@ -129880,9 +130002,9 @@ var __webpack_modules__ = {
                 external_fs_.writeFileSync(userJsPath, userJsContent);
             } catch  {}
             const parts = [
-                `--binary-args="${binaryArgs.join(' ')}"`,
                 '--verbose'
             ];
+            if (binaryArgs.length > 0) parts.unshift(`--binary-args="${binaryArgs.join(' ')}"`);
             if (profilePath) parts.splice(1, 0, `--profile="${profilePath}"`);
             return parts.join(' ');
         }
@@ -130146,7 +130268,8 @@ var __webpack_modules__ = {
                 const firefoxArgs = [];
                 const binaryArgsMatch = firefoxCfg.match(/--binary-args="([^"]*)"/);
                 if (binaryArgsMatch) {
-                    firefoxArgs.push(...binaryArgsMatch[1].split(' '));
+                    const rawArgs = String(binaryArgsMatch[1] || '').trim();
+                    if (rawArgs) firefoxArgs.push(...rawArgs.split(' ').filter((arg)=>arg.trim().length > 0));
                     if ('true' === process.env.EXTENSION_AUTHOR_MODE) this.ctx.logger?.info?.(messages.ivb(binaryArgsMatch[1]));
                 } else if ('true' === process.env.EXTENSION_AUTHOR_MODE) this.ctx.logger?.info?.(messages.dNY());
                 const profileMatch = firefoxCfg.match(/--profile="([^"]*)"/);
@@ -130154,7 +130277,15 @@ var __webpack_modules__ = {
                     const profilePath = profileMatch[1];
                     const { binary, args } = FirefoxBinaryDetector.generateFirefoxArgs(binaryPath, profilePath, debugPort, firefoxArgs);
                     const isWin = 'win32' === process.platform;
-                    const stdio = isWin ? 'ignore' : [
+                    const stdio = isWin ? 'true' === process.env.EXTENSION_AUTHOR_MODE ? [
+                        'pipe',
+                        'pipe',
+                        'pipe'
+                    ] : [
+                        'ignore',
+                        'ignore',
+                        'ignore'
+                    ] : [
                         'pipe',
                         'pipe',
                         'pipe'
@@ -130173,13 +130304,15 @@ var __webpack_modules__ = {
                     }, compilation, debugPort);
                     this.host.rdpController = ctrl;
                     this.ctx.setController(ctrl, debugPort);
+                    this.scheduleWatchTimeout();
                     try {
-                        if ('true' === process.env.EXTENSION_AUTHOR_MODE && this.host.instanceId && profileMatch) {
+                        if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
                             this.ctx.logger?.info?.(messages.pdv(debugPort, desiredDebugPort));
-                            this.ctx.logger?.info?.(messages.dwQ(profileMatch[1]));
+                            this.ctx.logger?.info?.(messages.dwQ(profilePath));
                         }
                     } catch  {}
                 } else {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) this.ctx.logger?.warn?.('[plugin-browsers] Firefox profile not set; skipping RDP add-on install.');
                     const args = [
                         ...debugPort > 0 ? [
                             '-start-debugger-server',
@@ -130192,7 +130325,15 @@ var __webpack_modules__ = {
                         ...firefoxArgs
                     ];
                     const isWin = 'win32' === process.platform;
-                    const stdio = isWin ? 'ignore' : [
+                    const stdio = isWin ? 'true' === process.env.EXTENSION_AUTHOR_MODE ? [
+                        'pipe',
+                        'pipe',
+                        'pipe'
+                    ] : [
+                        'ignore',
+                        'ignore',
+                        'ignore'
+                    ] : [
                         'pipe',
                         'pipe',
                         'pipe'
@@ -130205,6 +130346,7 @@ var __webpack_modules__ = {
                         logger: this.ctx.logger
                     });
                     this.wireChildLifecycle(compilation, debugPort, desiredDebugPort);
+                    this.scheduleWatchTimeout();
                 }
             }
             wireChildLifecycle(compilation, debugPort, desiredDebugPort) {
@@ -130216,6 +130358,10 @@ var __webpack_modules__ = {
                     process.exit(1);
                 });
                 child.on('close', (_code)=>{
+                    if (this.watchTimeout) {
+                        clearTimeout(this.watchTimeout);
+                        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();
@@ -130241,6 +130387,22 @@ var __webpack_modules__ = {
                     }
                 } catch  {}
             }
+            scheduleWatchTimeout() {
+                if (this.watchTimeout) return;
+                if (process.env.VITEST || process.env.VITEST_WORKER_ID) return;
+                const raw = process.env.EXTENSION_WATCH_TIMEOUT_MS || process.env.EXTENSION_DEV_WATCH_TIMEOUT_MS || process.env.EXTJS_WATCH_TIMEOUT_MS || process.env.EXTJS_DEV_WATCH_TIMEOUT_MS || '';
+                const ms = parseInt(String(raw || ''), 10);
+                if (!Number.isFinite(ms) || ms <= 0) return;
+                this.watchTimeout = setTimeout(()=>{
+                    try {
+                        this.ctx.logger?.info?.(`[plugin-browsers] Watch timeout reached (${ms}ms). Shutting down.`);
+                    } catch  {}
+                    this.cleanupInstance().catch(()=>{}).finally(()=>{
+                        process.exit(0);
+                    });
+                }, ms);
+                if ('function' == typeof this.watchTimeout.unref) this.watchTimeout.unref();
+            }
             printInstallHint(compilation, raw) {
                 try {
                     const displayCacheDir = (0, output_binaries_resolver.LB)(compilation);
@@ -130254,11 +130416,201 @@ var __webpack_modules__ = {
                 firefox_launch_define_property(this, "host", void 0);
                 firefox_launch_define_property(this, "ctx", void 0);
                 firefox_launch_define_property(this, "child", null);
+                firefox_launch_define_property(this, "watchTimeout", void 0);
                 this.host = host;
                 this.ctx = ctx;
             }
         }
     },
+    "./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/firefox-utils.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            Rv: ()=>printRunningInDevelopmentSummary,
+            ek: ()=>printLogEventJson,
+            mN: ()=>printLogEventPretty,
+            z0: ()=>printSourceInspection
+        });
+        var path__rspack_import_0 = __webpack_require__("path");
+        var fs__rspack_import_1 = __webpack_require__("fs");
+        var _browsers_lib_messages__rspack_import_2 = __webpack_require__("./webpack/plugin-browsers/browsers-lib/messages.ts");
+        var _browsers_lib_banner__rspack_import_3 = __webpack_require__("./webpack/plugin-browsers/browsers-lib/banner.ts");
+        async function waitForManifest(outPath, timeoutMs = 8000) {
+            const manifestPath = path__rspack_import_0.join(outPath, 'manifest.json');
+            const start = Date.now();
+            while(Date.now() - start < timeoutMs){
+                try {
+                    if (fs__rspack_import_1.existsSync(manifestPath)) return true;
+                } catch  {}
+                await new Promise((resolve)=>setTimeout(resolve, 150));
+            }
+            return false;
+        }
+        async function printRunningInDevelopmentSummary(candidateAddonPaths, browser, extensionId, browserVersionLine) {
+            try {
+                let chosenPath = null;
+                for (const p of candidateAddonPaths){
+                    const isManager = /extensions\/[a-z-]+-manager/.test(String(p));
+                    const isDevtools = /extension-js-devtools/.test(String(p));
+                    const isThemePath = /extension-js-theme/.test(String(p));
+                    if (isManager || isDevtools || isThemePath) continue;
+                    const mp = path__rspack_import_0.join(p, 'manifest.json');
+                    if (fs__rspack_import_1.existsSync(mp)) {
+                        const mf = JSON.parse(fs__rspack_import_1.readFileSync(mp, 'utf-8'));
+                        const name = mf?.name || '';
+                        const isThemeManifest = mf?.theme != null || 'theme' === String(mf?.type || '');
+                        if ('string' == typeof name && !/Extension\.js DevTools/i.test(name) && !/theme/i.test(name) && !isThemeManifest) {
+                            chosenPath = p;
+                            break;
+                        }
+                    }
+                }
+                if (!chosenPath && candidateAddonPaths.length > 0) chosenPath = candidateAddonPaths[candidateAddonPaths.length - 1];
+                if (!chosenPath) return false;
+                const manifestPath = path__rspack_import_0.join(chosenPath, 'manifest.json');
+                if (!fs__rspack_import_1.existsSync(manifestPath)) {
+                    const ready = await waitForManifest(chosenPath, 10000);
+                    if (!ready) return false;
+                }
+                const manifest = JSON.parse(fs__rspack_import_1.readFileSync(manifestPath, 'utf-8'));
+                const printed = await (0, _browsers_lib_banner__rspack_import_3.a)({
+                    browser,
+                    outPath: chosenPath,
+                    hostPort: {
+                        host: '127.0.0.1'
+                    },
+                    getInfo: async ()=>({
+                            extensionId: extensionId || '(temporary)',
+                            name: manifest.name,
+                            version: manifest.version
+                        }),
+                    browserVersionLine
+                });
+                return printed;
+            } catch  {
+                return false;
+            }
+        }
+        function printSourceInspection(html) {
+            console.log(_browsers_lib_messages__rspack_import_2.sew());
+            console.log(_browsers_lib_messages__rspack_import_2.sew());
+            console.log(html);
+            console.log(_browsers_lib_messages__rspack_import_2.sew());
+        }
+        function printLogEventPretty(event, color, colorFns, showTs) {
+            const ts = showTs ? new Date(event.timestamp).toISOString() + ' ' : '';
+            const level = event.level;
+            const context = event.context;
+            const text = event.messageParts[0];
+            const url = event.url;
+            const arrow = 'error' === level ? color ? colorFns.red('►►►') : '►►►' : 'warn' === level ? color ? colorFns.yellow('►►►') : '►►►' : 'log' === level ? color ? colorFns.gray('►►►') : '►►►' : color ? colorFns.blue('►►►') : '►►►';
+            const where = url ? ` ${url}` : '';
+            console.log(`${arrow} ${ts}${context}${where} - ${text}`);
+        }
+        function printLogEventJson(event) {
+            console.log(JSON.stringify(event));
+        }
+    },
+    "./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/logging.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            c: ()=>attachConsoleListeners,
+            g: ()=>subscribeUnifiedLogging
+        });
+        var pintor__rspack_import_0 = __webpack_require__("pintor");
+        var pintor__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_0);
+        var _firefox_utils__rspack_import_1 = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/firefox-utils.ts");
+        async function attachConsoleListeners(client) {
+            try {
+                const targets = await client.getTargets();
+                for (const t of targets || [])try {
+                    const resolved = await client.getTargetFromDescriptor(String(t.actor || ''));
+                    const consoleActor = resolved?.consoleActor || t.consoleActor || t.webConsoleActor;
+                    if (consoleActor) try {
+                        await client.request({
+                            to: consoleActor,
+                            type: 'startListeners',
+                            listeners: [
+                                'ConsoleAPI',
+                                'PageError',
+                                'NetworkActivity'
+                            ]
+                        });
+                    } catch  {}
+                } catch  {}
+            } catch  {}
+        }
+        function subscribeUnifiedLogging(client, opts) {
+            const levelMap = [
+                'trace',
+                'debug',
+                'log',
+                'info',
+                'warn',
+                'error'
+            ];
+            const wantLevel = String(opts.level || 'info').toLowerCase();
+            const wantIdx = Math.max(0, levelMap.indexOf(wantLevel));
+            const wantContexts = Array.isArray(opts.contexts) ? opts.contexts.map((s)=>String(s)) : void 0;
+            const urlFilter = String(opts.urlFilter || '');
+            const tabFilter = opts.tabFilter || '';
+            const fmt = opts.format || 'pretty';
+            const showTs = false !== opts.timestamps;
+            const color = !!opts.color;
+            const colorFns = {
+                red: (s)=>pintor__rspack_import_0_default().red ? pintor__rspack_import_0_default().red(s) : s,
+                yellow: (s)=>pintor__rspack_import_0_default().brightYellow ? pintor__rspack_import_0_default().brightYellow(s) : s,
+                gray: (s)=>pintor__rspack_import_0_default().gray ? pintor__rspack_import_0_default().gray(s) : s,
+                blue: (s)=>pintor__rspack_import_0_default().blue ? pintor__rspack_import_0_default().blue(s) : s
+            };
+            client.on('message', (message)=>{
+                try {
+                    const type = String(message?.type || '');
+                    if (!type) return;
+                    let level = 'info';
+                    let text = '';
+                    let url = '';
+                    let context = 'page';
+                    let tabId;
+                    if ('consoleAPICall' === type || 'logMessage' === type) {
+                        const a = message?.message || message;
+                        level = String(a.level || a.category || 'log').toLowerCase();
+                        const arg = a.arguments && a.arguments[0] || a.message || a.text;
+                        text = String(arg && (arg.value || arg.text || arg.message || arg) || '');
+                        url = String(a.filename || a.sourceName || '');
+                    } else if ('pageError' === type || 'networkEventUpdate' === type) {
+                        level = 'pageError' === type ? 'error' : 'info';
+                        text = String(message?.errorMessage || message?.cause || '');
+                        url = String(message?.url || message?.sourceURL || '');
+                    } else {
+                        if ('tabNavigated' !== type) return;
+                        level = 'debug';
+                        text = String(message?.url || '');
+                        url = String(message?.url || '');
+                    }
+                    context = 'string' == typeof url && url.startsWith('moz-extension://') ? 'background' : 'page';
+                    const idx = Math.max(0, levelMap.indexOf(level));
+                    if (idx < wantIdx) return;
+                    if (wantContexts && wantContexts.length && !wantContexts.includes(context)) return;
+                    if (urlFilter && !String(url || '').includes(urlFilter)) return;
+                    const msgTab = String(message?.from || '');
+                    if (tabFilter && msgTab && !msgTab.includes(tabFilter)) return;
+                    const event = {
+                        id: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+                        timestamp: Date.now(),
+                        level,
+                        context,
+                        messageParts: [
+                            text
+                        ],
+                        url,
+                        tabId
+                    };
+                    if ('json' === fmt || 'ndjson' === fmt) return void (0, _firefox_utils__rspack_import_1.ek)(event);
+                    (0, _firefox_utils__rspack_import_1.mN)(event, color, colorFns, showTs);
+                } catch  {}
+            });
+        }
+    },
     "./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/messaging-client.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -130663,6 +131015,13 @@ var __webpack_modules__ = {
         class MessagingClient extends external_events_default() {
             async connect(port) {
                 await this.transport.connect(port);
+                if (!this.forwardingSetup) {
+                    this.forwardingSetup = true;
+                    this.transport.on('message', (message)=>this.emit('message', message));
+                    this.transport.on('error', (error)=>this.emit('error', error));
+                    this.transport.on('end', ()=>this.emit('end'));
+                    this.transport.on('timeout', ()=>this.emit('timeout'));
+                }
             }
             disconnect() {
                 this.transport.disconnect();
@@ -130782,7 +131141,7 @@ var __webpack_modules__ = {
                 });
             }
             constructor(...args){
-                super(...args), messaging_client_define_property(this, "transport", new RdpTransport());
+                super(...args), messaging_client_define_property(this, "transport", new RdpTransport()), messaging_client_define_property(this, "forwardingSetup", false);
             }
         }
     },
@@ -131254,13 +131613,18 @@ var __webpack_modules__ = {
             const s = text && 0xfeff === text.charCodeAt(0) ? text.slice(1) : text;
             return JSON.parse(s || '{}');
         }
-        function isContentScriptEntry(absolutePath, manifestPath) {
-            if (!absolutePath || !manifestPath) return false;
+        function isContentScriptEntry(absolutePath, manifestPath, projectPath) {
+            if (!absolutePath || !manifestPath || !projectPath) return false;
             if (!fs__rspack_import_1.existsSync(manifestPath)) return false;
             const manifest = parseJsonSafe(fs__rspack_import_1.readFileSync(manifestPath, 'utf8'));
+            const scriptsDir = path__rspack_import_0.resolve(projectPath, "scripts");
+            const absPathNormalized = path__rspack_import_0.resolve(absolutePath);
+            const relToScripts = path__rspack_import_0.relative(scriptsDir, absPathNormalized);
+            const isScriptsFolderScript = relToScripts && !relToScripts.startsWith('..') && !path__rspack_import_0.isAbsolute(relToScripts);
+            if (isScriptsFolderScript) return true;
             for (const content of manifest.content_scripts || [])if (content.js?.length) for (const js of content.js){
                 const contentPath = path__rspack_import_0.resolve(path__rspack_import_0.dirname(manifestPath), js);
-                if (contentPath === absolutePath) return true;
+                if (contentPath === absPathNormalized) return true;
             }
             return false;
         }
@@ -131421,43 +131785,170 @@ var __webpack_modules__ = {
                     generator: {
                         filename: "content_scripts/[name].[contenthash:8].css"
                     },
-                    issuer: (issuer)=>(0, _css_lib_is_content_script__rspack_import_4.z)(issuer, resolvedManifestPath)
+                    issuer: (issuer)=>(0, _css_lib_is_content_script__rspack_import_4.z)(issuer, resolvedManifestPath, projectPath)
+                }
+            ];
+        }
+    },
+    "./webpack/plugin-css/css-tools/postcss.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>isUsingPostCss,
+            t: ()=>maybeUsePostCss
+        });
+        var path__rspack_import_0 = __webpack_require__("path");
+        var fs__rspack_import_1 = __webpack_require__("fs");
+        var module__rspack_import_2 = __webpack_require__("module");
+        var pintor__rspack_import_3 = __webpack_require__("pintor");
+        var pintor__rspack_import_3_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_3);
+        var _css_lib_messages__rspack_import_4 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
+        var _css_lib_integrations__rspack_import_5 = __webpack_require__("./webpack/plugin-css/css-lib/integrations.ts");
+        var _tailwind__rspack_import_6 = __webpack_require__("./webpack/plugin-css/css-tools/tailwind.ts");
+        var _sass__rspack_import_7 = __webpack_require__("./webpack/plugin-css/css-tools/sass.ts");
+        var _less__rspack_import_8 = __webpack_require__("./webpack/plugin-css/css-tools/less.ts");
+        let userMessageDelivered = false;
+        const postCssConfigFiles = [
+            '.postcssrc',
+            '.postcssrc.json',
+            '.postcssrc.yaml',
+            '.postcssrc.yml',
+            'postcss.config.mjs',
+            '.postcssrc.js',
+            '.postcssrc.cjs',
+            'postcss.config.js',
+            'postcss.config.cjs'
+        ];
+        function findPostCssConfig(projectPath) {
+            const ordered = isTypeModuleProject(projectPath) ? [
+                '.postcssrc',
+                '.postcssrc.json',
+                '.postcssrc.yaml',
+                '.postcssrc.yml',
+                'postcss.config.mjs',
+                '.postcssrc.cjs',
+                'postcss.config.cjs',
+                '.postcssrc.js',
+                'postcss.config.js'
+            ] : postCssConfigFiles;
+            for (const configFile of ordered){
+                const configPath = path__rspack_import_0.join(projectPath, configFile);
+                if (fs__rspack_import_1.existsSync(configPath)) return configPath;
+            }
+        }
+        function isTypeModuleProject(projectPath) {
+            try {
+                const raw = fs__rspack_import_1.readFileSync(path__rspack_import_0.join(projectPath, 'package.json'), 'utf8');
+                const pkg = JSON.parse(raw || '{}');
+                return pkg?.type === 'module';
+            } catch  {
+                return false;
+            }
+        }
+        function isLikelyCjsConfigInEsmProject(projectPath, postCssConfigPath) {
+            if (!postCssConfigPath || !postCssConfigPath.endsWith('postcss.config.js')) return false;
+            if (!isTypeModuleProject(projectPath)) return false;
+            try {
+                const text = fs__rspack_import_1.readFileSync(postCssConfigPath, 'utf8');
+                return /module\.exports|require\(/.test(text);
+            } catch  {
+                return false;
+            }
+        }
+        function isLikelyCjsTailwindConfig(tailwindConfigPath) {
+            if (!tailwindConfigPath) return false;
+            if (!tailwindConfigPath.endsWith('.js') && !tailwindConfigPath.endsWith('.cjs')) return false;
+            try {
+                const text = fs__rspack_import_1.readFileSync(tailwindConfigPath, 'utf8');
+                return /module\.exports|require\(/.test(text);
+            } catch  {
+                return false;
+            }
+        }
+        function userConfigMentionsTailwindPlugin(postCssConfigPath) {
+            if (!postCssConfigPath) return false;
+            try {
+                const text = fs__rspack_import_1.readFileSync(postCssConfigPath, 'utf8');
+                return /@tailwindcss\/postcss|tailwindcss/.test(text);
+            } catch  {
+                return false;
+            }
+        }
+        function userConfigUsesDirectTailwindPluginReference(postCssConfigPath) {
+            if (!postCssConfigPath) return false;
+            try {
+                const text = fs__rspack_import_1.readFileSync(postCssConfigPath, 'utf8');
+                return /require\(\s*['"]tailwindcss['"]\s*\)/.test(text) || /plugins\s*:\s*\[[^\]]*\btailwindcss\b/.test(text);
+            } catch  {
+                return false;
+            }
+        }
+        function tailwindStringPluginDisableShims() {
+            return [
+                {
+                    '@tailwindcss/postcss': false
+                },
+                {
+                    tailwindcss: false
                 }
             ];
         }
-    },
-    "./webpack/plugin-css/css-tools/postcss.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        "use strict";
-        __webpack_require__.d(__webpack_exports__, {
-            A: ()=>isUsingPostCss,
-            t: ()=>maybeUsePostCss
-        });
-        var path__rspack_import_0 = __webpack_require__("path");
-        var fs__rspack_import_1 = __webpack_require__("fs");
-        var module__rspack_import_2 = __webpack_require__("module");
-        var pintor__rspack_import_3 = __webpack_require__("pintor");
-        var pintor__rspack_import_3_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_3);
-        var _css_lib_messages__rspack_import_4 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
-        var _css_lib_integrations__rspack_import_5 = __webpack_require__("./webpack/plugin-css/css-lib/integrations.ts");
-        var _tailwind__rspack_import_6 = __webpack_require__("./webpack/plugin-css/css-tools/tailwind.ts");
-        var _sass__rspack_import_7 = __webpack_require__("./webpack/plugin-css/css-tools/sass.ts");
-        var _less__rspack_import_8 = __webpack_require__("./webpack/plugin-css/css-tools/less.ts");
-        let userMessageDelivered = false;
-        const postCssConfigFiles = [
-            '.postcssrc',
-            '.postcssrc.json',
-            '.postcssrc.yaml',
-            '.postcssrc.yml',
-            'postcss.config.mjs',
-            '.postcssrc.js',
-            '.postcssrc.cjs',
-            'postcss.config.js',
-            'postcss.config.cjs'
-        ];
-        function findPostCssConfig(projectPath) {
-            for (const configFile of postCssConfigFiles){
-                const configPath = path__rspack_import_0.join(projectPath, configFile);
-                if (fs__rspack_import_1.existsSync(configPath)) return configPath;
+        function tryLoadCjsConfig(configPath) {
+            try {
+                const source = fs__rspack_import_1.readFileSync(configPath, 'utf8');
+                const moduleObj = {
+                    exports: {}
+                };
+                const exportsObj = moduleObj.exports;
+                const req = (0, module__rspack_import_2.createRequire)(configPath);
+                const fn = new Function('require', 'module', 'exports', '__filename', '__dirname', source);
+                fn(req, moduleObj, exportsObj, configPath, path__rspack_import_0.dirname(configPath));
+                return moduleObj.exports;
+            } catch  {
+                return;
+            }
+        }
+        function normalizeTailwindContentGlobs(config, projectPath) {
+            if (!config || 'object' != typeof config) return config;
+            const normalizeEntry = (entry)=>{
+                if ('string' != typeof entry) return entry;
+                if (entry.startsWith('!')) {
+                    const raw = entry.slice(1);
+                    if (path__rspack_import_0.isAbsolute(raw)) return entry;
+                    return `!${path__rspack_import_0.join(projectPath, raw)}`;
+                }
+                return path__rspack_import_0.isAbsolute(entry) ? entry : path__rspack_import_0.join(projectPath, entry);
+            };
+            const out = {
+                ...config
+            };
+            const content = out.content;
+            if ('string' == typeof content) {
+                out.content = [
+                    normalizeEntry(content)
+                ];
+                return out;
+            }
+            if (Array.isArray(content)) {
+                out.content = content.map(normalizeEntry);
+                return out;
+            }
+            if (content && 'object' == typeof content && Array.isArray(content.files)) out.content = {
+                ...content,
+                files: content.files.map(normalizeEntry)
+            };
+            return out;
+        }
+        function getDeclaredTailwindMajor(projectPath) {
+            try {
+                const raw = fs__rspack_import_1.readFileSync(path__rspack_import_0.join(projectPath, 'package.json'), 'utf8');
+                const pkg = JSON.parse(raw || '{}');
+                const version1 = pkg?.dependencies?.tailwindcss || pkg?.devDependencies?.tailwindcss;
+                if ('string' != typeof version1) return;
+                const match = version1.match(/(\d+)/);
+                if (!match) return;
+                return parseInt(match[1], 10);
+            } catch  {
+                return;
             }
         }
         function isUsingPostCss(projectPath) {
@@ -131486,6 +131977,9 @@ var __webpack_modules__ = {
         }
         async function maybeUsePostCss(projectPath, opts) {
             const userPostCssConfig = findPostCssConfig(projectPath);
+            const userConfigMentionsTailwind = userConfigMentionsTailwindPlugin(userPostCssConfig);
+            const userConfigUsesDirectTailwindReference = userConfigUsesDirectTailwindPluginReference(userPostCssConfig);
+            const userConfigIsCjsInEsm = isLikelyCjsConfigInEsmProject(projectPath, userPostCssConfig);
             function getPackageJsonConfig(p) {
                 try {
                     const raw = fs__rspack_import_1.readFileSync(path__rspack_import_0.join(p, 'package.json'), 'utf8');
@@ -131500,12 +131994,13 @@ var __webpack_modules__ = {
                     };
                 }
             }
-            const { hasPostCss: pkgHasPostCss, config: pkgPostCssConfig } = getPackageJsonConfig(projectPath);
+            const { hasPostCss: pkgHasPostCss } = getPackageJsonConfig(projectPath);
             const tailwindPresent = (0, _tailwind__rspack_import_6.F)(projectPath);
+            const tailwindConfigured = tailwindPresent || userConfigMentionsTailwind;
             if (!userPostCssConfig && !pkgHasPostCss && !tailwindPresent) return {};
             try {
                 require.resolve('postcss-loader');
-            } catch (e) {
+            } catch (_error) {
                 if (!(0, _sass__rspack_import_7.fZ)(projectPath) && !(0, _less__rspack_import_8.K)(projectPath)) {
                     const postCssDependencies = [
                         'postcss',
@@ -131518,39 +132013,102 @@ var __webpack_modules__ = {
                 process.exit(0);
             }
             let pluginsFromOptions;
-            if (tailwindPresent) try {
-                const bases = [
+            const shouldInjectTailwindPlugin = tailwindConfigured && !pkgHasPostCss && (!userPostCssConfig || userConfigIsCjsInEsm || userConfigMentionsTailwind);
+            const declaredTailwindMajor = getDeclaredTailwindMajor(projectPath);
+            if (shouldInjectTailwindPlugin) try {
+                const bases = Array.from(new Set([
                     projectPath,
+                    userPostCssConfig ? path__rspack_import_0.dirname(userPostCssConfig) : '',
                     process.cwd()
+                ].filter(Boolean)));
+                const pluginCandidates = 'number' == typeof declaredTailwindMajor && declaredTailwindMajor < 4 ? [
+                    'tailwindcss',
+                    '@tailwindcss/postcss'
+                ] : [
+                    '@tailwindcss/postcss',
+                    'tailwindcss'
                 ];
                 let tailwindMod;
+                let tailwindPluginId;
                 for (const base of bases)try {
-                    const req = (0, module__rspack_import_2.createRequire)(path__rspack_import_0.join(base, 'package.json'));
-                    tailwindMod = req('@tailwindcss/postcss');
-                    break;
-                } catch (e) {}
+                    const req = (0, module__rspack_import_2.createRequire)(path__rspack_import_0.join(base, '__extensionjs__.js'));
+                    for (const id of pluginCandidates)try {
+                        tailwindMod = req(id);
+                        tailwindPluginId = id;
+                        break;
+                    } catch  {}
+                    if (tailwindMod) break;
+                } catch  {}
                 if (tailwindMod) {
                     if (tailwindMod && 'object' == typeof tailwindMod && 'default' in tailwindMod) tailwindMod = tailwindMod.default;
                     if ('function' == typeof tailwindMod) {
-                        const instance = tailwindMod();
-                        pluginsFromOptions = [
-                            {
-                                '@tailwindcss/postcss': false
-                            },
+                        let instance;
+                        try {
+                            if ('tailwindcss' === tailwindPluginId) {
+                                const configFile = (0, _tailwind__rspack_import_6.r)(projectPath);
+                                if (configFile) if (isLikelyCjsTailwindConfig(configFile)) {
+                                    const loaded = tryLoadCjsConfig(configFile);
+                                    if (loaded && 'object' == typeof loaded) {
+                                        const normalized = normalizeTailwindContentGlobs(loaded, projectPath);
+                                        instance = tailwindMod(normalized);
+                                    } else instance = tailwindMod({
+                                        config: configFile
+                                    });
+                                } else instance = tailwindMod({
+                                    config: configFile
+                                });
+                                else instance = tailwindMod();
+                            } else instance = tailwindMod({
+                                base: projectPath
+                            });
+                        } catch  {
+                            try {
+                                instance = tailwindMod();
+                            } catch  {
+                                if ('tailwindcss' === tailwindPluginId) for (const base of bases)try {
+                                    const req = (0, module__rspack_import_2.createRequire)(path__rspack_import_0.join(base, '__extensionjs__.js'));
+                                    let postcssMod = req('@tailwindcss/postcss');
+                                    if (postcssMod && 'object' == typeof postcssMod && 'default' in postcssMod) postcssMod = postcssMod.default;
+                                    if ('function' == typeof postcssMod) {
+                                        instance = postcssMod({
+                                            base: projectPath
+                                        });
+                                        tailwindPluginId = '@tailwindcss/postcss';
+                                        break;
+                                    }
+                                } catch  {}
+                            }
+                        }
+                        if (instance) pluginsFromOptions = userConfigIsCjsInEsm ? [
+                            instance
+                        ] : [
+                            ...tailwindStringPluginDisableShims(),
                             instance
                         ];
-                    } else if (tailwindMod && 'object' == typeof tailwindMod && 'postcssPlugin' in tailwindMod) pluginsFromOptions = [
-                        {
-                            '@tailwindcss/postcss': false
-                        },
+                    } else if (tailwindMod && 'object' == typeof tailwindMod && 'postcssPlugin' in tailwindMod) pluginsFromOptions = userConfigIsCjsInEsm ? [
                         tailwindMod
+                    ] : [
+                        ...tailwindStringPluginDisableShims(),
+                        tailwindMod
+                    ];
+                }
+            } catch  {}
+            const bypassUserConfigForTailwindCompat = !!pluginsFromOptions && !!userPostCssConfig && userConfigMentionsTailwind && userConfigUsesDirectTailwindReference;
+            if (userConfigIsCjsInEsm || bypassUserConfigForTailwindCompat) try {
+                if ((0, _css_lib_integrations__rspack_import_5.ws)(projectPath, 'autoprefixer')) {
+                    const req = (0, module__rspack_import_2.createRequire)(path__rspack_import_0.join(projectPath, 'package.json'));
+                    const autoprefixerMod = req('autoprefixer');
+                    const autoprefixerPlugin = 'function' == typeof autoprefixerMod ? autoprefixerMod() : autoprefixerMod?.default && 'function' == typeof autoprefixerMod.default ? autoprefixerMod.default() : void 0;
+                    if (autoprefixerPlugin) pluginsFromOptions = [
+                        ...pluginsFromOptions || [],
+                        autoprefixerPlugin
                     ];
                 }
             } catch  {}
             const postcssOptions = {
                 ident: 'postcss',
                 cwd: projectPath,
-                config: projectPath
+                config: userConfigIsCjsInEsm || bypassUserConfigForTailwindCompat ? false : projectPath
             };
             if (pluginsFromOptions) postcssOptions.plugins = pluginsFromOptions;
             if ('true' === process.env.EXTENSION_AUTHOR_MODE) try {
@@ -131814,10 +132372,12 @@ var __webpack_modules__ = {
             K: ()=>isUsingPreact,
             b: ()=>maybeUsePreact
         });
-        var pintor__rspack_import_0 = __webpack_require__("pintor");
-        var pintor__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_0);
-        var _js_frameworks_lib_messages__rspack_import_1 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
-        var _frameworks_lib_integrations__rspack_import_2 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
+        var path__rspack_import_0 = __webpack_require__("path");
+        var module__rspack_import_1 = __webpack_require__("module");
+        var pintor__rspack_import_2 = __webpack_require__("pintor");
+        var pintor__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_2);
+        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() {
@@ -131830,9 +132390,9 @@ var __webpack_modules__ = {
             } catch  {}
         }
         function isUsingPreact(projectPath) {
-            if ((0, _frameworks_lib_integrations__rspack_import_2.ws)(projectPath, 'preact')) {
+            if ((0, _frameworks_lib_integrations__rspack_import_4.ws)(projectPath, 'preact')) {
                 if (!userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_0_default().brightMagenta('►►► Author says')} ${_js_frameworks_lib_messages__rspack_import_1.zA('Preact')}`);
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_2_default().brightMagenta('►►► Author says')} ${_js_frameworks_lib_messages__rspack_import_3.zA('Preact')}`);
                     userMessageDelivered = true;
                 }
                 return true;
@@ -131850,9 +132410,9 @@ var __webpack_modules__ = {
                     '@rspack/plugin-preact-refresh',
                     'preact'
                 ];
-                const didInstall = await (0, _frameworks_lib_integrations__rspack_import_2.tm)('Preact', preactDependencies);
+                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_1.Jv('Preact'));
+                console.log(_js_frameworks_lib_messages__rspack_import_3.Jv('Preact'));
                 process.exit(0);
             }
             const PreactRefreshPlugin = getPreactRefreshPlugin();
@@ -131860,15 +132420,30 @@ var __webpack_modules__ = {
             const preactPlugins = [
                 new PreactRefreshPlugin({})
             ];
+            const requireFromProject = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(projectPath, 'package.json'));
+            const resolveFromProject = (id)=>{
+                try {
+                    return requireFromProject.resolve(id);
+                } catch  {
+                    return;
+                }
+            };
+            const preactCompat = resolveFromProject('preact/compat');
+            const preactTestUtils = resolveFromProject('preact/test-utils');
+            const preactJsxRuntime = resolveFromProject('preact/jsx-runtime');
+            const preactJsxDevRuntime = resolveFromProject('preact/jsx-dev-runtime');
+            const alias = {};
+            if (preactCompat) {
+                alias.react = preactCompat;
+                alias['react-dom'] = preactCompat;
+            }
+            if (preactTestUtils) alias['react-dom/test-utils'] = preactTestUtils;
+            if (preactJsxRuntime) alias['react/jsx-runtime'] = preactJsxRuntime;
+            if (preactJsxDevRuntime) alias['react/jsx-dev-runtime'] = preactJsxDevRuntime;
             return {
                 plugins: preactPlugins,
                 loaders: void 0,
-                alias: {
-                    react: 'preact/compat',
-                    'react-dom/test-utils': 'preact/test-utils',
-                    'react-dom': 'preact/compat',
-                    'react/jsx-runtime': 'preact/jsx-runtime'
-                }
+                alias
             };
         }
     },
@@ -131931,6 +132506,7 @@ var __webpack_modules__ = {
             let reactDomPath;
             let reactDomClientPath;
             let jsxRuntimePath;
+            let jsxDevRuntimePath;
             try {
                 reactPath = requireFromProject.resolve('react');
             } catch  {}
@@ -131943,11 +132519,15 @@ var __webpack_modules__ = {
             try {
                 jsxRuntimePath = requireFromProject.resolve('react/jsx-runtime');
             } catch  {}
+            try {
+                jsxDevRuntimePath = requireFromProject.resolve('react/jsx-dev-runtime');
+            } catch  {}
             const alias = {};
             if (reactPath) alias['react$'] = reactPath;
             if (reactDomPath) alias['react-dom$'] = reactDomPath;
             if (reactDomClientPath) alias['react-dom/client'] = reactDomClientPath;
             if (jsxRuntimePath) alias['react/jsx-runtime'] = jsxRuntimePath;
+            if (jsxDevRuntimePath) alias['react/jsx-dev-runtime'] = jsxDevRuntimePath;
             return {
                 plugins: reactPlugins,
                 loaders: void 0,
@@ -131962,9 +132542,10 @@ var __webpack_modules__ = {
             a: ()=>isUsingSvelte
         });
         var path__rspack_import_0 = __webpack_require__("path");
-        var _js_frameworks_lib_messages__rspack_import_1 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
-        var _frameworks_lib_integrations__rspack_import_2 = __webpack_require__("./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts");
-        var _js_frameworks_lib_load_loader_options__rspack_import_3 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/load-loader-options.ts");
+        var module__rspack_import_1 = __webpack_require__("module");
+        var _js_frameworks_lib_messages__rspack_import_2 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
+        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 resolveFromProject(id, projectPath) {
             try {
@@ -131979,9 +132560,9 @@ var __webpack_modules__ = {
             }
         }
         function isUsingSvelte(projectPath) {
-            const using = (0, _frameworks_lib_integrations__rspack_import_2.ws)(projectPath, 'svelte');
+            const using = (0, _frameworks_lib_integrations__rspack_import_3.ws)(projectPath, 'svelte');
             if (using && !userMessageDelivered) {
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_1.zA('Svelte'));
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_js_frameworks_lib_messages__rspack_import_2.zA('Svelte'));
                 userMessageDelivered = true;
             }
             return using;
@@ -131994,14 +132575,14 @@ var __webpack_modules__ = {
                 const typeScriptDependencies = [
                     "typescript"
                 ];
-                const didInstallTs = await (0, _frameworks_lib_integrations__rspack_import_2.tm)('TypeScript', typeScriptDependencies);
+                const didInstallTs = await (0, _frameworks_lib_integrations__rspack_import_3.tm)('TypeScript', typeScriptDependencies);
                 if (!didInstallTs) throw new Error('[TypeScript] Optional dependencies failed to install.');
                 const svelteDependencies = [
                     'svelte-loader'
                 ];
-                const didInstallSvelte = await (0, _frameworks_lib_integrations__rspack_import_2.tm)('Svelte', svelteDependencies);
+                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_1.Jv('Svelte'));
+                console.log(_js_frameworks_lib_messages__rspack_import_2.Jv('Svelte'));
                 process.exit(0);
             }
             try {
@@ -132015,12 +132596,12 @@ var __webpack_modules__ = {
                 const typeScriptDependencies = [
                     "typescript"
                 ];
-                const didInstallTs = await (0, _frameworks_lib_integrations__rspack_import_2.tm)('TypeScript', typeScriptDependencies);
+                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_1.Jv('TypeScript'));
+                console.log(_js_frameworks_lib_messages__rspack_import_2.Jv('TypeScript'));
                 process.exit(0);
             }
-            const customOptions = await (0, _js_frameworks_lib_load_loader_options__rspack_import_3.g)(projectPath, 'svelte');
+            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 = [
                 {
@@ -132054,7 +132635,25 @@ var __webpack_modules__ = {
                     }
                 }
             ];
-            const alias = void 0;
+            const requireFromProject = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(projectPath, 'package.json'));
+            const resolveSvelteRuntime = (id)=>{
+                try {
+                    return requireFromProject.resolve(id);
+                } catch  {
+                    return;
+                }
+            };
+            const alias = {};
+            const svelteEntry = resolveSvelteRuntime('svelte');
+            const svelteInternal = resolveSvelteRuntime('svelte/internal');
+            const svelteStore = resolveSvelteRuntime('svelte/store');
+            const svelteMotion = resolveSvelteRuntime('svelte/motion');
+            const svelteTransition = resolveSvelteRuntime('svelte/transition');
+            if (svelteEntry) alias.svelte = svelteEntry;
+            if (svelteInternal) alias['svelte/internal'] = svelteInternal;
+            if (svelteStore) alias['svelte/store'] = svelteStore;
+            if (svelteMotion) alias['svelte/motion'] = svelteMotion;
+            if (svelteTransition) alias['svelte/transition'] = svelteTransition;
             const resolverPlugin = {
                 apply (compiler) {
                     const existingMainFields = compiler.options.resolve && compiler.options.resolve.mainFields || [];
@@ -132222,12 +132821,14 @@ var __webpack_modules__ = {
             K: ()=>maybeUseVue,
             L: ()=>isUsingVue
         });
-        var _rspack_core__rspack_import_0 = __webpack_require__("@rspack/core");
-        var pintor__rspack_import_1 = __webpack_require__("pintor");
-        var pintor__rspack_import_1_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_1);
-        var _js_frameworks_lib_messages__rspack_import_2 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
-        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");
+        var path__rspack_import_0 = __webpack_require__("path");
+        var module__rspack_import_1 = __webpack_require__("module");
+        var _rspack_core__rspack_import_2 = __webpack_require__("@rspack/core");
+        var pintor__rspack_import_3 = __webpack_require__("pintor");
+        var pintor__rspack_import_3_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_3);
+        var _js_frameworks_lib_messages__rspack_import_4 = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
+        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() {
@@ -132242,9 +132843,9 @@ var __webpack_modules__ = {
             } catch  {}
         }
         function isUsingVue(projectPath) {
-            const using = (0, _frameworks_lib_integrations__rspack_import_3.ws)(projectPath, 'vue');
+            const using = (0, _frameworks_lib_integrations__rspack_import_5.ws)(projectPath, 'vue');
             if (using && !userMessageDelivered) {
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_1_default().brightMagenta('►►► Author says')} ${_js_frameworks_lib_messages__rspack_import_2.zA('Vue')}`);
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_3_default().brightMagenta('►►► Author says')} ${_js_frameworks_lib_messages__rspack_import_4.zA('Vue')}`);
                 userMessageDelivered = true;
             }
             return using;
@@ -132258,14 +132859,14 @@ var __webpack_modules__ = {
                     'vue-loader',
                     '@vue/compiler-sfc'
                 ];
-                const didInstall = await (0, _frameworks_lib_integrations__rspack_import_3.tm)('Vue', vueDependencies);
+                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_2.Jv('Vue'));
+                console.log(_js_frameworks_lib_messages__rspack_import_4.Jv('Vue'));
                 process.exit(0);
             }
             const VueLoaderPlugin = getVueLoaderPlugin();
             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_4.g)(projectPath, 'vue');
+            const customOptions = await (0, _js_frameworks_lib_load_loader_options__rspack_import_6.g)(projectPath, 'vue');
             const defaultLoaders = [
                 {
                     test: /\.vue$/,
@@ -132281,16 +132882,33 @@ var __webpack_modules__ = {
             const isProd = 'production' === mode;
             const defaultPlugins = [
                 new VueLoaderPlugin(),
-                new _rspack_core__rspack_import_0.DefinePlugin({
+                new _rspack_core__rspack_import_2.DefinePlugin({
                     __VUE_OPTIONS_API__: JSON.stringify(true),
                     __VUE_PROD_DEVTOOLS__: JSON.stringify(!isProd),
                     __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: JSON.stringify(!isProd)
                 })
             ];
+            const requireFromProject = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(projectPath, 'package.json'));
+            const resolveFromProject = (id)=>{
+                try {
+                    return requireFromProject.resolve(id);
+                } catch  {
+                    return;
+                }
+            };
+            const alias = {};
+            const vuePath = resolveFromProject('vue');
+            const vueRuntimeDom = resolveFromProject('@vue/runtime-dom');
+            const vueRuntimeCore = resolveFromProject('@vue/runtime-core');
+            const vueShared = resolveFromProject('@vue/shared');
+            if (vuePath) alias['vue$'] = vuePath;
+            if (vueRuntimeDom) alias['@vue/runtime-dom'] = vueRuntimeDom;
+            if (vueRuntimeCore) alias['@vue/runtime-core'] = vueRuntimeCore;
+            if (vueShared) alias['@vue/shared'] = vueShared;
             return {
                 plugins: defaultPlugins,
                 loaders: defaultLoaders,
-                alias: void 0
+                alias
             };
         }
     },
@@ -132350,76 +132968,6 @@ var __webpack_modules__ = {
             return Object.keys(dependencies).filter((dep)=>!isDependencyInstalled(dep, packageRoot));
         }
     },
-    "./webpack/webpack-lib/companion-extensions.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        "use strict";
-        __webpack_require__.d(__webpack_exports__, {
-            A: ()=>resolveCompanionExtensionDirs
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        function isDir(p) {
-            try {
-                return fs__rspack_import_0.existsSync(p) && fs__rspack_import_0.statSync(p).isDirectory();
-            } catch  {
-                return false;
-            }
-        }
-        function isFile(p) {
-            try {
-                return fs__rspack_import_0.existsSync(p) && fs__rspack_import_0.statSync(p).isFile();
-            } catch  {
-                return false;
-            }
-        }
-        function toAbs(projectRoot, p) {
-            return path__rspack_import_1.isAbsolute(p) ? p : path__rspack_import_1.resolve(projectRoot, p);
-        }
-        function isValidExtensionRoot(dir) {
-            if (!isDir(dir)) return false;
-            return isFile(path__rspack_import_1.join(dir, 'manifest.json'));
-        }
-        function resolveCompanionExtensionDirs(opts) {
-            const { projectRoot, config } = opts;
-            const explicitPaths = [];
-            let scanDir;
-            if (Array.isArray(config)) explicitPaths.push(...config.filter((p)=>'string' == typeof p));
-            else if (config && 'object' == typeof config) {
-                if (Array.isArray(config.paths)) explicitPaths.push(...config.paths.filter((p)=>'string' == typeof p));
-                if ('string' == typeof config.dir && config.dir.trim().length > 0) scanDir = config.dir.trim();
-            }
-            const found = [];
-            for (const p of explicitPaths){
-                const abs = toAbs(projectRoot, p);
-                if (isValidExtensionRoot(abs)) found.push(abs);
-            }
-            if (scanDir) {
-                const absScan = toAbs(projectRoot, scanDir);
-                if (isDir(absScan)) {
-                    let entries = [];
-                    try {
-                        entries = fs__rspack_import_0.readdirSync(absScan, {
-                            withFileTypes: true
-                        });
-                    } catch  {
-                        entries = [];
-                    }
-                    for (const ent of entries){
-                        if (!ent.isDirectory()) continue;
-                        if (ent.name.startsWith('.')) continue;
-                        const candidate = path__rspack_import_1.join(absScan, ent.name);
-                        if (isValidExtensionRoot(candidate)) found.push(candidate);
-                    }
-                }
-            }
-            const unique = [];
-            const seen = new Set();
-            for (const p of found)if (!seen.has(p)) {
-                seen.add(p);
-                unique.push(p);
-            }
-            return unique;
-        }
-    },
     "./webpack/webpack-lib/config-loader.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -132579,9 +133127,13 @@ var __webpack_modules__ = {
                     const baseExtensions = userConfig && userConfig.extensions ? {
                         extensions: userConfig.extensions
                     } : {};
+                    const baseTranspilePackages = userConfig && Array.isArray(userConfig.transpilePackages) ? {
+                        transpilePackages: userConfig.transpilePackages
+                    } : {};
                     const perCommand = userConfig && userConfig.commands && userConfig.commands[command] ? userConfig.commands[command] : {};
                     return {
                         ...baseExtensions,
+                        ...baseTranspilePackages,
                         ...perCommand
                     };
                 } catch (err) {
@@ -132703,6 +133255,18 @@ var __webpack_modules__ = {
         var fs__rspack_import_0 = __webpack_require__("fs");
         var path__rspack_import_1 = __webpack_require__("path");
         var _paths__rspack_import_2 = __webpack_require__("./webpack/webpack-lib/paths.ts");
+        function hasNewTabOverride(extensionDir) {
+            const manifestPath = path__rspack_import_1.join(extensionDir, 'manifest.json');
+            if (!fs__rspack_import_0.existsSync(manifestPath)) return false;
+            try {
+                const raw = fs__rspack_import_0.readFileSync(manifestPath, 'utf-8');
+                const manifest = JSON.parse(raw);
+                const newtab = manifest?.chrome_url_overrides?.newtab;
+                return 'string' == typeof newtab && newtab.trim().length > 0;
+            } catch  {
+                return false;
+            }
+        }
         function computeExtensionsToLoad(baseDir, mode, browser, userExtensionOutputPath, extraExtensionDirs = []) {
             const list = [];
             try {
@@ -132712,7 +133276,10 @@ var __webpack_modules__ = {
                 const themeRoot = path__rspack_import_1.join(distRoot, 'extension-js-theme');
                 const devtoolsForBrowser = path__rspack_import_1.join(devtoolsRoot, engine);
                 const themeForBrowser = path__rspack_import_1.join(themeRoot, engine);
-                if ('production' !== mode && fs__rspack_import_0.existsSync(devtoolsForBrowser)) list.push(devtoolsForBrowser);
+                const userHasNewTabOverride = hasNewTabOverride(userExtensionOutputPath);
+                const devtoolsHasNewTabOverride = hasNewTabOverride(devtoolsForBrowser);
+                const shouldSkipDevtoolsForNtpConflict = userHasNewTabOverride && devtoolsHasNewTabOverride;
+                if ('production' !== mode && fs__rspack_import_0.existsSync(devtoolsForBrowser) && !shouldSkipDevtoolsForNtpConflict) list.push(devtoolsForBrowser);
                 if (fs__rspack_import_0.existsSync(themeForBrowser)) list.push(themeForBrowser);
             } catch  {}
             for (const p of extraExtensionDirs)list.push(p);
@@ -133136,6 +133703,77 @@ 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/package-json.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            Pb: ()=>findNearestPackageJsonSync,
+            cy: ()=>findNearestPackageJson,
+            t7: ()=>validatePackageJson
+        });
+        var path__rspack_import_0 = __webpack_require__("path");
+        var fs__rspack_import_1 = __webpack_require__("fs");
+        async function findUpLocal(filename, options) {
+            const root = path__rspack_import_0.parse(options.cwd).root;
+            let currentDir = options.cwd;
+            while(true){
+                const candidate = path__rspack_import_0.join(currentDir, filename);
+                try {
+                    const stat = await fs__rspack_import_1.promises.stat(candidate);
+                    if (stat.isFile()) return candidate;
+                } catch  {}
+                if (currentDir === root) return;
+                currentDir = path__rspack_import_0.dirname(currentDir);
+            }
+        }
+        function findUpLocalSync(filename, options) {
+            const root = path__rspack_import_0.parse(options.cwd).root;
+            let currentDir = options.cwd;
+            while(true){
+                const candidate = path__rspack_import_0.join(currentDir, filename);
+                try {
+                    const stat = fs__rspack_import_1.statSync(candidate);
+                    if (stat.isFile()) return candidate;
+                } catch  {}
+                if (currentDir === root) return;
+                currentDir = path__rspack_import_0.dirname(currentDir);
+            }
+        }
+        async function findNearestPackageJson(manifestPath) {
+            try {
+                const manifestDir = path__rspack_import_0.dirname(manifestPath);
+                const packageJsonPath = await findUpLocal('package.json', {
+                    cwd: manifestDir
+                });
+                return packageJsonPath || null;
+            } catch (error) {
+                console.warn('Failed to find package.json:', error);
+                return null;
+            }
+        }
+        function findNearestPackageJsonSync(manifestPath) {
+            try {
+                const manifestDir = path__rspack_import_0.dirname(manifestPath);
+                const packageJsonPath = findUpLocalSync('package.json', {
+                    cwd: manifestDir
+                });
+                return packageJsonPath || null;
+            } catch (error) {
+                console.warn('Failed to find package.json:', error);
+                return null;
+            }
+        }
+        function validatePackageJson(packageJsonPath) {
+            try {
+                if (!fs__rspack_import_1.existsSync(packageJsonPath)) return false;
+                const content = fs__rspack_import_1.readFileSync(packageJsonPath, 'utf-8');
+                JSON.parse(content);
+                return true;
+            } catch (error) {
+                console.warn('Invalid package.json at:', packageJsonPath, error);
+                return false;
+            }
+        }
+    },
     "./webpack/webpack-lib/package-manager.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -133455,12 +134093,15 @@ var __webpack_modules__ = {
                     const depsCount = Object.keys(packageJson?.dependencies || {}).length;
                     const devDepsCount = Object.keys(packageJson?.devDependencies || {}).length;
                     if (depsCount + devDepsCount === 0) return false;
-                    if ((0, _install_cache__rspack_import_2.Q)(packageJsonDir)) return false;
                     if (!fs__rspack_import_0.existsSync(nm)) return true;
                     const deps = Object.keys(packageJson?.dependencies || {});
                     const devDeps = Object.keys(packageJson?.devDependencies || {});
+                    const hasMarker = (0, _install_cache__rspack_import_2.Q)(packageJsonDir);
                     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;
+                    } catch  {}
                     const hasInstalledDep = [
                         ...deps,
                         ...devDeps
@@ -133539,6 +134180,11 @@ var __webpack_modules__ = {
             J: ()=>startProgressBar,
             u: ()=>shouldShowProgress
         });
+        function clearLine() {
+            if (!process.stdout.isTTY) return;
+            process.stdout.write('\r');
+            process.stdout.write('\x1b[2K');
+        }
         function stripAnsi(input) {
             return input.replace(/\x1b\[[0-9;]*m/g, '');
         }
@@ -133560,7 +134206,8 @@ var __webpack_modules__ = {
                 const bar = `[${'='.repeat(filled)}${' '.repeat(empty)}]`;
                 const line = `${label} ${bar}`;
                 lastVisibleLength = stripAnsi(line).length;
-                process.stdout.write(`\r${line}`);
+                clearLine();
+                process.stdout.write(line);
                 tick = (tick + 1) % (width + 1);
             };
             render();
@@ -133569,7 +134216,11 @@ var __webpack_modules__ = {
                 stop: ()=>{
                     clearInterval(timer);
                     if (process.stdout.isTTY) {
-                        process.stdout.write(`\r${' '.repeat(lastVisibleLength)}\r`);
+                        clearLine();
+                        if (lastVisibleLength > 0) {
+                            process.stdout.write(' '.repeat(lastVisibleLength));
+                            process.stdout.write('\r');
+                        }
                         if (options?.persistLabel) process.stdout.write(`${label}\n`);
                     }
                 }
@@ -133719,7 +134370,7 @@ var __webpack_modules__ = {
     },
     "./package.json" (module) {
         "use strict";
-        module.exports = JSON.parse('{"rE":"3.5.1","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","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.6.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__ = {};
@@ -133814,42 +134465,7 @@ var __webpack_exports__ = {};
     var external_path_ = __webpack_require__("path");
     var external_fs_ = __webpack_require__("fs");
     var messages = __webpack_require__("./webpack/webpack-lib/messages.ts");
-    async function findUpLocal(filename, options) {
-        const root = external_path_.parse(options.cwd).root;
-        let currentDir = options.cwd;
-        while(true){
-            const candidate = external_path_.join(currentDir, filename);
-            try {
-                const stat = await external_fs_.promises.stat(candidate);
-                if (stat.isFile()) return candidate;
-            } catch  {}
-            if (currentDir === root) return;
-            currentDir = external_path_.dirname(currentDir);
-        }
-    }
-    async function findNearestPackageJson(manifestPath) {
-        try {
-            const manifestDir = external_path_.dirname(manifestPath);
-            const packageJsonPath = await findUpLocal('package.json', {
-                cwd: manifestDir
-            });
-            return packageJsonPath || null;
-        } catch (error) {
-            console.warn('Failed to find package.json:', error);
-            return null;
-        }
-    }
-    function validatePackageJson(packageJsonPath) {
-        try {
-            if (!external_fs_.existsSync(packageJsonPath)) return false;
-            const content = external_fs_.readFileSync(packageJsonPath, 'utf-8');
-            JSON.parse(content);
-            return true;
-        } catch (error) {
-            console.warn('Invalid package.json at:', packageJsonPath, error);
-            return false;
-        }
-    }
+    var package_json = __webpack_require__("./webpack/webpack-lib/package-json.ts");
     const isUrl = (url)=>{
         try {
             new URL(url);
@@ -133971,15 +134587,24 @@ var __webpack_exports__ = {};
     }
     async function getProjectStructure(pathOrRemoteUrl) {
         const projectPath = await getProjectPath(pathOrRemoteUrl);
-        let manifestPath = external_path_.join(projectPath, 'manifest.json');
+        const isUnderDir = (baseDir, candidatePath)=>{
+            const rel = external_path_.relative(baseDir, candidatePath);
+            return Boolean(rel && !rel.startsWith('..') && !external_path_.isAbsolute(rel));
+        };
+        const packageJsonPathFromProject = await (0, package_json.cy)(external_path_.join(projectPath, 'manifest.json'));
+        const packageJsonDirFromProject = packageJsonPathFromProject ? external_path_.dirname(packageJsonPathFromProject) : void 0;
+        const rootManifestPath = external_path_.join(projectPath, 'manifest.json');
+        const srcManifestPath = external_path_.join(projectPath, 'src', 'manifest.json');
+        let manifestPath = external_fs_.existsSync(srcManifestPath) ? srcManifestPath : rootManifestPath;
         if (!external_fs_.existsSync(manifestPath)) {
+            if (packageJsonDirFromProject) throw new Error(messages.dx(manifestPath));
             const findManifest = (dir)=>{
                 const files = external_fs_.readdirSync(dir, {
                     withFileTypes: true
                 });
                 for (const file of files){
                     if (file.isFile() && 'manifest.json' === file.name) return external_path_.join(dir, file.name);
-                    if (file.isDirectory() && !file.name.startsWith('.') && 'node_modules' !== file.name && 'dist' !== file.name) {
+                    if (file.isDirectory() && !file.name.startsWith('.') && 'node_modules' !== file.name && 'dist' !== file.name && 'public' !== file.name) {
                         const found = findManifest(external_path_.join(dir, file.name));
                         if (found) return found;
                     }
@@ -133990,8 +134615,19 @@ var __webpack_exports__ = {};
             if (foundManifest) manifestPath = foundManifest;
             else throw new Error(messages.dx(manifestPath));
         }
-        const packageJsonPath = await findNearestPackageJson(manifestPath);
-        if (!packageJsonPath || !validatePackageJson(packageJsonPath)) return {
+        const packageJsonPath = await (0, package_json.cy)(manifestPath);
+        const packageJsonDir = packageJsonPath ? external_path_.dirname(packageJsonPath) : void 0;
+        if (packageJsonDir) {
+            const publicRoot = external_path_.join(packageJsonDir, 'public');
+            if (isUnderDir(publicRoot, manifestPath)) {
+                const fallbackSrc = external_path_.join(packageJsonDir, 'src', 'manifest.json');
+                const fallbackRoot = external_path_.join(packageJsonDir, 'manifest.json');
+                if (external_fs_.existsSync(fallbackSrc)) manifestPath = fallbackSrc;
+                else if (external_fs_.existsSync(fallbackRoot)) manifestPath = fallbackRoot;
+                else throw new Error(messages.dx(fallbackRoot));
+            }
+        }
+        if (!packageJsonPath || !(0, package_json.t7)(packageJsonPath)) return {
             manifestPath
         };
         return {
@@ -134458,6 +135094,8 @@ var __webpack_exports__ = {};
             stdio
         });
     }
+    var resolve_config = __webpack_require__("./webpack/feature-special-folders/folder-extensions/resolve-config.ts");
+    var get_data = __webpack_require__("./webpack/feature-special-folders/get-data.ts");
     async function extensionBuild(pathOrRemoteUrl, buildOptions) {
         const require1 = (0, external_module_.createRequire)(__rslib_import_meta_url__);
         const projectStructure = await getProjectStructure(pathOrRemoteUrl);
@@ -134486,21 +135124,29 @@ 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("547")
+                    __webpack_require__.e("535")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./webpack/webpack-config.ts"))
             ]);
             const debug = isAuthor;
             if (projectStructure.packageJsonPath) assertNoManagedDependencyConflicts(projectStructure.packageJsonPath, manifestDir);
             const commandConfig = await (0, config_loader.eY)(manifestDir, 'build');
+            const specialFoldersData = (0, get_data.H)(packageJsonDir);
             const distPath = (0, webpack_lib_paths.q4)(packageJsonDir, browser);
             if (debug) {
                 console.log(messages.SG(manifestDir, packageJsonDir));
                 console.log(messages._A(browser, buildOptions?.chromiumBinary, buildOptions?.geckoBinary || buildOptions?.firefoxBinary));
                 console.log(messages.AC(distPath));
             }
+            const mergedExtensionsConfig = buildOptions?.extensions ?? commandConfig.extensions ?? specialFoldersData.extensions;
+            const resolvedExtensionsConfig = await (0, resolve_config.R)({
+                projectRoot: packageJsonDir,
+                browser,
+                config: mergedExtensionsConfig
+            });
             const baseConfig = webpackConfig(projectStructure, {
                 ...commandConfig,
                 ...buildOptions,
+                extensions: resolvedExtensionsConfig,
                 browser,
                 mode: 'production',
                 output: {
@@ -134616,7 +135262,7 @@ var __webpack_exports__ = {};
             if ('true' === process.env.EXTENSION_DEV_DRY_RUN) return;
             const { devServer } = await Promise.all([
                 __webpack_require__.e("215"),
-                __webpack_require__.e("547"),
+                __webpack_require__.e("535"),
                 __webpack_require__.e("928")
             ]).then(__webpack_require__.bind(__webpack_require__, "./webpack/dev-server/index.ts"));
             await devServer(projectStructure, {
@@ -134631,7 +135277,61 @@ var __webpack_exports__ = {};
         }
     }
     var sanitize = __webpack_require__("./webpack/webpack-lib/sanitize.ts");
-    var companion_extensions = __webpack_require__("./webpack/webpack-lib/companion-extensions.ts");
+    var utils = __webpack_require__("./webpack/feature-special-folders/folder-extensions/utils.ts");
+    function resolveCompanionExtensionDirs(opts) {
+        const { projectRoot, config } = opts;
+        const normalized = (0, utils.cz)(config);
+        const explicitPaths = normalized.paths;
+        const scanDir = normalized.dir;
+        const found = [];
+        for (const p of explicitPaths){
+            const abs = (0, utils.A$)(projectRoot, p);
+            if ((0, utils.Uy)(abs)) found.push(abs);
+        }
+        if (scanDir) {
+            const absScan = (0, utils.A$)(projectRoot, scanDir);
+            if ((0, utils.Q7)(absScan)) {
+                let entries = [];
+                try {
+                    entries = external_fs_.readdirSync(absScan, {
+                        withFileTypes: true
+                    });
+                } catch  {
+                    entries = [];
+                }
+                const scanOneLevel = (rootDir)=>{
+                    let dirEntries = [];
+                    try {
+                        dirEntries = external_fs_.readdirSync(rootDir, {
+                            withFileTypes: true
+                        });
+                    } catch  {
+                        dirEntries = [];
+                    }
+                    for (const ent of dirEntries){
+                        if (!ent.isDirectory()) continue;
+                        if (ent.name.startsWith('.')) continue;
+                        const candidate = external_path_.join(rootDir, ent.name);
+                        if ((0, utils.Uy)(candidate)) found.push(candidate);
+                    }
+                };
+                scanOneLevel(absScan);
+                if ('extensions' === external_path_.basename(absScan)) for (const ent of entries){
+                    if (!ent.isDirectory()) continue;
+                    if (ent.name.startsWith('.')) continue;
+                    const browserDir = external_path_.join(absScan, ent.name);
+                    scanOneLevel(browserDir);
+                }
+            }
+        }
+        const unique = [];
+        const seen = new Set();
+        for (const p of found)if (!seen.has(p)) {
+            seen.add(p);
+            unique.push(p);
+        }
+        return unique;
+    }
     var extensions_to_load = __webpack_require__("./webpack/webpack-lib/extensions-to-load.ts");
     var dark_mode = __webpack_require__("./webpack/webpack-lib/dark-mode.ts");
     var output_binaries_resolver = __webpack_require__("./webpack/plugin-browsers/browsers-lib/output-binaries-resolver.ts");
@@ -134734,12 +135434,20 @@ var __webpack_exports__ = {};
         const safeBrowserConfig = (0, sanitize.a)(browserConfig);
         const safeCommandConfig = (0, sanitize.a)(commandConfig);
         const safePreviewOptions = (0, sanitize.a)(previewOptions);
+        const specialFoldersData = (0, get_data.H)(packageJsonDir);
+        const mergedExtensionsConfig = safePreviewOptions.extensions ?? safeCommandConfig.extensions ?? safeBrowserConfig.extensions ?? specialFoldersData.extensions;
+        const resolvedExtensionsConfig = await (0, resolve_config.R)({
+            projectRoot: packageJsonDir,
+            browser,
+            config: mergedExtensionsConfig
+        });
         const mergedGeckoBinary = safePreviewOptions.geckoBinary || safePreviewOptions.firefoxBinary || safeCommandConfig.geckoBinary || safeCommandConfig.firefoxBinary || safeBrowserConfig.geckoBinary || safeBrowserConfig.firefoxBinary;
         const mergedChromiumBinary = safePreviewOptions.chromiumBinary || safeCommandConfig.chromiumBinary || safeBrowserConfig.chromiumBinary;
         const merged = {
             ...safeBrowserConfig,
             ...safeCommandConfig,
             ...safePreviewOptions,
+            extensions: resolvedExtensionsConfig,
             chromiumBinary: mergedChromiumBinary,
             geckoBinary: mergedGeckoBinary
         };
@@ -134748,7 +135456,7 @@ var __webpack_exports__ = {};
             browserFlags: merged.browserFlags,
             preferences: merged.preferences
         });
-        const companionUnpackedExtensionDirs = (0, companion_extensions.A)({
+        const companionUnpackedExtensionDirs = resolveCompanionExtensionDirs({
             projectRoot: packageJsonDir,
             config: merged.extensions
         });