extension-develop 3.15.1 → 3.16.0

package/dist/module.cjs

@@ -1,3479 +0,0 @@
-"use strict";
-const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
-    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
-}();
-var __webpack_modules__ = {
-    "./dev-server/messages.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            Df: ()=>autoExitForceKill,
-            Gc: ()=>ready,
-            Nq: ()=>bundlerFatalError,
-            UF: ()=>devServerStartTimeout,
-            VL: ()=>extensionJsRunnerError,
-            aO: ()=>portInUse,
-            bL: ()=>browserRunnerDisabled,
-            eP: ()=>bundlerRecompiling,
-            nI: ()=>noEntrypointsDetected,
-            o6: ()=>autoExitModeEnabled,
-            tJ: ()=>autoExitTriggered,
-            tl: ()=>spacerLine
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var pintor__rspack_import_1 = __webpack_require__("pintor");
-        var pintor__rspack_import_1_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_1);
-        function getLoggingPrefix(type) {
-            const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-            if (isAuthor) {
-                const base = 'error' === type ? 'ERROR Author says' : '⏵⏵⏵ Author says';
-                return pintor__rspack_import_1_default().brightMagenta(base);
-            }
-            if ('error' === type) return pintor__rspack_import_1_default().red('ERROR');
-            if ('warn' === type) return pintor__rspack_import_1_default().brightYellow('⏵⏵⏵');
-            if ('info' === type) return pintor__rspack_import_1_default().gray('⏵⏵⏵');
-            return pintor__rspack_import_1_default().green('⏵⏵⏵');
-        }
-        function ready(mode, browser) {
-            const key = String(browser || '').toLowerCase();
-            const extensionOutput = 'firefox' === key || 'gecko-based' === key || 'firefox-based' === key || 'edge' === key ? 'Add-on' : 'Extension';
-            const cap = 'firefox' === key || 'gecko-based' === key || 'firefox-based' === key ? 'Firefox' : String(browser || '').charAt(0).toUpperCase() + String(browser || '').slice(1);
-            const pretty = pintor__rspack_import_1_default().green('ready for ' + mode);
-            return `${getLoggingPrefix('info')} ${cap} ${extensionOutput} ${pretty}.`;
-        }
-        function readJsonRecord(filePath) {
-            try {
-                return JSON.parse(fs__rspack_import_0.readFileSync(filePath, 'utf8'));
-            } catch  {
-                return null;
-            }
-        }
-        function capitalizeToken(value) {
-            return value.split('-').filter(Boolean).map((token)=>token.charAt(0).toUpperCase() + token.slice(1)).join('-');
-        }
-        function getExtensionVersion() {
-            return process.env.EXTENSION_DEVELOP_VERSION || process.env.EXTENSION_CLI_VERSION || (()=>{
-                try {
-                    return __webpack_require__("./package.json").rE;
-                } catch  {
-                    return 'unknown';
-                }
-            })();
-        }
-        function browserRunnerDisabled(args) {
-            const manifest = readJsonRecord(args.manifestPath);
-            const ready = readJsonRecord(args.readyPath);
-            const browserLabel = capitalizeToken(String(args.browser || 'unknown'));
-            const runId = String(ready?.runId || '').trim();
-            const pid = Number.isInteger(ready?.pid) ? String(ready?.pid) : '';
-            const runLabel = runId ? `${pintor__rspack_import_1_default().gray(runId)}${pid ? ` · ${pintor__rspack_import_1_default().gray(`PID ${pid}`)}` : ''}` : pid ? pintor__rspack_import_1_default().gray(`PID ${pid}`) : pintor__rspack_import_1_default().gray('n/a');
-            const extensionName = String(manifest?.name || 'Extension');
-            const extensionVersion = String(manifest?.version || '').trim();
-            const extensionLabel = extensionVersion ? `${extensionName} ${extensionVersion}` : extensionName;
-            const extensionJsVersion = getExtensionVersion();
-            return [
-                ` 🧩 ${pintor__rspack_import_1_default().brightBlue('Extension.js')} ${pintor__rspack_import_1_default().gray(extensionJsVersion)}`,
-                `    Browser        ${pintor__rspack_import_1_default().gray(args.browserModeLabel || `${browserLabel} (build-only mode)`)}`,
-                `    Extension      ${pintor__rspack_import_1_default().gray(extensionLabel)}`,
-                `    Run ID         ${runLabel}`
-            ].join('\n');
-        }
-        function portInUse(requestedPort, newPort) {
-            return `Port: Requested port ${pintor__rspack_import_1_default().brightBlue(requestedPort.toString())} is in use; using ${pintor__rspack_import_1_default().brightBlue(newPort.toString())} instead.`;
-        }
-        function extensionJsRunnerError(error) {
-            return `Extension.js Runner Error:\n${pintor__rspack_import_1_default().red(String(error))}`;
-        }
-        function autoExitModeEnabled(ms) {
-            return `Auto-exit enabled. Will exit after ${pintor__rspack_import_1_default().brightBlue(ms.toString())} ms if idle.`;
-        }
-        function autoExitTriggered(ms) {
-            return `Auto-exit triggered after ${pintor__rspack_import_1_default().brightBlue(ms.toString())} ms. Cleaning up...`;
-        }
-        function autoExitForceKill(ms) {
-            return `Force-killing process after ${pintor__rspack_import_1_default().brightBlue(ms.toString())} ms to ensure exit.`;
-        }
-        function devServerStartTimeout(ms) {
-            return [
-                `Dev server startup is taking longer than expected (${pintor__rspack_import_1_default().brightBlue(ms.toString())} ms).`,
-                "The bundler may have encountered an error before emitting the first build.",
-                `If nothing else prints, try setting ${pintor__rspack_import_1_default().brightBlue('EXTENSION_VERBOSE=1')} for more logs.`
-            ].join('\n');
-        }
-        function bundlerFatalError(error) {
-            const text = error instanceof Error ? error.stack || error.message : String(error);
-            return `Build failed to start:\n${pintor__rspack_import_1_default().red(text)}`;
-        }
-        function bundlerRecompiling() {
-            return "Recompiling due to file changes…";
-        }
-        function noEntrypointsDetected(port) {
-            return [
-                "No entrypoints or assets were produced by the initial compilation.",
-                `The dev server is running on 127.0.0.1:${pintor__rspack_import_1_default().brightBlue(port.toString())}, but nothing is being built.`,
-                "Possible causes:",
-                "  • Empty or missing entry configuration.",
-                "  • Extension-related plugins are disabled (entries not derived from manifest).",
-                "  • All sources are ignored or excluded.",
-                `Try enabling verbose logs with ${pintor__rspack_import_1_default().brightBlue('EXTENSION_VERBOSE=1')} or review your extension config.`
-            ].join('\n');
-        }
-        function spacerLine() {
-            return ' ';
-        }
-    },
-    "./lib/config-loader.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            cR: ()=>loadCustomConfig,
-            eY: ()=>loadCommandConfig,
-            xY: ()=>loadBrowserConfig
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        var os__rspack_import_2 = __webpack_require__("os");
-        var vm__rspack_import_3 = __webpack_require__("vm");
-        var url__rspack_import_4 = __webpack_require__("url");
-        var module__rspack_import_5 = __webpack_require__("module");
-        var dotenv__rspack_import_6 = __webpack_require__("dotenv");
-        var dotenv__rspack_import_6_default = /*#__PURE__*/ __webpack_require__.n(dotenv__rspack_import_6);
-        var _messages__rspack_import_7 = __webpack_require__("./lib/messages.ts");
-        function loadCommonJsConfigWithStableDirname(absolutePath) {
-            const code = fs__rspack_import_0.readFileSync(absolutePath, 'utf-8');
-            const dirname = path__rspack_import_1.dirname(absolutePath);
-            const requireFn = (0, module__rspack_import_5.createRequire)(absolutePath);
-            const module = {
-                exports: {}
-            };
-            const exports1 = module.exports;
-            const wrapped = `(function (exports, require, module, __filename, __dirname) {\n${code}\n})`;
-            const fn = new vm__rspack_import_3.Script(wrapped, {
-                filename: absolutePath
-            }).runInThisContext();
-            fn(exports1, requireFn, module, absolutePath, dirname);
-            return module.exports?.default || module.exports;
-        }
-        function findNearestWorkspaceRoot(startDir) {
-            let current = path__rspack_import_1.resolve(startDir);
-            while(true){
-                if (fs__rspack_import_0.existsSync(path__rspack_import_1.join(current, 'pnpm-workspace.yaml'))) return current;
-                const parent = path__rspack_import_1.dirname(current);
-                if (parent === current) return;
-                current = parent;
-            }
-        }
-        function preloadEnvFilesFromDir(envDir, options) {
-            let loadedAny = false;
-            try {
-                const defaultsPath = path__rspack_import_1.join(envDir, '.env.defaults');
-                if (fs__rspack_import_0.existsSync(defaultsPath)) {
-                    dotenv__rspack_import_6_default().config({
-                        path: defaultsPath,
-                        override: Boolean(options?.override),
-                        quiet: true
-                    });
-                    loadedAny = true;
-                }
-                const envCandidates = [
-                    '.env.development',
-                    '.env.local',
-                    '.env'
-                ];
-                for (const filename of envCandidates){
-                    const filePath = path__rspack_import_1.join(envDir, filename);
-                    if (fs__rspack_import_0.existsSync(filePath)) {
-                        dotenv__rspack_import_6_default().config({
-                            path: filePath,
-                            override: Boolean(options?.override),
-                            quiet: true
-                        });
-                        loadedAny = true;
-                        break;
-                    }
-                }
-            } catch  {}
-            return {
-                loadedAny,
-                envDir
-            };
-        }
-        function findConfigFile(projectPath) {
-            const candidates = [
-                path__rspack_import_1.join(projectPath, 'extension.config.js'),
-                path__rspack_import_1.join(projectPath, 'extension.config.mjs'),
-                path__rspack_import_1.join(projectPath, 'extension.config.cjs')
-            ];
-            return candidates.find((p)=>fs__rspack_import_0.existsSync(p));
-        }
-        function preloadEnvFiles(projectDir) {
-            const local = preloadEnvFilesFromDir(projectDir);
-            if (local.loadedAny) return local;
-            const workspaceRoot = findNearestWorkspaceRoot(projectDir);
-            if (workspaceRoot && workspaceRoot !== projectDir) return preloadEnvFilesFromDir(workspaceRoot);
-            return local;
-        }
-        async function loadConfigFile(configPath) {
-            const absolutePath = path__rspack_import_1.resolve(configPath);
-            const projectDir = path__rspack_import_1.dirname(absolutePath);
-            preloadEnvFiles(projectDir);
-            try {
-                if (absolutePath.endsWith('.cjs')) {
-                    const requireFn = (0, module__rspack_import_5.createRequire)(__rslib_import_meta_url__);
-                    const required = requireFn(absolutePath);
-                    return required?.default || required;
-                }
-                let esmImportPath = absolutePath;
-                try {
-                    const originalContent = fs__rspack_import_0.readFileSync(absolutePath, 'utf-8');
-                    if (originalContent.includes('import.meta.env')) {
-                        const tmpDir = fs__rspack_import_0.mkdtempSync(path__rspack_import_1.join(os__rspack_import_2.tmpdir(), 'extension-config-esm-'));
-                        const tmpPath = path__rspack_import_1.join(tmpDir, path__rspack_import_1.basename(absolutePath));
-                        const envObjectLiteral = JSON.stringify(Object.fromEntries(Object.entries(process.env).map(([k, v])=>[
-                                k,
-                                v
-                            ])), null, 0);
-                        const shimHeader = `const __IMPORT_META_ENV__ = Object.freeze(${envObjectLiteral});\n`;
-                        const replaced = originalContent.replace(/import\.meta\.env/g, '__IMPORT_META_ENV__');
-                        fs__rspack_import_0.writeFileSync(tmpPath, `${shimHeader}${replaced}`, 'utf-8');
-                        esmImportPath = tmpPath;
-                    }
-                } catch  {}
-                const module = await import((0, url__rspack_import_4.pathToFileURL)(esmImportPath).href);
-                return module.default || module;
-            } catch (err) {
-                const error = err;
-                try {
-                    if (!absolutePath.endsWith('.mjs')) {
-                        const requireFn = (0, module__rspack_import_5.createRequire)(__rslib_import_meta_url__);
-                        let required;
-                        try {
-                            required = requireFn(absolutePath);
-                        } catch (requireErr) {
-                            const message = String(error?.message || '') + ' ' + String(requireErr?.message || '');
-                            const looksLikeCommonJsInEsm = message.includes('require is not defined in ES module scope') || message.includes('Cannot use import statement outside a module') || message.includes('ERR_REQUIRE_ESM');
-                            if (looksLikeCommonJsInEsm) try {
-                                required = loadCommonJsConfigWithStableDirname(absolutePath);
-                            } catch  {
-                                const tmpDir = fs__rspack_import_0.mkdtempSync(path__rspack_import_1.join(os__rspack_import_2.tmpdir(), 'extension-config-'));
-                                const tmpCjsPath = path__rspack_import_1.join(tmpDir, path__rspack_import_1.basename(absolutePath, path__rspack_import_1.extname(absolutePath)) + '.cjs');
-                                fs__rspack_import_0.copyFileSync(absolutePath, tmpCjsPath);
-                                required = requireFn(tmpCjsPath);
-                            }
-                            else throw requireErr;
-                        }
-                        return required?.default || required;
-                    }
-                } catch  {}
-                try {
-                    const content = fs__rspack_import_0.readFileSync(absolutePath, 'utf-8');
-                    return JSON.parse(content);
-                } catch (jsonErr) {
-                    throw new Error(`Failed to load config file: ${configPath}\nError: ${error.message || error}`);
-                }
-            }
-        }
-        async function loadCustomConfig(projectPath) {
-            const configPath = findConfigFile(projectPath);
-            if (configPath) {
-                if (await isUsingExperimentalConfig(projectPath)) try {
-                    const userConfig = await loadConfigFile(configPath);
-                    if (userConfig && 'function' == typeof userConfig.config) return userConfig.config;
-                    if (userConfig && userConfig.config && 'object' == typeof userConfig.config) {
-                        const partial = userConfig.config;
-                        return (config)=>{
-                            const requireFn = (0, module__rspack_import_5.createRequire)(__rslib_import_meta_url__);
-                            const { merge } = requireFn('webpack-merge');
-                            return merge(config, partial);
-                        };
-                    }
-                } catch (err) {
-                    const error = err;
-                    console.error(_messages__rspack_import_7.f7(configPath, error));
-                    throw err;
-                }
-            }
-            return (config)=>config;
-        }
-        async function loadCommandConfig(projectPath, command) {
-            const configPath = findConfigFile(projectPath);
-            if (configPath) {
-                if (await isUsingExperimentalConfig(projectPath)) try {
-                    const userConfig = await loadConfigFile(configPath);
-                    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) {
-                    const error = err;
-                    console.error(_messages__rspack_import_7.f7(configPath, error));
-                    throw err;
-                }
-            }
-            return {};
-        }
-        async function loadBrowserConfig(projectPath, browser = 'chrome') {
-            const configPath = findConfigFile(projectPath);
-            if (configPath) {
-                if (await isUsingExperimentalConfig(projectPath)) try {
-                    const userConfig = await loadConfigFile(configPath);
-                    if (userConfig && userConfig.browser) {
-                        const browsers = userConfig.browser;
-                        if ('chromium-based' === browser) {
-                            if (browsers['chromium-based']) return browsers['chromium-based'];
-                            if (browsers.chromium) return browsers.chromium;
-                        } else if ('gecko-based' === browser) {
-                            if (browsers['gecko-based']) return browsers['gecko-based'];
-                            if (browsers.firefox) return browsers.firefox;
-                        } else {
-                            const direct = browsers[browser];
-                            if (direct) return direct;
-                        }
-                    }
-                } catch (err) {
-                    const error = err;
-                    console.error(_messages__rspack_import_7.f7(configPath, error));
-                    throw err;
-                }
-            }
-            return {
-                browser: browser || 'chrome'
-            };
-        }
-        let userMessageDelivered = false;
-        async function isUsingExperimentalConfig(projectPath) {
-            const configPath = findConfigFile(projectPath);
-            if (configPath) {
-                if (!userMessageDelivered) {
-                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(_messages__rspack_import_7.BX('extension.config.js'));
-                    userMessageDelivered = true;
-                }
-                return true;
-            }
-            return false;
-        }
-    },
-    "./lib/develop-context.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            G5: ()=>resolveDevelopDistFile,
-            He: ()=>resolveDevelopInstallRoot,
-            w1: ()=>findExtensionDevelopRoot
-        });
-        var path__rspack_import_0 = __webpack_require__("path");
-        var fs__rspack_import_1 = __webpack_require__("fs");
-        var _package_json__rspack_import_2 = __webpack_require__("./package.json");
-        var _parse_json_safe__rspack_import_3 = __webpack_require__("./lib/parse-json-safe.ts");
-        if (!process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION) process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION = _package_json__rspack_import_2.rE;
-        function resolveDevelopRootFromDir(dir) {
-            try {
-                const packageJsonPath = path__rspack_import_0.join(dir, 'package.json');
-                if (!fs__rspack_import_1.existsSync(packageJsonPath)) return;
-                const pkg = (0, _parse_json_safe__rspack_import_3.p)(fs__rspack_import_1.readFileSync(packageJsonPath, 'utf8'));
-                if (pkg?.name === 'extension-develop') return dir;
-            } catch  {}
-        }
-        function findDevelopRootFrom(startDir) {
-            let currentDir = startDir;
-            const maxDepth = 6;
-            for(let i = 0; i < maxDepth; i++){
-                const root = resolveDevelopRootFromDir(currentDir);
-                if (root) return root;
-                const parent = path__rspack_import_0.dirname(currentDir);
-                if (parent === currentDir) break;
-                currentDir = parent;
-            }
-        }
-        function findExtensionDevelopRoot() {
-            const libDir = __dirname;
-            const buildDir = path__rspack_import_0.resolve(libDir, '..');
-            const packageRoot = path__rspack_import_0.resolve(buildDir, '..');
-            const packageJsonPath = path__rspack_import_0.join(packageRoot, 'package.json');
-            if (fs__rspack_import_1.existsSync(packageJsonPath)) try {
-                const pkg = JSON.parse(fs__rspack_import_1.readFileSync(packageJsonPath, 'utf-8'));
-                if ('extension-develop' === pkg.name) return packageRoot;
-            } catch  {}
-            return null;
-        }
-        function resolveDevelopInstallRoot() {
-            const envRoot = process.env.EXTENSION_DEVELOP_ROOT;
-            if (envRoot) {
-                const resolvedEnvRoot = resolveDevelopRootFromDir(path__rspack_import_0.resolve(envRoot));
-                if (resolvedEnvRoot) return resolvedEnvRoot;
-            }
-            const directRoot = findExtensionDevelopRoot();
-            if (directRoot) return directRoot;
-            try {
-                const candidateRoot = findDevelopRootFrom(__dirname);
-                if (candidateRoot) return candidateRoot;
-            } catch  {}
-            try {
-                const pkgPath = require.resolve('extension-develop/package.json', {
-                    paths: [
-                        __dirname
-                    ]
-                });
-                return resolveDevelopRootFromDir(path__rspack_import_0.dirname(pkgPath));
-            } catch  {
-                return;
-            }
-        }
-        function resolveDevelopDistFile(stem) {
-            const installRoot = resolveDevelopInstallRoot();
-            const distRoot = installRoot ? path__rspack_import_0.join(installRoot, 'dist') : path__rspack_import_0.resolve(__dirname, '..');
-            const base = path__rspack_import_0.join(distRoot, stem);
-            const candidates = [
-                `${base}.js`,
-                `${base}.cjs`,
-                `${base}.mjs`,
-                base
-            ];
-            for (const candidate of candidates)if (fs__rspack_import_1.existsSync(candidate)) {
-                if ('1' === process.env.EXTENSION_DEBUG_DEVELOP_ROOT) console.log(`[extjs:develop-root] ${stem} -> ${candidate} (installRoot=${installRoot || '<none>'})`);
-                return candidate;
-            }
-            if ('1' === process.env.EXTENSION_DEBUG_DEVELOP_ROOT) console.log(`[extjs:develop-root] ${stem} -> ${base} (fallback, installRoot=${installRoot || '<none>'})`);
-            return base;
-        }
-    },
-    "./lib/extensions-to-load.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            n: ()=>computeExtensionsToLoad
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        var _paths__rspack_import_2 = __webpack_require__("./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 resolveBuiltInExtensionForBrowser(input) {
-            const engine = (0, _paths__rspack_import_2.gP)(input.browser);
-            const packageRelativeCandidates = [
-                path__rspack_import_1.join('dist', input.packageName, engine)
-            ];
-            const normalizedBaseDir = path__rspack_import_1.normalize(input.baseDir);
-            const parentName = path__rspack_import_1.basename(path__rspack_import_1.dirname(normalizedBaseDir));
-            const baseName = path__rspack_import_1.basename(normalizedBaseDir);
-            if ('programs' === parentName && 'develop' === baseName) packageRelativeCandidates.push(path__rspack_import_1.join('..', '..', 'extensions', input.packageName, 'dist', engine));
-            for (const rel of packageRelativeCandidates){
-                const candidate = path__rspack_import_1.resolve(input.baseDir, rel);
-                if (fs__rspack_import_0.existsSync(candidate)) return candidate;
-            }
-        }
-        const RESERVED_BUILT_IN_NAMES = new Set([
-            'extension-js-devtools',
-            'extension-js-theme'
-        ]);
-        function isReservedBuiltInPath(extensionPath) {
-            const base = path__rspack_import_1.basename(path__rspack_import_1.normalize(extensionPath));
-            if (RESERVED_BUILT_IN_NAMES.has(base)) return true;
-            const segments = path__rspack_import_1.normalize(extensionPath).split(path__rspack_import_1.sep);
-            return segments.some((segment)=>RESERVED_BUILT_IN_NAMES.has(segment));
-        }
-        function dedupeByResolvedPath(paths) {
-            const seen = new Set();
-            const result = [];
-            for (const entry of paths){
-                const resolved = path__rspack_import_1.resolve(entry);
-                if (!seen.has(resolved)) {
-                    seen.add(resolved);
-                    result.push(entry);
-                }
-            }
-            return result;
-        }
-        function computeExtensionsToLoad(baseDir, mode, browser, userExtensionOutputPath, extraExtensionDirs = [], userManifestPath) {
-            const list = [];
-            try {
-                const devtoolsForBrowser = resolveBuiltInExtensionForBrowser({
-                    baseDir,
-                    packageName: 'extension-js-devtools',
-                    browser
-                });
-                const themeForBrowser = resolveBuiltInExtensionForBrowser({
-                    baseDir,
-                    packageName: 'extension-js-theme',
-                    browser
-                });
-                const userHasNewTabOverride = hasNewTabOverride(userExtensionOutputPath) || ('string' == typeof userManifestPath ? hasNewTabOverride(path__rspack_import_1.dirname(userManifestPath)) : false);
-                const devtoolsHasNewTabOverride = devtoolsForBrowser ? hasNewTabOverride(devtoolsForBrowser) : false;
-                const shouldSkipDevtoolsForNtpConflict = userHasNewTabOverride && devtoolsHasNewTabOverride;
-                if (devtoolsForBrowser && !shouldSkipDevtoolsForNtpConflict) list.push(devtoolsForBrowser);
-                if (themeForBrowser) list.push(themeForBrowser);
-            } catch  {}
-            for (const p of extraExtensionDirs)if (!isReservedBuiltInPath(p)) list.push(p);
-            list.push(userExtensionOutputPath);
-            return dedupeByResolvedPath(list);
-        }
-    },
-    "./lib/has-dependency.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            w: ()=>hasDependency
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        function hasDependency(projectPath, packageName) {
-            const manifestPath = path__rspack_import_1.join(projectPath, 'package.json');
-            if (!fs__rspack_import_0.existsSync(manifestPath)) return false;
-            try {
-                const raw = fs__rspack_import_0.readFileSync(manifestPath, 'utf8');
-                const pkg = JSON.parse(raw || '{}');
-                const sections = [
-                    pkg.dependencies,
-                    pkg.devDependencies,
-                    pkg.optionalDependencies,
-                    pkg.peerDependencies
-                ];
-                return sections.some((s)=>s && 'object' == typeof s && packageName in s);
-            } catch  {
-                return false;
-            }
-        }
-    },
-    "./lib/messages.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            $3: ()=>buildCommandFailed,
-            AC: ()=>debugOutputPath,
-            BT: ()=>treeWithSourceFiles,
-            BX: ()=>isUsingExperimentalConfig,
-            Cf: ()=>buildSuccess,
-            F$: ()=>downloadingProjectPath,
-            F_: ()=>packagingDistributionFiles,
-            GW: ()=>failedToDownloadOrExtractZIPFileError,
-            H3: ()=>managedDependencyConflict,
-            I: ()=>buildWebpack,
-            IV: ()=>packagingSourceFiles,
-            SG: ()=>debugDirs,
-            TL: ()=>authorInstallNotice,
-            Ud: ()=>downloadingText,
-            Ut: ()=>treeWithDistFilesbrowser,
-            V_: ()=>previewing,
-            W4: ()=>creatingProjectPath,
-            W6: ()=>treeWithSourceAndDistFiles,
-            _A: ()=>debugBrowser,
-            aw: ()=>debugContextPath,
-            ax: ()=>downloadedProjectFolderNotFound,
-            dx: ()=>manifestNotFoundError,
-            f7: ()=>configLoadingError,
-            fm: ()=>buildSuccessWithWarnings,
-            gC: ()=>unpackagingExtension,
-            jM: ()=>debugExtensionsToLoad,
-            jV: ()=>debugPreviewOutput,
-            k4: ()=>previewSkippedNoBrowser,
-            ng: ()=>writingTypeDefinitions,
-            tQ: ()=>fetchingProjectPath,
-            tc: ()=>invalidRemoteZip,
-            v_: ()=>writingTypeDefinitionsError,
-            wh: ()=>buildWarningsDetails,
-            yp: ()=>noCompanionExtensionsResolved,
-            zM: ()=>unpackagedSuccessfully
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        var pintor__rspack_import_2 = __webpack_require__("pintor");
-        var pintor__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_2);
-        __webpack_require__("./package.json");
-        const fmt = {
-            heading: (title)=>pintor__rspack_import_2_default().underline(pintor__rspack_import_2_default().blue(title)),
-            label: (key)=>pintor__rspack_import_2_default().gray(key.toUpperCase()),
-            val: (value)=>pintor__rspack_import_2_default().underline(value),
-            code: (value)=>pintor__rspack_import_2_default().blue(value),
-            bullet: (value)=>`- ${value}`,
-            block (title, rows) {
-                const head = fmt.heading(title);
-                const body = rows.map(([key, value])=>`${fmt.label(key)} ${value}`).join('\n');
-                return `${head}\n${body}`;
-            },
-            truncate (input, max = 800) {
-                const s = (()=>{
-                    try {
-                        return 'string' == typeof input ? input : JSON.stringify(input);
-                    } catch  {
-                        return String(input);
-                    }
-                })();
-                return s.length > max ? s.slice(0, max) + '…' : s;
-            }
-        };
-        function getLoggingPrefix(type) {
-            const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-            if (isAuthor) {
-                const base = 'error' === type ? 'ERROR Author says' : '⏵⏵⏵ Author says';
-                return pintor__rspack_import_2_default().brightMagenta(base);
-            }
-            if ('error' === type) return pintor__rspack_import_2_default().red('ERROR');
-            if ('warn' === type) return pintor__rspack_import_2_default().brightYellow('⏵⏵⏵');
-            if ('info' === type) return pintor__rspack_import_2_default().gray('⏵⏵⏵');
-            return pintor__rspack_import_2_default().green('⏵⏵⏵');
-        }
-        function isPathLike(input) {
-            return input.includes('/') || input.includes('\\') || path__rspack_import_1.isAbsolute(input);
-        }
-        function manifestNotFoundError(manifestPath) {
-            return `${getLoggingPrefix('error')} Manifest file not found.\n${pintor__rspack_import_2_default().red('Ensure the path to your extension exists and try again.')}\n${pintor__rspack_import_2_default().red('NOT FOUND')}\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(manifestPath)}`;
-        }
-        function previewing(browser) {
-            return `${getLoggingPrefix('info')} Previewing the extension on ${capitalizedBrowserName(browser)}...`;
-        }
-        function previewSkippedNoBrowser(browser) {
-            return `${getLoggingPrefix('info')} Skipping browser launch for ${capitalizedBrowserName(browser)} (no-browser).`;
-        }
-        function authorInstallNotice(target) {
-            return `${getLoggingPrefix('warn')} Author mode: installing ${target}.`;
-        }
-        function buildWebpack(projectDir, stats, browser) {
-            const statsJson = stats?.toJson({
-                all: false,
-                assets: true,
-                time: true
-            });
-            const outputPath = 'string' == typeof stats?.compilation?.outputOptions?.path ? stats.compilation.outputOptions.path : '';
-            const manifestPath = outputPath ? path__rspack_import_1.join(outputPath, 'manifest.json') : path__rspack_import_1.join(projectDir, 'manifest.json');
-            const manifest = JSON.parse(fs__rspack_import_0.readFileSync(manifestPath, 'utf8'));
-            const assets = statsJson?.assets;
-            const heading = `${getLoggingPrefix('info')} Building ${pintor__rspack_import_2_default().blue(manifest.name)} extension using ${capitalizedBrowserName(browser)} defaults...\n`;
-            const buildTime = `\nBuild completed in ${((statsJson?.time || 0) / 1000).toFixed(2)} seconds.\n`;
-            const buildTarget = `Build Target: ${pintor__rspack_import_2_default().gray(capitalizedBrowserName(browser))}\n`;
-            const buildStatus = `Build Status: ${stats?.hasErrors() ? pintor__rspack_import_2_default().red('Failed') : pintor__rspack_import_2_default().green('Success')}\n`;
-            const version = `\nVersion: ${pintor__rspack_import_2_default().gray(manifest.version)}\n`;
-            const size = `Size: ${pintor__rspack_import_2_default().gray(getAssetsSize(assets))}\n`;
-            let output = '';
-            output += heading;
-            output += getAssetsTree(assets);
-            output += version;
-            output += size;
-            output += buildTarget;
-            output += buildStatus;
-            output += buildTime;
-            return output;
-        }
-        function buildSuccess() {
-            return `${getLoggingPrefix('success')} Build succeeded with no warnings. Your extension is ${pintor__rspack_import_2_default().green('ready for deployment')}.`;
-        }
-        function getWarningMessage(warning) {
-            if (!warning) return '';
-            if ('string' == typeof warning) return warning.trim();
-            const candidates = [
-                warning.message,
-                warning.details,
-                warning.reason,
-                warning.description
-            ];
-            for (const candidate of candidates)if ('string' == typeof candidate && candidate.trim()) return candidate.trim();
-            return '';
-        }
-        function getWarningSource(warning) {
-            if (!warning || 'string' == typeof warning) return 'bundler';
-            const candidates = [
-                warning.name,
-                warning.moduleName,
-                warning.moduleIdentifier,
-                warning.originName,
-                warning.pluginName
-            ];
-            for (const candidate of candidates)if ('string' == typeof candidate && candidate.trim()) return candidate.trim();
-            return 'bundler';
-        }
-        function getWarningArtifact(warning) {
-            if (!warning || 'string' == typeof warning) return '';
-            const candidates = [
-                warning.file,
-                warning.chunkName,
-                warning.moduleName
-            ];
-            for (const candidate of candidates)if ('string' == typeof candidate && candidate.trim()) return candidate.trim();
-            return '';
-        }
-        function classifyWarning(message, source) {
-            const haystack = `${message} ${source}`.toLowerCase();
-            if (haystack.includes('performance') || haystack.includes('asset size') || haystack.includes('entrypoint size') || haystack.includes('exceeds the recommended size') || haystack.includes('hints')) return 'Performance';
-            if (haystack.includes('deprecat') || haystack.includes('[dep_') || haystack.includes('legacy')) return 'Deprecation';
-            if (haystack.includes('invalid') || haystack.includes('unknown option') || haystack.includes('configuration') || haystack.includes('schema')) return 'Configuration';
-            if (haystack.includes('manifest') || haystack.includes('browser') || haystack.includes('target')) return 'Compatibility';
-            if (haystack.includes('runtime') || haystack.includes('will fail') || haystack.includes('cannot resolve') || haystack.includes('service_worker')) return 'Runtime-risk';
-            return 'Warning';
-        }
-        function suggestedHintForWarning(category) {
-            if ('Performance' === category) return 'Inspect the largest startup bundles and split optional code paths.';
-            if ('Deprecation' === category) return 'Move to the supported API or plugin path before the next update.';
-            if ('Configuration' === category) return 'Review extension and bundler config keys, then remove or rename invalid options.';
-            if ('Compatibility' === category) return 'Verify browser target and manifest compatibility for this build.';
-            if ('Runtime-risk' === category) return 'Address this before release; it may fail or degrade at runtime.';
-            return 'Re-run with EXTENSION_VERBOSE=1 to inspect full warning details.';
-        }
-        function buildSuccessWithWarnings(warningCount) {
-            return `${getLoggingPrefix('warn')} Build succeeded with ${warningCount} warning(s). Your extension is ${pintor__rspack_import_2_default().green('ready for deployment')}.`;
-        }
-        function buildWarningsDetails(warnings) {
-            if (!Array.isArray(warnings) || 0 === warnings.length) return '';
-            const blocks = [];
-            warnings.forEach((warning, index)=>{
-                const message = getWarningMessage(warning);
-                const source = getWarningSource(warning);
-                const artifact = getWarningArtifact(warning);
-                const category = classifyWarning(message, source);
-                const hint = suggestedHintForWarning(category);
-                if (!message) return void blocks.push(`${getLoggingPrefix('warn')} Warning ${index + 1}: details were suppressed by tool output.\n${formatWarningLabelLine('Source', pintor__rspack_import_2_default().gray(source))}\n${formatWarningLabelLine('Hint', 'Re-run with EXTENSION_VERBOSE=1 to inspect full warning messages.')}`);
-                const performanceWarning = parsePerformanceWarning(warning, source, artifact);
-                if (performanceWarning) return void blocks.push(performanceWarning);
-                const oneLine = message.replace(/\s+/g, ' ').trim();
-                const artifactSuffix = artifact ? ` ${pintor__rspack_import_2_default().gray(`(${artifact})`)}` : '';
-                blocks.push(`${getLoggingPrefix('warn')} ${category}: ${oneLine}${artifactSuffix}\n${formatWarningLabelLine('Source', pintor__rspack_import_2_default().gray(source))}\n${formatWarningLabelLine('Hint', hint)}`);
-            });
-            return blocks.join('\n\n');
-        }
-        function fetchingProjectPath(owner, project) {
-            return fmt.block('Fetching project', [
-                [
-                    'URL',
-                    fmt.val(`https://github.com/${owner}/${project}`)
-                ]
-            ]);
-        }
-        function downloadingProjectPath(projectName) {
-            const formatted = isPathLike(projectName) ? pintor__rspack_import_2_default().underline(projectName) : pintor__rspack_import_2_default().yellow(projectName);
-            return `${getLoggingPrefix('info')} Downloading ${formatted}...`;
-        }
-        function creatingProjectPath(projectPath) {
-            return `${getLoggingPrefix('info')} Creating a new browser extension...\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(projectPath)}`;
-        }
-        function downloadedProjectFolderNotFound(cwd, candidates) {
-            return `${getLoggingPrefix('error')} Downloaded project folder not found.\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(cwd)}\n${pintor__rspack_import_2_default().gray('Tried')} ${pintor__rspack_import_2_default().underline(candidates.join(', '))}`;
-        }
-        function packagingSourceFiles(zipPath) {
-            return `${getLoggingPrefix('info')} Packaging source files. Files in ${pintor__rspack_import_2_default().yellow('.gitignore')} will be excluded...\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(zipPath)}.`;
-        }
-        function packagingDistributionFiles(zipPath) {
-            return `${getLoggingPrefix('info')} Packaging extension distribution files...\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(zipPath)}`;
-        }
-        function treeWithSourceAndDistFiles(browser, name, sourceZip, destZip) {
-            return `📦 Package name: ${pintor__rspack_import_2_default().blue(`${name}`)}, Target Browser: ${capitalizedBrowserName(browser)}\n   ${pintor__rspack_import_2_default().gray('└─')} ${pintor__rspack_import_2_default().underline(`${sourceZip}`)} ${pintor__rspack_import_2_default().gray('(source)')}\n   ${pintor__rspack_import_2_default().gray('└─')} ${pintor__rspack_import_2_default().underline(`${destZip}`)} ${pintor__rspack_import_2_default().gray('(distribution)')}`;
-        }
-        function treeWithDistFilesbrowser(name, ext, browser, zipPath) {
-            return `📦 Package name: ${pintor__rspack_import_2_default().blue(`${name}.${ext}`)}, Target Browser: ${capitalizedBrowserName(browser)}\n   ${pintor__rspack_import_2_default().gray('└─')} ${pintor__rspack_import_2_default().underline(`${zipPath}`)} ${pintor__rspack_import_2_default().gray('(distribution)')}`;
-        }
-        function treeWithSourceFiles(name, ext, browser, zipPath) {
-            return `📦 Package name: ${pintor__rspack_import_2_default().blue(`${name}-source.${ext}`)}, Target Browser: ${capitalizedBrowserName(browser)}\n   ${pintor__rspack_import_2_default().gray('└─')} ${pintor__rspack_import_2_default().underline(`${zipPath}`)} ${pintor__rspack_import_2_default().gray('(source)')}`;
-        }
-        function writingTypeDefinitions(manifest) {
-            return `${getLoggingPrefix('info')} Writing type definitions for ${pintor__rspack_import_2_default().blue(manifest.name || '')}...`;
-        }
-        function writingTypeDefinitionsError(error) {
-            return `${getLoggingPrefix('error')} Failed to write the extension type definition.\n${pintor__rspack_import_2_default().red(error)}`;
-        }
-        function downloadingText(url) {
-            return fmt.block('Downloading extension', [
-                [
-                    'URL',
-                    fmt.val(url)
-                ]
-            ]);
-        }
-        function unpackagingExtension(zipFilePath) {
-            return `${getLoggingPrefix('info')} Unpackaging browser extension...\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(zipFilePath)}`;
-        }
-        function unpackagedSuccessfully() {
-            return `${getLoggingPrefix('info')} Browser extension unpackaged ${pintor__rspack_import_2_default().green('successfully')}.`;
-        }
-        function failedToDownloadOrExtractZIPFileError(error) {
-            return `${getLoggingPrefix('error')} Failed to download or extract ZIP file.\n${pintor__rspack_import_2_default().red(error)}`;
-        }
-        function invalidRemoteZip(url, contentType) {
-            return `${getLoggingPrefix('error')} Remote URL does not appear to be a ZIP archive.\n${pintor__rspack_import_2_default().gray('URL')} ${pintor__rspack_import_2_default().underline(url)}\n${pintor__rspack_import_2_default().gray('Content-Type')} ${pintor__rspack_import_2_default().underline(contentType || 'unknown')}`;
-        }
-        function capitalizedBrowserName(browser) {
-            const b = String(browser || '');
-            const cap = b.charAt(0).toUpperCase() + b.slice(1);
-            return pintor__rspack_import_2_default().yellow(`${cap}`);
-        }
-        function getFileSize(fileSizeInBytes) {
-            return `${(fileSizeInBytes / 1024).toFixed(2)}KB`;
-        }
-        function getAssetsSize(assets) {
-            let totalSize = 0;
-            assets?.forEach((asset)=>{
-                totalSize += asset.size;
-            });
-            return getFileSize(totalSize);
-        }
-        function printTree(node, prefix = '') {
-            let output = '';
-            Object.keys(node).forEach((key, index, array)=>{
-                const isLast = index === array.length - 1;
-                const connector = isLast ? '└─' : '├─';
-                const sizeInKB = node[key].size ? ` (${getFileSize(node[key].size)})` : '';
-                output += `${pintor__rspack_import_2_default().gray(prefix)}${pintor__rspack_import_2_default().gray(connector)} ${key}${pintor__rspack_import_2_default().gray(sizeInKB)}\n`;
-                if ('object' == typeof node[key] && !node[key].size) output += printTree(node[key], `${prefix}${isLast ? '   ' : pintor__rspack_import_2_default().gray('│  ')}`);
-            });
-            return output;
-        }
-        function getAssetsTree(assets) {
-            const assetTree = {};
-            assets?.forEach((asset)=>{
-                const paths = asset.name.split('/');
-                let currentLevel = assetTree;
-                paths.forEach((part, index)=>{
-                    if (!currentLevel[part]) currentLevel[part] = {};
-                    if (index === paths.length - 1) currentLevel[part] = {
-                        size: asset.size
-                    };
-                    else currentLevel = currentLevel[part];
-                });
-            });
-            return `.\n${printTree(assetTree)}`;
-        }
-        function formatWarningLabelLine(label, value) {
-            return `${pintor__rspack_import_2_default().gray('│')}  ${pintor__rspack_import_2_default().gray(`${label}:`)} ${value}`;
-        }
-        function parsePerformanceWarning(warning, source, _artifact) {
-            const normalized = getWarningBody(warning).replace(/\r/g, '');
-            const lower = normalized.toLowerCase();
-            const threshold = normalized.match(/\(([\d.]+\s(?:KiB|MiB|GiB|KB|MB|GB))\)/)?.[1] || '';
-            if (lower.includes('asset size limit')) return formatPerformanceWarningBlock({
-                title: 'asset size limit exceeded',
-                threshold,
-                impact: 'Large emitted files can increase package size and slow extension startup.',
-                source,
-                hint: 'Inspect the largest startup bundles and split optional code paths.'
-            });
-            if (lower.includes('entrypoint size limit')) return formatPerformanceWarningBlock({
-                title: 'entrypoint size limit exceeded',
-                threshold,
-                impact: 'Startup entrypoints are heavier than recommended.',
-                source,
-                hint: 'Keep startup entrypoints thin and defer non-critical code.'
-            });
-        }
-        function formatPerformanceWarningBlock(options) {
-            const lines = [
-                `${getLoggingPrefix('warn')} Performance: ${options.title}`
-            ];
-            if (options.threshold) lines.push(formatWarningLabelLine('Threshold', options.threshold));
-            lines.push(formatWarningLabelLine('Impact', options.impact));
-            lines.push(pintor__rspack_import_2_default().gray('│'));
-            lines.push(formatWarningLabelLine('Source', pintor__rspack_import_2_default().gray(options.source)));
-            lines.push(formatWarningLabelLine('Hint', options.hint));
-            return lines.join('\n');
-        }
-        function getWarningBody(warning) {
-            if (!warning) return '';
-            if ('string' == typeof warning) return warning;
-            return [
-                warning.message,
-                warning.details,
-                warning.reason,
-                warning.description
-            ].filter((value)=>'string' == typeof value && value.trim().length > 0).join('\n');
-        }
-        function isUsingExperimentalConfig(integration) {
-            return `${getLoggingPrefix('info')} Using ${pintor__rspack_import_2_default().yellow(integration)}.`;
-        }
-        function debugDirs(manifestDir, packageJsonDir) {
-            return `${getLoggingPrefix('info')} Directories\n${pintor__rspack_import_2_default().gray('MANIFEST_DIR')} ${pintor__rspack_import_2_default().underline(manifestDir)}\n${pintor__rspack_import_2_default().gray('PACKAGE_JSON_DIR')} ${pintor__rspack_import_2_default().underline(packageJsonDir)}`;
-        }
-        function debugBrowser(browser, chromiumBinary, geckoBinary) {
-            return `${getLoggingPrefix('info')} Browser Target\n${pintor__rspack_import_2_default().gray('BROWSER')} ${pintor__rspack_import_2_default().yellow(String(browser))}\n${pintor__rspack_import_2_default().gray('CHROMIUM_BINARY')} ${pintor__rspack_import_2_default().underline(String(chromiumBinary || 'auto'))}\n${pintor__rspack_import_2_default().gray('GECKO_BINARY')} ${pintor__rspack_import_2_default().underline(String(geckoBinary || 'auto'))}`;
-        }
-        function debugOutputPath(pathValue) {
-            return `${getLoggingPrefix('info')} Output Path\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(pathValue)}`;
-        }
-        function debugPreviewOutput(outputPath, distPath) {
-            return `${getLoggingPrefix('info')} Preview Output\n${pintor__rspack_import_2_default().gray('OUTPUT')} ${pintor__rspack_import_2_default().underline(outputPath)}\n${pintor__rspack_import_2_default().gray('DIST')} ${pintor__rspack_import_2_default().underline(distPath)}`;
-        }
-        function debugContextPath(packageJsonDir) {
-            return `${getLoggingPrefix('info')} Context\n${pintor__rspack_import_2_default().gray('CONTEXT')} ${pintor__rspack_import_2_default().underline(packageJsonDir)}`;
-        }
-        function debugExtensionsToLoad(extensions) {
-            const header = `${getLoggingPrefix('info')} Extensions To Load (${extensions.length})`;
-            const list = extensions.map((e)=>`- ${pintor__rspack_import_2_default().underline(e)}`).join('\n');
-            return `${header}\n${list}`;
-        }
-        function noCompanionExtensionsResolved() {
-            return `${getLoggingPrefix('warn')} No companion extensions resolved from ${pintor__rspack_import_2_default().underline('extensions')} config.\n${pintor__rspack_import_2_default().gray('Ensure each companion extension is an unpacked extension directory containing a manifest.json (e.g., ./extensions/<name>/manifest.json).')}`;
-        }
-        function configLoadingError(configPath, error) {
-            return `${pintor__rspack_import_2_default().red('ERROR')} ${pintor__rspack_import_2_default().brightBlue('config load failed')}\n${fmt.label('PATH')} ${fmt.val(configPath)}\n` + pintor__rspack_import_2_default().red(fmt.truncate(error, 1200));
-        }
-        function buildCommandFailed(error) {
-            const message = (()=>{
-                if (error instanceof Error && error.message) return error.message;
-                return String(error || 'Unknown error');
-            })();
-            return `${getLoggingPrefix('error')} Build failed.\n${pintor__rspack_import_2_default().red(fmt.truncate(message, 1200))}`;
-        }
-        function managedDependencyConflict(duplicates, userPackageJsonPath) {
-            const list = duplicates.map((d)=>`- ${pintor__rspack_import_2_default().yellow(d)}`).join('\n');
-            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.`;
-        }
-    },
-    "./lib/optional-deps-resolver.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            Ci: ()=>ensureOptionalContractModuleLoaded,
-            k3: ()=>loadOptionalContractModuleWithoutInstall,
-            Eh: ()=>resolveOptionalContractPackageWithoutInstall,
-            nR: ()=>resolveOptionalDependencySync,
-            xr: ()=>ensureOptionalContractPackageResolved
-        });
-        var external_fs_ = __webpack_require__("fs");
-        var external_path_ = __webpack_require__("path");
-        var external_module_ = __webpack_require__("module");
-        var develop_context = __webpack_require__("./lib/develop-context.ts");
-        function installRootRules(packageIds) {
-            return packageIds.map((packageId)=>({
-                    type: 'install-root',
-                    packageId
-                }));
-        }
-        function defineContract(contract) {
-            return contract;
-        }
-        const OPTIONAL_DEPENDENCY_CONTRACTS = {
-            typescript: defineContract({
-                id: "typescript",
-                integration: 'TypeScript',
-                installPackages: [
-                    "typescript@5.9.3"
-                ],
-                verificationRules: installRootRules([
-                    "typescript"
-                ])
-            }),
-            'react-refresh': defineContract({
-                id: 'react-refresh',
-                integration: 'React',
-                installPackages: [
-                    'react-refresh@0.18.0',
-                    '@rspack/plugin-react-refresh@1.6.0'
-                ],
-                verificationRules: [
-                    ...installRootRules([
-                        'react-refresh',
-                        '@rspack/plugin-react-refresh'
-                    ]),
-                    {
-                        type: 'module-context-resolve',
-                        fromPackage: '@rspack/plugin-react-refresh',
-                        packageId: 'react-refresh'
-                    }
-                ]
-            }),
-            'preact-refresh': defineContract({
-                id: 'preact-refresh',
-                integration: 'Preact',
-                installPackages: [
-                    '@prefresh/core@1.5.9',
-                    '@prefresh/utils@1.2.1',
-                    '@rspack/plugin-preact-refresh@1.1.5',
-                    'preact@10.27.2'
-                ],
-                verificationRules: [
-                    ...installRootRules([
-                        '@prefresh/core',
-                        '@prefresh/utils',
-                        '@rspack/plugin-preact-refresh',
-                        'preact'
-                    ]),
-                    {
-                        type: 'module-context-resolve',
-                        fromPackage: '@rspack/plugin-preact-refresh',
-                        packageId: '@prefresh/core'
-                    },
-                    {
-                        type: 'module-context-resolve',
-                        fromPackage: '@rspack/plugin-preact-refresh',
-                        packageId: '@prefresh/utils'
-                    },
-                    {
-                        type: 'module-context-resolve',
-                        fromPackage: '@rspack/plugin-preact-refresh',
-                        packageId: 'preact'
-                    }
-                ]
-            }),
-            vue: defineContract({
-                id: 'vue',
-                integration: 'Vue',
-                installPackages: [
-                    'vue-loader@17.4.2',
-                    '@vue/compiler-sfc@3.5.26',
-                    'vue@3.5.26'
-                ],
-                verificationRules: [
-                    ...installRootRules([
-                        'vue-loader',
-                        '@vue/compiler-sfc',
-                        'vue'
-                    ]),
-                    {
-                        type: 'module-context-load',
-                        fromPackage: 'vue-loader',
-                        packageId: '@vue/compiler-sfc'
-                    }
-                ]
-            }),
-            svelte: defineContract({
-                id: 'svelte',
-                integration: 'Svelte',
-                installPackages: [
-                    "typescript@5.9.3",
-                    'svelte-loader@3.2.4'
-                ],
-                verificationRules: installRootRules([
-                    "typescript",
-                    'svelte-loader'
-                ])
-            }),
-            less: defineContract({
-                id: 'less',
-                integration: 'LESS',
-                installPackages: [
-                    'less@4.5.1',
-                    'less-loader@12.3.0'
-                ],
-                verificationRules: installRootRules([
-                    'less',
-                    'less-loader'
-                ])
-            }),
-            postcss: defineContract({
-                id: 'postcss',
-                integration: 'PostCSS',
-                installPackages: [
-                    'postcss@8.5.6',
-                    'postcss-loader@8.2.0'
-                ],
-                verificationRules: installRootRules([
-                    'postcss',
-                    'postcss-loader'
-                ])
-            }),
-            sass: defineContract({
-                id: 'sass',
-                integration: 'SASS',
-                installPackages: [
-                    'postcss-loader@8.2.0',
-                    'postcss-scss@4.0.9',
-                    'postcss-preset-env@11.1.1',
-                    'sass-loader@16.0.6'
-                ],
-                verificationRules: installRootRules([
-                    'postcss-loader',
-                    'postcss-scss',
-                    'postcss-preset-env',
-                    'sass-loader'
-                ])
-            })
-        };
-        function getOptionalDependencyContract(contractId) {
-            const contract = OPTIONAL_DEPENDENCY_CONTRACTS[contractId];
-            if (!contract) throw new Error(`Unknown optional dependency contract: ${contractId}`);
-            return contract;
-        }
-        function toInstallRootContract(integration, contractId, installDependencies, verifyPackageIds) {
-            return {
-                id: contractId,
-                integration,
-                installPackages: installDependencies,
-                verificationRules: verifyPackageIds.map((packageId)=>({
-                        type: 'install-root',
-                        packageId
-                    }))
-            };
-        }
-        function getVerificationContract(input) {
-            if (input.contract) return input.contract;
-            const installDependencies = input.installDependencies || [
-                input.dependencyId
-            ];
-            const verifyPackageIds = input.verifyPackageIds || installDependencies;
-            return toInstallRootContract(input.integration, input.integration, installDependencies, verifyPackageIds);
-        }
-        function getResolutionBases(projectPath) {
-            const extensionRoot = (0, develop_context.He)();
-            const bases = [
-                projectPath,
-                extensionRoot || void 0,
-                process.cwd()
-            ].filter(Boolean);
-            if (extensionRoot && extensionRoot.includes('.pnpm')) bases.push(external_path_.join(extensionRoot, '..', '..'));
-            return Array.from(new Set(bases));
-        }
-        function optional_deps_resolver_packageJsonPath(basePath) {
-            return external_path_.join(basePath, 'package.json');
-        }
-        function tryResolveWithBase(dependencyId, basePath) {
-            try {
-                const req = (0, external_module_.createRequire)(optional_deps_resolver_packageJsonPath(basePath));
-                return req.resolve(dependencyId);
-            } catch  {
-                return;
-            }
-        }
-        function resolveDependency(dependencyId, projectPath) {
-            const bases = getResolutionBases(projectPath);
-            for (const basePath of bases){
-                const resolvedPath = tryResolveWithBase(dependencyId, basePath);
-                if (resolvedPath) return {
-                    resolvedPath,
-                    basePath
-                };
-            }
-            try {
-                const resolvedPath = require.resolve(dependencyId, {
-                    paths: bases
-                });
-                return {
-                    resolvedPath,
-                    basePath: projectPath
-                };
-            } catch  {
-                return;
-            }
-        }
-        function resolveFromKnownLocations(dependencyId, projectPath) {
-            const direct = resolveDependency(dependencyId, projectPath)?.resolvedPath;
-            if (direct) return direct;
-            if (declaresDependency(projectPath, dependencyId)) return projectPath;
-        }
-        function declaresDependency(projectPath, dependencyId) {
-            try {
-                const packageJsonPath = external_path_.join(projectPath, 'package.json');
-                if (!external_fs_.existsSync(packageJsonPath)) return false;
-                const pkg = JSON.parse(external_fs_.readFileSync(packageJsonPath, 'utf8'));
-                const sections = [
-                    pkg.dependencies,
-                    pkg.devDependencies,
-                    pkg.optionalDependencies,
-                    pkg.peerDependencies
-                ];
-                return sections.some((section)=>section && 'object' == typeof section && dependencyId in section);
-            } catch  {
-                return false;
-            }
-        }
-        function dedupeFailures(packageIds) {
-            return Array.from(new Set(packageIds));
-        }
-        function resolveRealPathSafe(targetPath) {
-            try {
-                return external_fs_.realpathSync(targetPath);
-            } catch  {
-                return external_path_.resolve(targetPath);
-            }
-        }
-        function findOwningPackageDir(resolvedPath) {
-            let currentPath = external_path_.dirname(resolvedPath);
-            for(let depth = 0; depth < 8; depth++){
-                const packageJson = external_path_.join(currentPath, 'package.json');
-                if (external_fs_.existsSync(packageJson)) return currentPath;
-                const parent = external_path_.dirname(currentPath);
-                if (parent === currentPath) break;
-                currentPath = parent;
-            }
-        }
-        function isSameInstalledPackage(resolvedPath, expectedInstalledPath) {
-            const resolvedPackageDir = findOwningPackageDir(resolvedPath);
-            const expectedPackageDir = findOwningPackageDir(expectedInstalledPath);
-            if (resolvedPackageDir && expectedPackageDir) return resolveRealPathSafe(resolvedPackageDir) === resolveRealPathSafe(expectedPackageDir);
-            return resolveRealPathSafe(resolvedPath) === resolveRealPathSafe(expectedInstalledPath);
-        }
-        function evaluateModuleContextRule(rule, fromPackagePath, options) {
-            try {
-                const req = (0, external_module_.createRequire)(fromPackagePath);
-                const resolvedPeer = req.resolve(rule.packageId);
-                if (options?.expectedInstalledPath && !isSameInstalledPackage(resolvedPeer, options.expectedInstalledPath)) return rule.packageId;
-                if ('module-context-load' === rule.type) req(rule.packageId);
-                return;
-            } catch  {
-                return rule.packageId;
-            }
-        }
-        function getContractVerificationFailuresFromKnownLocations(contract, projectPath) {
-            const resolvedByPackage = new Map();
-            const resolvePackage = (packageId)=>{
-                if (!resolvedByPackage.has(packageId)) resolvedByPackage.set(packageId, resolveFromKnownLocations(packageId, projectPath));
-                return resolvedByPackage.get(packageId);
-            };
-            const failures = [];
-            for (const rule of contract.verificationRules){
-                if ('install-root' === rule.type) {
-                    if (!resolvePackage(rule.packageId)) failures.push(rule.packageId);
-                    continue;
-                }
-                const fromPackagePath = resolvePackage(rule.fromPackage);
-                if (!fromPackagePath) {
-                    failures.push(rule.fromPackage);
-                    continue;
-                }
-                const failure = evaluateModuleContextRule(rule, fromPackagePath);
-                if (!(failure && declaresDependency(projectPath, failure))) {
-                    if (failure) failures.push(failure);
-                }
-            }
-            return dedupeFailures(failures);
-        }
-        function buildDiagnostics(input) {
-            const bases = getResolutionBases(input.projectPath);
-            return {
-                contractId: input.contract?.id || null,
-                integration: input.integration,
-                dependencyId: input.dependencyId,
-                projectPath: input.projectPath,
-                installDependencies: input.installDependencies,
-                verifyPackageIds: input.verifyPackageIds,
-                resolutionBases: bases
-            };
-        }
-        function resolveOptionalDependencySync(dependencyId, projectPath) {
-            const resolved = resolveFromKnownLocations(dependencyId, projectPath);
-            if (resolved) return resolved;
-            const bases = getResolutionBases(projectPath);
-            throw new Error(`[CSS] ${dependencyId} could not be resolved. Searched: ${bases.join(', ')}`);
-        }
-        async function ensureOptionalPackageResolved(input) {
-            const contract = getVerificationContract(input);
-            const missing = getContractVerificationFailuresFromKnownLocations(contract, input.projectPath);
-            const resolved = resolveFromKnownLocations(input.dependencyId, input.projectPath);
-            if (resolved && 0 === missing.length) return resolved;
-            const diagnostics = buildDiagnostics({
-                integration: input.integration,
-                dependencyId: input.dependencyId,
-                projectPath: input.projectPath,
-                contract,
-                installDependencies: contract.installPackages,
-                verifyPackageIds: contract.installPackages
-            });
-            throw new Error(`[${input.integration}] ${input.dependencyId} could not be resolved.` + (missing.length > 0 ? ` Missing or invalid packages: ${missing.join(', ')}.` : '') + '\n' + JSON.stringify({
-                ...diagnostics,
-                missing
-            }, null, 2));
-        }
-        function resolveOptionalPackageWithoutInstall(input) {
-            const contract = getVerificationContract(input);
-            const resolved = resolveFromKnownLocations(input.dependencyId, input.projectPath);
-            const missingPeerDeps = getContractVerificationFailuresFromKnownLocations(contract, input.projectPath);
-            if (resolved && 0 === missingPeerDeps.length) return resolved;
-            const diagnostics = buildDiagnostics({
-                integration: input.integration,
-                dependencyId: input.dependencyId,
-                projectPath: input.projectPath,
-                contract,
-                installDependencies: contract.installPackages,
-                verifyPackageIds: contract.installPackages
-            });
-            throw new Error(`[${input.integration}] ${input.dependencyId} could not be resolved from the project or extension-develop.\n` + JSON.stringify({
-                ...diagnostics,
-                missingPeerDeps,
-                expectation: 'Run optional dependency preflight or reinstall extension-develop.'
-            }, null, 2));
-        }
-        async function ensureOptionalModuleLoaded(input) {
-            const resolvedPath = await ensureOptionalPackageResolved(input);
-            const candidateBases = getResolutionBases(input.projectPath);
-            let loaded;
-            let didLoad = false;
-            let lastLoadError;
-            for (const basePath of candidateBases){
-                const req = (0, external_module_.createRequire)(optional_deps_resolver_packageJsonPath(basePath));
-                const candidateModuleIds = [
-                    input.dependencyId,
-                    resolvedPath
-                ];
-                for (const candidateModuleId of candidateModuleIds)try {
-                    loaded = req(candidateModuleId);
-                    didLoad = true;
-                    break;
-                } catch (error) {
-                    lastLoadError = error;
-                }
-                if (didLoad) break;
-            }
-            if (!didLoad) try {
-                loaded = require(resolvedPath);
-                didLoad = true;
-            } catch (directRequireError) {
-                lastLoadError = directRequireError;
-            }
-            if (!didLoad) {
-                const diagnostics = {
-                    ...buildDiagnostics({
-                        integration: input.integration,
-                        dependencyId: input.dependencyId,
-                        projectPath: input.projectPath,
-                        installDependencies: input.installDependencies || [
-                            input.dependencyId
-                        ],
-                        verifyPackageIds: input.verifyPackageIds || input.installDependencies || [
-                            input.dependencyId
-                        ]
-                    }),
-                    resolvedPath,
-                    loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
-                };
-                throw new Error(`[${input.integration}] ${input.dependencyId} could not be loaded after it resolved.\n` + JSON.stringify(diagnostics, null, 2));
-            }
-            return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
-        }
-        function loadOptionalModuleWithoutInstall(input) {
-            const resolvedPath = resolveOptionalPackageWithoutInstall(input);
-            const candidateBases = getResolutionBases(input.projectPath);
-            let loaded;
-            let didLoad = false;
-            let lastLoadError;
-            for (const basePath of candidateBases){
-                const req = (0, external_module_.createRequire)(optional_deps_resolver_packageJsonPath(basePath));
-                const candidateModuleIds = [
-                    input.dependencyId,
-                    resolvedPath
-                ];
-                for (const candidateModuleId of candidateModuleIds)try {
-                    loaded = req(candidateModuleId);
-                    didLoad = true;
-                    break;
-                } catch (error) {
-                    lastLoadError = error;
-                }
-                if (didLoad) break;
-            }
-            if (!didLoad) try {
-                loaded = require(resolvedPath);
-                didLoad = true;
-            } catch (directRequireError) {
-                lastLoadError = directRequireError;
-            }
-            if (!didLoad) throw new Error(`[${input.integration}] ${input.dependencyId} could not be loaded after resolving.\n` + JSON.stringify({
-                resolvedPath,
-                loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
-            }, null, 2));
-            return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
-        }
-        async function ensureOptionalContractPackageResolved(input) {
-            const contract = getOptionalDependencyContract(input.contractId);
-            return ensureOptionalPackageResolved({
-                integration: contract.integration,
-                projectPath: input.projectPath,
-                dependencyId: input.dependencyId,
-                contract
-            });
-        }
-        async function ensureOptionalContractModuleLoaded(input) {
-            const contract = getOptionalDependencyContract(input.contractId);
-            return ensureOptionalModuleLoaded({
-                integration: contract.integration,
-                projectPath: input.projectPath,
-                dependencyId: input.dependencyId,
-                contract,
-                moduleAdapter: input.moduleAdapter
-            });
-        }
-        function resolveOptionalContractPackageWithoutInstall(input) {
-            const contract = getOptionalDependencyContract(input.contractId);
-            return resolveOptionalPackageWithoutInstall({
-                integration: contract.integration,
-                projectPath: input.projectPath,
-                dependencyId: input.dependencyId,
-                contract
-            });
-        }
-        function loadOptionalContractModuleWithoutInstall(input) {
-            const contract = getOptionalDependencyContract(input.contractId);
-            return loadOptionalModuleWithoutInstall({
-                integration: contract.integration,
-                projectPath: input.projectPath,
-                dependencyId: input.dependencyId,
-                contract,
-                moduleAdapter: input.moduleAdapter
-            });
-        }
-    },
-    "./lib/parse-json-safe.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            p: ()=>parseJsonSafe
-        });
-        function parseJsonSafe(text) {
-            const raw = 'string' == typeof text ? text : String(text || '');
-            const s = raw && 0xfeff === raw.charCodeAt(0) ? raw.slice(1) : raw;
-            return JSON.parse(s || '{}');
-        }
-    },
-    "./lib/paths.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            Bi: ()=>needsInstall,
-            G6: ()=>asAbsolute,
-            YN: ()=>normalizeBrowser,
-            fu: ()=>getDirs,
-            gP: ()=>devtoolsEngineFor,
-            q4: ()=>getDistPath,
-            u2: ()=>computePreviewOutputPath
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        function asAbsolute(p) {
-            return path__rspack_import_1.isAbsolute(p) ? p : path__rspack_import_1.resolve(p);
-        }
-        function getDirs(struct) {
-            const manifestDir = asAbsolute(path__rspack_import_1.dirname(struct.manifestPath));
-            const packageJsonDir = asAbsolute(struct.packageJsonPath ? path__rspack_import_1.dirname(struct.packageJsonPath) : manifestDir);
-            return {
-                manifestDir,
-                packageJsonDir
-            };
-        }
-        function getNodeModulesDir(packageJsonDir) {
-            return asAbsolute(path__rspack_import_1.join(packageJsonDir, 'node_modules'));
-        }
-        function needsInstall(packageJsonDir) {
-            const nm = getNodeModulesDir(packageJsonDir);
-            const packageJsonPath = path__rspack_import_1.join(packageJsonDir, 'package.json');
-            if (!fs__rspack_import_0.existsSync(packageJsonPath)) return false;
-            try {
-                const raw = fs__rspack_import_0.readFileSync(packageJsonPath, 'utf-8');
-                const packageJson = JSON.parse(raw);
-                const depsCount = Object.keys(packageJson?.dependencies || {}).length;
-                const devDepsCount = Object.keys(packageJson?.devDependencies || {}).length;
-                if (depsCount + devDepsCount === 0) return false;
-                if (!fs__rspack_import_0.existsSync(nm)) return true;
-                const deps = Object.keys(packageJson?.dependencies || {});
-                const devDeps = Object.keys(packageJson?.devDependencies || {});
-                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;
-                const hasInstalledDep = [
-                    ...deps,
-                    ...devDeps
-                ].some((dep)=>fs__rspack_import_0.existsSync(path__rspack_import_1.join(nm, dep)));
-                return !hasInstalledDep;
-            } catch  {
-                return true;
-            }
-        }
-        function normalizeBrowser(browser, chromiumBinary, geckoBinary) {
-            const requested = String(browser || '');
-            if (chromiumBinary) {
-                if (!requested || 'chromium-based' === requested) return 'chromium-based';
-                if ('chromium' === requested) return 'chromium';
-                if ('edge' === requested) return 'edge';
-                if ('chrome' === requested) return 'chrome';
-            }
-            if (geckoBinary) {
-                if (!requested || 'gecko-based' === requested || 'firefox-based' === requested) return 'gecko-based';
-                if ('firefox' === requested) return 'firefox';
-            }
-            switch(requested){
-                case 'chrome':
-                    return 'chrome';
-                case 'edge':
-                    return 'edge';
-                case 'chromium':
-                    return 'chromium';
-                case 'chromium-based':
-                    return 'chromium-based';
-                case 'firefox':
-                    return 'firefox';
-                case 'gecko-based':
-                case 'firefox-based':
-                    return 'gecko-based';
-                default:
-                    return browser || 'chrome';
-            }
-        }
-        function getDistPath(packageJsonDir, browser) {
-            return asAbsolute(path__rspack_import_1.join(packageJsonDir, 'dist', browser));
-        }
-        function computePreviewOutputPath(struct, browser, explicitOutputPath) {
-            const { manifestDir, packageJsonDir } = getDirs(struct);
-            if (explicitOutputPath) return asAbsolute(explicitOutputPath);
-            if (struct.packageJsonPath) {
-                const distDir = getDistPath(packageJsonDir, browser);
-                try {
-                    if (fs__rspack_import_0.existsSync(path__rspack_import_1.join(distDir, 'manifest.json'))) return distDir;
-                } catch  {}
-            }
-            return manifestDir;
-        }
-        function devtoolsEngineFor(browser) {
-            switch(browser){
-                case 'chrome':
-                    return 'chrome';
-                case 'edge':
-                    return 'edge';
-                case 'chromium':
-                case 'chromium-based':
-                    return 'chromium';
-                case 'firefox':
-                case 'gecko-based':
-                    return 'firefox';
-                default:
-                    return 'chrome';
-            }
-        }
-    },
-    "./lib/sanitize.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            a: ()=>sanitize
-        });
-        function sanitize(obj) {
-            return Object.fromEntries(Object.entries(obj || {}).filter(([, value])=>void 0 !== value));
-        }
-    },
-    "./module.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.r(__webpack_exports__);
-        __webpack_require__.d(__webpack_exports__, {
-            BuildEmitter: ()=>BuildEmitter,
-            extensionDev: ()=>extensionDev,
-            extensionPreview: ()=>extensionPreview,
-            extensionBuild: ()=>extensionBuild
-        });
-        var external_fs_ = __webpack_require__("fs");
-        function getBuildSummary(browser, info) {
-            const assets = info?.assets || [];
-            return {
-                browser,
-                total_assets: assets.length,
-                total_bytes: assets.reduce((n, a)=>n + (a.size || 0), 0),
-                largest_asset_bytes: assets.reduce((m, a)=>Math.max(m, a.size || 0), 0),
-                warnings_count: (info?.warnings || []).length,
-                errors_count: (info?.errors || []).length
-            };
-        }
-        var external_module_ = __webpack_require__("module");
-        var external_path_ = __webpack_require__("path");
-        var messages = __webpack_require__("./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;
-            }
-        }
-        const isUrl = (url)=>{
-            try {
-                new URL(url);
-                return true;
-            } catch (e) {
-                return false;
-            }
-        };
-        async function importUrlSourceFromGithub(pathOrRemoteUrl, text) {
-            const cwd = process.cwd();
-            const url = new URL(pathOrRemoteUrl);
-            const segments = url.pathname.split('/').filter(Boolean);
-            const repoName = segments.length >= 2 ? segments[1] : segments[segments.length - 1];
-            const treeIndex = segments.indexOf('tree');
-            const expectedName = -1 !== treeIndex && segments.length > treeIndex + 2 ? segments[segments.length - 1] : repoName;
-            const expectedPath = external_path_.resolve(cwd, expectedName);
-            if (external_fs_.existsSync(expectedPath)) try {
-                const entries = external_fs_.readdirSync(expectedPath);
-                if (0 === entries.length) external_fs_.rmSync(expectedPath, {
-                    recursive: true,
-                    force: true
-                });
-                else {
-                    const hasManifest = (dir)=>{
-                        const stack = [
-                            dir
-                        ];
-                        while(stack.length){
-                            const current = stack.pop();
-                            const items = external_fs_.readdirSync(current, {
-                                withFileTypes: true
-                            });
-                            for (const it of items){
-                                if (it.isFile() && 'manifest.json' === it.name) return true;
-                                if (it.isDirectory() && 'node_modules' !== it.name && 'dist' !== it.name && !it.name.startsWith('.')) stack.push(external_path_.join(current, it.name));
-                            }
-                        }
-                        return false;
-                    };
-                    if (hasManifest(expectedPath)) return expectedPath;
-                    external_fs_.rmSync(expectedPath, {
-                        recursive: true,
-                        force: true
-                    });
-                }
-            } catch  {}
-            async function tryGitClone() {
-                const { default: goGitIt } = await import("go-git-it");
-                await goGitIt(pathOrRemoteUrl, cwd, text);
-            }
-            async function tryZipFallback() {
-                const branch = -1 !== treeIndex && segments.length > treeIndex + 1 ? segments[treeIndex + 1] : 'main';
-                const owner = segments[0];
-                const repo = segments[1];
-                const subdir = -1 !== treeIndex && segments.length > treeIndex + 2 ? segments.slice(treeIndex + 2).join('/') : '';
-                const zipUrl = `https://codeload.github.com/${owner}/${repo}/zip/refs/heads/${branch}`;
-                const extractedPath = await importUrlSourceFromZip(zipUrl);
-                const extractedDirs = external_fs_.readdirSync(extractedPath, {
-                    withFileTypes: true
-                }).filter((d)=>d.isDirectory()).map((d)=>d.name);
-                const repoRootDir = extractedDirs.find((d)=>d.startsWith(`${repo}-${branch}`));
-                const repoRoot = repoRootDir ? external_path_.join(extractedPath, repoRootDir) : extractedPath;
-                return subdir ? external_path_.join(repoRoot, subdir) : repoRoot;
-            }
-            try {
-                await tryGitClone();
-            } catch  {
-                return await tryZipFallback();
-            }
-            const candidates = [];
-            if (-1 !== treeIndex && segments.length > treeIndex + 2) candidates.push(segments[segments.length - 1]);
-            candidates.push(repoName);
-            for (const name of candidates){
-                const p = external_path_.resolve(cwd, name);
-                if (external_fs_.existsSync(p)) return p;
-            }
-            const dirs = external_fs_.readdirSync(cwd, {
-                withFileTypes: true
-            }).filter((d)=>d.isDirectory()).map((d)=>d.name);
-            for (const dir of dirs){
-                const manifestPath = external_path_.join(cwd, dir, 'manifest.json');
-                if (external_fs_.existsSync(manifestPath)) return external_path_.join(cwd, dir);
-            }
-            try {
-                const dirs = external_fs_.readdirSync(cwd, {
-                    withFileTypes: true
-                }).filter((d)=>d.isDirectory()).map((d)=>d.name);
-                const ghRoot = dirs.find((d)=>/-main$|-master$/.test(d));
-                if (ghRoot) return external_path_.join(cwd, ghRoot);
-            } catch  {}
-            throw new Error(messages.ax(cwd, candidates));
-        }
-        async function importUrlSourceFromZip(pathOrRemoteUrl) {
-            const cwd = process.cwd();
-            const { downloadAndExtractZip } = await __webpack_require__.e(787).then(__webpack_require__.bind(__webpack_require__, "./lib/zip.ts"));
-            const extractedPath = await downloadAndExtractZip(pathOrRemoteUrl, cwd);
-            return extractedPath;
-        }
-        async function getProjectPath(pathOrRemoteUrl) {
-            if (!pathOrRemoteUrl) return process.cwd();
-            if (isUrl(pathOrRemoteUrl)) {
-                const url = new URL(pathOrRemoteUrl);
-                if (url.protocol.startsWith('http')) {
-                    const pathname = url.pathname.toLowerCase();
-                    if (pathname.endsWith('.zip')) return await importUrlSourceFromZip(pathOrRemoteUrl);
-                    if ('https://github.com' !== url.origin) {
-                        const urlSource = await importUrlSourceFromZip(pathOrRemoteUrl);
-                        return urlSource;
-                    }
-                    const urlData = url.pathname.split('/');
-                    const owner = urlData.slice(1, 3)[0];
-                    const project = urlData.slice(1, 3)[1];
-                    console.log(messages.tQ(owner, project));
-                    const projectName = external_path_.basename(url.pathname);
-                    const urlSource = await importUrlSourceFromGithub(pathOrRemoteUrl, messages.F$(projectName));
-                    console.log(messages.W4(url.pathname));
-                    return urlSource;
-                }
-            }
-            return external_path_.resolve(process.cwd(), pathOrRemoteUrl);
-        }
-        async function getProjectStructure(pathOrRemoteUrl) {
-            const projectPath = await getProjectPath(pathOrRemoteUrl);
-            const isUnderDir = (baseDir, candidatePath)=>{
-                const rel = external_path_.relative(baseDir, candidatePath);
-                return Boolean(rel && !rel.startsWith('..') && !external_path_.isAbsolute(rel));
-            };
-            const packageJsonPathFromProject = await findNearestPackageJson(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 && 'public' !== file.name) {
-                            const found = findManifest(external_path_.join(dir, file.name));
-                            if (found) return found;
-                        }
-                    }
-                    return null;
-                };
-                const foundManifest = findManifest(projectPath);
-                if (foundManifest) manifestPath = foundManifest;
-                else throw new Error(messages.dx(manifestPath));
-            }
-            const packageJsonPath = await findNearestPackageJson(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 || !validatePackageJson(packageJsonPath)) return {
-                manifestPath
-            };
-            return {
-                manifestPath,
-                packageJsonPath
-            };
-        }
-        var config_loader = __webpack_require__("./lib/config-loader.ts");
-        var package_0 = __webpack_require__("./package.json");
-        function assertNoManagedDependencyConflicts(userPackageJsonPath, projectPath) {
-            try {
-                const raw = external_fs_.readFileSync(userPackageJsonPath, 'utf-8');
-                const userPackageJson = JSON.parse(raw);
-                const userDeps = Array.from(new Set([
-                    ...Object.keys(userPackageJson.dependencies || {}),
-                    ...Object.keys(userPackageJson.devDependencies || {}),
-                    ...Object.keys(userPackageJson.optionalDependencies || {}),
-                    ...Object.keys(userPackageJson.peerDependencies || {})
-                ]));
-                const managedDeps = new Set([
-                    ...Object.keys(package_0.El || {}),
-                    ...Object.keys(package_0.optionalDependencies || {})
-                ]);
-                managedDeps.delete('webpack');
-                const userConfigJs = external_path_.join(projectPath, 'extension.config.js');
-                const userConfigMjs = external_path_.join(projectPath, 'extension.config.mjs');
-                const hasConfig = external_fs_.existsSync(userConfigJs) || external_fs_.existsSync(userConfigMjs);
-                if (!hasConfig) return;
-                const configPath = external_fs_.existsSync(userConfigJs) ? userConfigJs : userConfigMjs;
-                const configSource = external_fs_.readFileSync(configPath, 'utf-8');
-                const duplicates = userDeps.filter((d)=>managedDeps.has(d)).filter((d)=>configSource.includes(d)).sort();
-                if (duplicates.length > 0) {
-                    console.error(messages.H3(duplicates, userPackageJsonPath));
-                    process.exit(1);
-                }
-            } catch (error) {
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(error);
-            }
-        }
-        var paths = __webpack_require__("./lib/paths.ts");
-        var develop_context = __webpack_require__("./lib/develop-context.ts");
-        const external_child_process_namespaceObject = require("child_process");
-        const package_manager_require = (0, external_module_.createRequire)(__rslib_import_meta_url__);
-        function normalizePackageManager(value) {
-            if (!value) return;
-            const lower = value.toLowerCase().trim();
-            if ('pnpm' === lower) return 'pnpm';
-            if ('yarn' === lower) return 'yarn';
-            if ('bun' === lower) return 'bun';
-            if ('npm' === lower) return 'npm';
-        }
-        function inferPackageManagerFromPath(value) {
-            if (!value) return;
-            const lower = value.toLowerCase();
-            if (lower.includes('pnpm')) return 'pnpm';
-            if (lower.includes('yarn')) return 'yarn';
-            if (lower.includes('bun')) return 'bun';
-            if (lower.includes('npm')) return 'npm';
-        }
-        function getPackageManagerOverride() {
-            const name = normalizePackageManager(process.env.EXTENSION_JS_PACKAGE_MANAGER);
-            const execPath = process.env.EXTENSION_JS_PM_EXEC_PATH || process.env.npm_execpath || process.env.NPM_EXEC_PATH;
-            if (!name && !execPath) return;
-            const inferredName = name || inferPackageManagerFromPath(execPath) || 'npm';
-            return {
-                name: inferredName,
-                execPath
-            };
-        }
-        function detectPackageManagerFromEnv() {
-            const userAgent = process.env.npm_config_user_agent || '';
-            const execPath = process.env.npm_execpath || process.env.NPM_EXEC_PATH || '';
-            if (userAgent.includes('pnpm')) return {
-                name: 'pnpm',
-                execPath: execPath || void 0
-            };
-            if (userAgent.includes('yarn')) return {
-                name: 'yarn',
-                execPath: execPath || void 0
-            };
-            if (userAgent.includes('bun')) return {
-                name: 'bun',
-                execPath: execPath || void 0
-            };
-            if (userAgent.includes('npm')) return {
-                name: 'npm',
-                execPath: execPath || void 0
-            };
-            if (execPath) {
-                const inferred = inferPackageManagerFromPath(execPath) || 'npm';
-                return {
-                    name: inferred,
-                    execPath
-                };
-            }
-        }
-        function resolveNpmCliFromNode(execPath) {
-            const execDir = external_path_.dirname(execPath);
-            const candidates = [
-                external_path_.join(execDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-                external_path_.join(execDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-                external_path_.join(execDir, '..', 'node_modules', 'npm', 'bin', 'npm-cli.js')
-            ];
-            for (const candidate of candidates)if (external_fs_.existsSync(candidate)) return candidate;
-        }
-        function resolveBundledNpmCliPath() {
-            if (process.env.EXTENSION_JS_PM_EXEC_PATH) {
-                const overridePath = process.env.EXTENSION_JS_PM_EXEC_PATH;
-                if (overridePath && external_fs_.existsSync(overridePath)) return overridePath;
-            }
-            try {
-                const resolved = package_manager_require.resolve('npm/bin/npm-cli.js', {
-                    paths: [
-                        process.cwd(),
-                        __dirname
-                    ]
-                });
-                if (resolved && external_fs_.existsSync(resolved)) return resolved;
-            } catch  {}
-            return resolveNpmCliFromNode(process.execPath);
-        }
-        function isWindowsExecutablePath(value) {
-            if (!value || 'win32' !== process.platform) return false;
-            return /\.(cmd|bat|exe)$/i.test(value);
-        }
-        function isNodeScriptPath(value) {
-            if (!value) return false;
-            return /\.(mjs|cjs|js)$/i.test(value);
-        }
-        function resolveWindowsCommandPath(command) {
-            if ('win32' !== process.platform) return;
-            try {
-                const systemRoot = process.env.SystemRoot || 'C:\\Windows';
-                const whereExe = external_path_.join(systemRoot, 'System32', 'where.exe');
-                const whereCommand = external_fs_.existsSync(whereExe) ? whereExe : 'where';
-                const output = (0, external_child_process_namespaceObject.execFileSync)(whereCommand, [
-                    command
-                ], {
-                    encoding: 'utf8',
-                    stdio: [
-                        'ignore',
-                        'pipe',
-                        'ignore'
-                    ],
-                    windowsHide: true
-                });
-                const candidates = String(output).split(/\r?\n/).map((line)=>line.trim()).filter(Boolean);
-                const cmdMatch = candidates.find((line)=>/\.cmd$/i.test(line));
-                return cmdMatch || candidates[0];
-            } catch  {
-                return;
-            }
-        }
-        function resolveUnixCommandPath(command) {
-            if ('win32' === process.platform) return;
-            try {
-                const output = (0, external_child_process_namespaceObject.execFileSync)('which', [
-                    command
-                ], {
-                    encoding: 'utf8',
-                    stdio: [
-                        'ignore',
-                        'pipe',
-                        'ignore'
-                    ]
-                });
-                const candidate = String(output).trim();
-                return candidate || void 0;
-            } catch  {
-                return;
-            }
-        }
-        function resolveCommandOnPath(command) {
-            return resolveWindowsCommandPath(command) || resolveUnixCommandPath(command) || void 0;
-        }
-        function canRunCorepack() {
-            try {
-                const fallback = package_manager_require('child_process');
-                const spawnSync = external_child_process_namespaceObject.spawnSync?.mock !== void 0 ? external_child_process_namespaceObject.spawnSync : fallback.spawnSync || external_child_process_namespaceObject.spawnSync;
-                const result = spawnSync('corepack', [
-                    '--version'
-                ], {
-                    stdio: 'ignore',
-                    windowsHide: true
-                });
-                return result?.status === 0;
-            } catch  {
-                return false;
-            }
-        }
-        function detectByLockfile(cwd) {
-            if (!cwd) return;
-            const hasPnpmLock = external_fs_.existsSync(external_path_.join(cwd, 'pnpm-lock.yaml'));
-            const hasYarnLock = external_fs_.existsSync(external_path_.join(cwd, 'yarn.lock'));
-            const hasNpmLock = external_fs_.existsSync(external_path_.join(cwd, 'package-lock.json'));
-            if (hasPnpmLock) return 'pnpm';
-            if (hasYarnLock) return 'yarn';
-            if (hasNpmLock) return 'npm';
-        }
-        function hydrateResolvedPackageManager(name) {
-            const resolvedCommand = resolveCommandOnPath(name);
-            if (resolvedCommand) return {
-                name,
-                execPath: resolvedCommand
-            };
-            if ('npm' === name) {
-                const bundledNpmCli = resolveBundledNpmCliPath();
-                if (bundledNpmCli) return {
-                    name: 'npm',
-                    execPath: bundledNpmCli,
-                    runnerCommand: process.execPath,
-                    runnerArgs: [
-                        bundledNpmCli
-                    ]
-                };
-            }
-        }
-        function resolvePackageManager(opts) {
-            const lockPm = detectByLockfile(opts?.cwd);
-            if (lockPm) {
-                const hydrated = hydrateResolvedPackageManager(lockPm);
-                if (hydrated) return hydrated;
-                return {
-                    name: lockPm
-                };
-            }
-            const override = getPackageManagerOverride();
-            if (override) return override;
-            const envPm = detectPackageManagerFromEnv();
-            if (envPm) return envPm;
-            const candidates = [
-                'pnpm',
-                'yarn',
-                'bun'
-            ];
-            for (const candidate of candidates){
-                const resolved = resolveCommandOnPath(candidate);
-                if (resolved) return {
-                    name: candidate,
-                    execPath: resolved
-                };
-            }
-            const corepackPath = resolveCommandOnPath('corepack');
-            if (corepackPath || canRunCorepack()) return {
-                name: 'pnpm',
-                runnerCommand: corepackPath || 'corepack',
-                runnerArgs: [
-                    'pnpm'
-                ]
-            };
-            const bundledNpmCli = resolveBundledNpmCliPath();
-            if (bundledNpmCli) return {
-                name: 'npm',
-                execPath: bundledNpmCli,
-                runnerCommand: process.execPath,
-                runnerArgs: [
-                    bundledNpmCli
-                ]
-            };
-            return {
-                name: 'npm'
-            };
-        }
-        function buildExecEnv() {
-            if ('win32' !== process.platform) return;
-            const nodeDir = external_path_.dirname(process.execPath);
-            const pathSep = external_path_.delimiter;
-            const existing = process.env.PATH || process.env.Path || '';
-            if (existing.includes(nodeDir)) return;
-            return {
-                ...process.env,
-                PATH: `${nodeDir}${pathSep}${existing}`.trim(),
-                Path: `${nodeDir}${pathSep}${existing}`.trim()
-            };
-        }
-        function buildInstallCommand(pm, args) {
-            if (pm.runnerCommand) return {
-                command: pm.runnerCommand,
-                args: [
-                    ...pm.runnerArgs || [],
-                    ...args
-                ]
-            };
-            if (pm.execPath) {
-                if (isWindowsExecutablePath(pm.execPath)) return {
-                    command: pm.execPath,
-                    args
-                };
-                if (isNodeScriptPath(pm.execPath)) return {
-                    command: process.execPath,
-                    args: [
-                        pm.execPath,
-                        ...args
-                    ]
-                };
-                return {
-                    command: pm.execPath,
-                    args
-                };
-            }
-            return {
-                command: pm.name,
-                args
-            };
-        }
-        function buildSpawnInvocation(command, args) {
-            return {
-                command,
-                args
-            };
-        }
-        function execInstallCommand(command, args, options) {
-            const invocation = buildSpawnInvocation(command, args);
-            const env = buildExecEnv();
-            const stdio = options?.stdio ?? 'ignore';
-            const useShell = 'win32' === process.platform && /\.(cmd|bat)$/i.test(invocation.command);
-            return new Promise((resolve, reject)=>{
-                const child = (0, external_child_process_namespaceObject.spawn)(invocation.command, invocation.args, {
-                    cwd: options?.cwd,
-                    stdio,
-                    env: env || process.env,
-                    ...useShell ? {
-                        shell: true
-                    } : {}
-                });
-                child.on('close', (code)=>{
-                    if (0 !== code) reject(new Error(`Install failed with exit code ${code}`));
-                    else resolve();
-                });
-                child.on('error', (error)=>reject(error));
-            });
-        }
-        async function ensureUserProjectDependencies(packageJsonDir) {
-            if (!(0, paths.Bi)(packageJsonDir)) return;
-            const pm = resolvePackageManager({
-                cwd: packageJsonDir
-            });
-            const cmd = buildInstallCommand(pm, [
-                'install'
-            ]);
-            await execInstallCommand(cmd.command, cmd.args, {
-                cwd: packageJsonDir,
-                stdio: 'inherit'
-            });
-        }
-        async function ensureDevelopArtifacts() {
-            const developRoot = (0, develop_context.w1)();
-            if (!developRoot) return;
-            const requiredFiles = [
-                external_path_.join(developRoot, 'dist', "ensure-hmr-for-scripts.js"),
-                external_path_.join(developRoot, 'dist', "minimum-script-file.js")
-            ];
-            const missing = requiredFiles.filter((file)=>!external_fs_.existsSync(file));
-            if (0 === missing.length) return;
-            const pm = resolvePackageManager({
-                cwd: developRoot
-            });
-            const command = buildInstallCommand(pm, [
-                'run',
-                'compile'
-            ]);
-            const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-            const stdio = isAuthor ? 'inherit' : 'ignore';
-            if (isAuthor) console.warn(messages.TL('extension-develop build artifacts (dist missing)'));
-            await execInstallCommand(command.command, command.args, {
-                cwd: developRoot,
-                stdio
-            });
-        }
-        var resolve_config = __webpack_require__("./plugin-special-folders/folder-extensions/resolve-config.ts");
-        var get_data = __webpack_require__("./plugin-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);
-            const isVitest = 'true' === process.env.VITEST;
-            const shouldExitOnError = (buildOptions?.exitOnError ?? true) && !isVitest;
-            const browser = (0, paths.YN)(buildOptions?.browser || 'chrome', buildOptions?.chromiumBinary, buildOptions?.geckoBinary || buildOptions?.firefoxBinary);
-            const { manifestDir, packageJsonDir } = (0, paths.fu)(projectStructure);
-            const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-            try {
-                await ensureDevelopArtifacts();
-                if (buildOptions?.install !== false) await ensureUserProjectDependencies(packageJsonDir);
-                const [{ rspack }, { merge }, { handleStatsErrors }, { default: webpackConfig }] = await Promise.all([
-                    Promise.resolve(require1('@rspack/core')),
-                    import("webpack-merge"),
-                    __webpack_require__.e(504).then(__webpack_require__.bind(__webpack_require__, "./lib/stats-handler.ts")),
-                    __webpack_require__.e(442).then(__webpack_require__.bind(__webpack_require__, "./rspack-config.ts"))
-                ]);
-                const debug = isAuthor;
-                if (projectStructure.packageJsonPath) assertNoManagedDependencyConflicts(projectStructure.packageJsonPath, manifestDir);
-                const commandConfig = await (0, config_loader.eY)(packageJsonDir, 'build');
-                const specialFoldersData = (0, get_data.H)(packageJsonDir);
-                const distPath = (0, paths.q4)(packageJsonDir, browser);
-                try {
-                    external_fs_.rmSync(distPath, {
-                        recursive: true,
-                        force: true
-                    });
-                } catch  {}
-                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 resolvedMode = buildOptions?.mode === 'development' || buildOptions?.mode === 'none' || buildOptions?.mode === 'production' ? buildOptions.mode : 'production';
-                if ('development' === resolvedMode || 'production' === resolvedMode) process.env.NODE_ENV = resolvedMode;
-                const baseConfig = webpackConfig(projectStructure, {
-                    ...commandConfig,
-                    ...buildOptions,
-                    extensions: resolvedExtensionsConfig,
-                    browser,
-                    mode: resolvedMode,
-                    output: {
-                        clean: true,
-                        path: distPath
-                    }
-                });
-                const allPluginsButBrowserRunners = baseConfig.plugins?.filter((plugin)=>plugin?.constructor.name !== 'plugin-browsers');
-                const userExtensionConfig = await (0, config_loader.cR)(packageJsonDir);
-                const userConfig = userExtensionConfig({
-                    ...baseConfig,
-                    plugins: allPluginsButBrowserRunners
-                });
-                const compilerConfig = merge(userConfig);
-                compilerConfig.stats = false;
-                const compiler = rspack(compilerConfig);
-                let summary = {
-                    browser,
-                    total_assets: 0,
-                    total_bytes: 0,
-                    largest_asset_bytes: 0,
-                    warnings_count: 0,
-                    errors_count: 0
-                };
-                await new Promise((resolve, reject)=>{
-                    compiler.run(async (err, stats)=>{
-                        if (err) {
-                            console.error(err.stack || err);
-                            return reject(err);
-                        }
-                        if (!stats || 'function' != typeof stats.hasErrors) return reject(new Error('Build failed: bundler returned invalid stats output (no reliable compilation result).'));
-                        if (!buildOptions?.silent && stats) console.log(messages.I(manifestDir, stats, browser));
-                        if (stats.hasErrors()) {
-                            handleStatsErrors(stats);
-                            if (!shouldExitOnError) return reject(new Error('Build failed with errors'));
-                            process.exit(1);
-                        } else {
-                            const info = stats?.toJson({
-                                all: false,
-                                assets: true,
-                                warnings: true,
-                                errors: true
-                            });
-                            summary = getBuildSummary(browser, info);
-                            if (summary.warnings_count > 0) {
-                                console.log(messages.fm(summary.warnings_count));
-                                const warningDetails = messages.wh(info?.warnings || []);
-                                if (warningDetails) console.log(`\n${warningDetails}`);
-                            } else console.log(messages.Cf());
-                            resolve();
-                        }
-                    });
-                });
-                return summary;
-            } catch (error) {
-                const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-                if (isAuthor) console.error(error);
-                else console.error(messages.$3(error));
-                if (!shouldExitOnError) throw error;
-                process.exit(1);
-            }
-        }
-        const promises_namespaceObject = require("fs/promises");
-        async function generateExtensionTypes(manifestDir, packageJsonDir) {
-            const extensionEnvFile = external_path_.join(packageJsonDir, 'extension-env.d.ts');
-            const typePath = 'extension';
-            const fileContent = `\
-// Required Extension.js types for TypeScript projects.
-// This file is auto-generated and should not be excluded.
-// If you need additional types, consider creating a new *.d.ts file and
-// referencing it in the "include" array of your tsconfig.json file.
-// See https://www.typescriptlang.org/tsconfig#include for more information.
-/// <reference types="${typePath}/types" />
-
-// Polyfill types for browser.* APIs
-/// <reference types="${typePath}/types/polyfill" />
-`;
-            try {
-                await promises_namespaceObject.access(extensionEnvFile);
-                const existingContent = await promises_namespaceObject.readFile(extensionEnvFile, 'utf8');
-                if (existingContent.includes('develop/dist/types')) await promises_namespaceObject.writeFile(extensionEnvFile, fileContent);
-                await promises_namespaceObject.writeFile(extensionEnvFile, fileContent);
-            } catch (err) {
-                const manifest = require(external_path_.join(manifestDir, 'manifest.json'));
-                console.log(messages.ng(manifest));
-                try {
-                    await promises_namespaceObject.writeFile(extensionEnvFile, fileContent);
-                } catch (writeErr) {
-                    console.log(messages.v_(writeErr));
-                }
-            }
-        }
-        var sanitize = __webpack_require__("./lib/sanitize.ts");
-        const external_node_events_namespaceObject = require("node:events");
-        var contracts = __webpack_require__("./plugin-web-extension/feature-scripts/contracts.ts");
-        function _define_property(obj, key, value) {
-            if (key in obj) Object.defineProperty(obj, key, {
-                value: value,
-                enumerable: true,
-                configurable: true,
-                writable: true
-            });
-            else obj[key] = value;
-            return obj;
-        }
-        class BuildEmitter extends external_node_events_namespaceObject.EventEmitter {
-            constructor(){
-                super();
-                this.on('error', ()=>{});
-            }
-        }
-        class BrowsersPlugin {
-            apply(compiler) {
-                let pendingReloadReason;
-                let pendingChangedSources = [];
-                compiler.hooks.watchRun.tap(BrowsersPlugin.name, ()=>{
-                    pendingReloadReason = void 0;
-                    pendingChangedSources = [];
-                    const modifiedFiles = compiler.modifiedFiles;
-                    if (!modifiedFiles || 0 === modifiedFiles.size) return;
-                    const contextDir = compiler.options.context || '';
-                    for (const file of modifiedFiles){
-                        const normalized = external_path_.relative(contextDir, file).replace(/\\/g, '/');
-                        pendingChangedSources.push(normalized);
-                        if (normalized.includes('manifest.json')) pendingReloadReason = 'full';
-                        else if (normalized.includes('_locales/')) pendingReloadReason = 'full';
-                    }
-                });
-                compiler.hooks.done.tapPromise(BrowsersPlugin.name, async (stats)=>{
-                    const compilation = stats.compilation;
-                    const hasErrors = compilation.errors && compilation.errors.length > 0;
-                    if (hasErrors) return void this.emitter.emit('error', {
-                        errors: compilation.errors.map((e)=>'string' == typeof e ? e : e.message || String(e))
-                    });
-                    const outputPath = String(compilation.options?.output?.path || '');
-                    const contextDir = String(compilation.options?.context || '');
-                    let reloadInstruction;
-                    if (!this.isFirstCompile && pendingReloadReason) reloadInstruction = {
-                        type: pendingReloadReason,
-                        changedAssets: pendingChangedSources
-                    };
-                    else if (!this.isFirstCompile && pendingChangedSources.length > 0) {
-                        const isServiceWorkerSource = (rel)=>/(^|\/)background(\.|\/)/i.test(rel) || /service[-_.]?worker/i.test(rel);
-                        const hasServiceWorkerChange = pendingChangedSources.some(isServiceWorkerSource);
-                        if (hasServiceWorkerChange) reloadInstruction = {
-                            type: 'service-worker',
-                            changedAssets: pendingChangedSources
-                        };
-                        else {
-                            const contentScriptCount = readContentScriptCount(compilation, outputPath);
-                            if (contentScriptCount > 0) {
-                                const entries = [];
-                                for(let i = 0; i < contentScriptCount; i++)entries.push((0, contracts.Y0)(i));
-                                reloadInstruction = {
-                                    type: "content-scripts",
-                                    changedContentScriptEntries: entries,
-                                    changedAssets: pendingChangedSources
-                                };
-                            } else reloadInstruction = void 0;
-                        }
-                    }
-                    const wasFirstCompile = this.isFirstCompile;
-                    this.isFirstCompile = false;
-                    if (wasFirstCompile) try {
-                        this.controller = await this.options.launcher({
-                            ...this.options.browserOptions,
-                            outputPath,
-                            contextDir,
-                            extensionsToLoad: this.extensionsToLoad
-                        });
-                        const logLevel = this.options.browserOptions.logLevel || 'off';
-                        if ('off' !== logLevel && this.controller) await this.controller.enableUnifiedLogging({
-                            level: logLevel,
-                            contexts: this.options.browserOptions.logContexts,
-                            format: this.options.browserOptions.logFormat,
-                            timestamps: this.options.browserOptions.logTimestamps,
-                            color: this.options.browserOptions.logColor,
-                            urlFilter: this.options.browserOptions.logUrl,
-                            tabFilter: this.options.browserOptions.logTab
-                        });
-                    } catch (error) {
-                        this.emitter.emit('error', {
-                            errors: [
-                                error instanceof Error ? error.message : String(error)
-                            ]
-                        });
-                    }
-                    else if (this.controller && reloadInstruction) {
-                        if ('true' !== process.env.EXTENSION_NO_RELOAD) try {
-                            await this.controller.reload(reloadInstruction);
-                        } catch  {}
-                    }
-                    this.emitter.emit('compiled', {
-                        outputPath,
-                        contextDir,
-                        isFirstCompile: wasFirstCompile,
-                        reloadInstruction,
-                        extensionsToLoad: wasFirstCompile ? this.extensionsToLoad : void 0
-                    });
-                });
-            }
-            constructor(options){
-                _define_property(this, "options", void 0);
-                _define_property(this, "emitter", void 0);
-                _define_property(this, "extensionsToLoad", void 0);
-                _define_property(this, "isFirstCompile", void 0);
-                _define_property(this, "controller", void 0);
-                this.options = options;
-                this.emitter = new BuildEmitter();
-                this.extensionsToLoad = [];
-                this.isFirstCompile = true;
-            }
-        }
-        _define_property(BrowsersPlugin, "name", 'plugin-browsers');
-        function readContentScriptCount(compilation, outputPath) {
-            try {
-                const asset = compilation.getAsset?.('manifest.json');
-                if (asset?.source) {
-                    const manifest = JSON.parse(String(asset.source.source()));
-                    const list = manifest?.content_scripts;
-                    if (Array.isArray(list)) return list.length;
-                }
-            } catch  {}
-            try {
-                const fs = __webpack_require__("fs");
-                const manifestPath = external_path_.join(outputPath, 'manifest.json');
-                if (fs.existsSync(manifestPath)) {
-                    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-                    const list = manifest?.content_scripts;
-                    if (Array.isArray(list)) return list.length;
-                }
-            } catch  {}
-            return 0;
-        }
-        var typescript = __webpack_require__("./plugin-js-frameworks/js-tools/typescript.ts");
-        async function extensionDev(pathOrRemoteUrl, devOptions) {
-            let browsersPlugin;
-            let emitter = new BuildEmitter();
-            const projectStructure = await getProjectStructure(pathOrRemoteUrl);
-            try {
-                const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-                const debug = isAuthor;
-                const { manifestDir, packageJsonDir } = (0, paths.fu)(projectStructure);
-                await ensureDevelopArtifacts();
-                if (false !== devOptions.install) await ensureUserProjectDependencies(packageJsonDir);
-                if ((0, typescript.eE)(manifestDir)) await generateExtensionTypes(manifestDir, packageJsonDir);
-                if (projectStructure.packageJsonPath) assertNoManagedDependencyConflicts(projectStructure.packageJsonPath, manifestDir);
-                const browser = (0, paths.YN)(devOptions.browser || 'chrome', devOptions.chromiumBinary, devOptions.geckoBinary || devOptions.firefoxBinary);
-                const geckoBinary = devOptions.geckoBinary || devOptions.firefoxBinary;
-                if (debug) {
-                    console.log(messages.SG(manifestDir, packageJsonDir));
-                    console.log(messages._A(browser, devOptions.chromiumBinary, geckoBinary));
-                }
-                const browserConfig = await (0, config_loader.xY)(packageJsonDir, browser);
-                const commandConfig = await (0, config_loader.eY)(packageJsonDir, 'dev');
-                const merged = {
-                    ...(0, sanitize.a)(browserConfig),
-                    ...(0, sanitize.a)(commandConfig),
-                    ...(0, sanitize.a)(devOptions)
-                };
-                if (devOptions.launcher && !devOptions.noBrowser) {
-                    browsersPlugin = new BrowsersPlugin({
-                        launcher: devOptions.launcher,
-                        browserOptions: {
-                            browser,
-                            mode: 'development',
-                            enableDevtools: true,
-                            noOpen: merged.noOpen,
-                            profile: merged.profile,
-                            persistProfile: merged.persistProfile,
-                            preferences: merged.preferences,
-                            browserFlags: merged.browserFlags,
-                            excludeBrowserFlags: merged.excludeBrowserFlags,
-                            startingUrl: merged.startingUrl,
-                            chromiumBinary: merged.chromiumBinary,
-                            geckoBinary: merged.geckoBinary || merged.firefoxBinary,
-                            port: merged.port,
-                            source: merged.source,
-                            watchSource: merged.watchSource,
-                            sourceFormat: merged.sourceFormat,
-                            sourceSummary: merged.sourceSummary,
-                            sourceMeta: merged.sourceMeta,
-                            sourceProbe: merged.sourceProbe,
-                            sourceTree: merged.sourceTree,
-                            sourceConsole: merged.sourceConsole,
-                            sourceDom: merged.sourceDom,
-                            sourceMaxBytes: merged.sourceMaxBytes,
-                            sourceRedact: merged.sourceRedact,
-                            sourceIncludeShadow: merged.sourceIncludeShadow,
-                            sourceDiff: merged.sourceDiff,
-                            logLevel: merged.logLevel,
-                            logContexts: merged.logContexts,
-                            logFormat: merged.logFormat,
-                            logTimestamps: merged.logTimestamps,
-                            logColor: merged.logColor,
-                            logUrl: merged.logUrl,
-                            logTab: merged.logTab
-                        }
-                    });
-                    emitter = browsersPlugin.emitter;
-                }
-                if ('true' === process.env.EXTENSION_DEV_DRY_RUN) return emitter;
-                const { devServer } = await Promise.all([
-                    __webpack_require__.e(442),
-                    __webpack_require__.e(221)
-                ]).then(__webpack_require__.bind(__webpack_require__, "./dev-server/index.ts"));
-                await devServer(projectStructure, {
-                    ...devOptions,
-                    mode: 'development',
-                    browser,
-                    geckoBinary,
-                    browsersPlugin
-                });
-                return emitter;
-            } catch (error) {
-                console.error(error);
-                process.exit(1);
-            }
-        }
-        var plugin_playwright = __webpack_require__("./plugin-playwright/index.ts");
-        var utils = __webpack_require__("./plugin-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__("./lib/extensions-to-load.ts");
-        function getDarkModeDefaults(browser) {
-            if ('chrome' === browser || 'edge' === browser || 'chromium' === browser || 'chromium-based' === browser) return {
-                browserFlags: [
-                    '--force-dark-mode',
-                    '--enable-features=WebUIDarkMode'
-                ],
-                preferences: {}
-            };
-            if ('firefox' === browser || 'gecko-based' === browser || 'firefox-based' === browser) return {
-                browserFlags: [],
-                preferences: {
-                    'ui.systemUsesDarkTheme': 1,
-                    'layout.css.prefers-color-scheme.content-override': 2,
-                    'devtools.theme': 'dark'
-                }
-            };
-            return {
-                browserFlags: [],
-                preferences: {}
-            };
-        }
-        function withDarkMode(config) {
-            const defaults = getDarkModeDefaults(config.browser);
-            const existingFlags = Array.isArray(config.browserFlags) ? [
-                ...config.browserFlags
-            ] : [];
-            const nextFlags = [
-                ...existingFlags
-            ];
-            for (const flag of defaults.browserFlags || [])if (!nextFlags.some((f)=>String(f).trim() === flag)) nextFlags.push(flag);
-            const nextPreferences = {
-                ...config.preferences || {},
-                ...Object.fromEntries(Object.entries(defaults.preferences || {}).filter(([k])=>!(k in (config.preferences || {}))))
-            };
-            return {
-                ...config,
-                browserFlags: nextFlags,
-                preferences: nextPreferences
-            };
-        }
-        var dev_server_messages = __webpack_require__("./dev-server/messages.ts");
-        async function extensionPreview(pathOrRemoteUrl, previewOptions, browserLauncher) {
-            const projectStructure = await getProjectStructure(pathOrRemoteUrl);
-            const debug = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-            const { manifestDir, packageJsonDir } = (0, paths.fu)(projectStructure);
-            if (projectStructure.packageJsonPath) assertNoManagedDependencyConflicts(projectStructure.packageJsonPath, packageJsonDir);
-            const browser = (0, paths.YN)(previewOptions.browser || 'chrome', previewOptions.chromiumBinary, previewOptions.geckoBinary || previewOptions.firefoxBinary);
-            const outputPath = (0, paths.u2)(projectStructure, browser, previewOptions.outputPath);
-            const distPath = (0, paths.q4)(packageJsonDir, browser);
-            const metadataCommand = 'start' === previewOptions.metadataCommand ? 'start' : 'preview';
-            const metadata = (0, plugin_playwright.Ih)({
-                packageJsonDir,
-                browser: String(browser),
-                command: metadataCommand,
-                distPath,
-                manifestPath: projectStructure.manifestPath,
-                port: 'number' == typeof previewOptions.port ? previewOptions.port : 'string' == typeof previewOptions.port ? parseInt(previewOptions.port, 10) : null
-            });
-            metadata.writeStarting();
-            if (debug) {
-                console.log(messages.SG(manifestDir, packageJsonDir));
-                console.log(messages._A(browser, previewOptions.chromiumBinary, previewOptions.geckoBinary || previewOptions.firefoxBinary));
-                console.log(messages.jV(outputPath, distPath));
-            }
-            const manifestAtOutput = external_path_.join(outputPath, 'manifest.json');
-            if (!external_fs_.existsSync(manifestAtOutput)) {
-                metadata.writeError('preview_manifest_missing', `Expected manifest at ${manifestAtOutput}`);
-                throw new Error(`Preview is run-only and does not compile.\nExpected an unpacked extension at:\n  ${manifestAtOutput}\n\nRun \`extension build\` or \`extension dev\` first, or pass --output-path to an existing unpacked extension directory.`);
-            }
-            const commandConfig = await (0, config_loader.eY)(packageJsonDir, metadataCommand);
-            const browserConfig = await (0, config_loader.xY)(packageJsonDir, browser);
-            console.log(messages.V_(browser));
-            if (previewOptions.noBrowser) {
-                console.log(messages.k4(browser));
-                metadata.writeReady();
-                console.log(dev_server_messages.tl());
-                const browserLabel = String(browser || 'unknown');
-                console.log(dev_server_messages.bL({
-                    browser: browserLabel,
-                    manifestPath: projectStructure.manifestPath,
-                    readyPath: metadata.readyPath,
-                    browserModeLabel: `${browserLabel.charAt(0).toUpperCase() + browserLabel.slice(1)} (no-browser mode)`
-                }));
-                return;
-            }
-            const safeBrowserConfig = (0, sanitize.a)(browserConfig);
-            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
-            };
-            const darkDefaults = withDarkMode({
-                browser,
-                browserFlags: merged.browserFlags,
-                preferences: merged.preferences
-            });
-            const companionUnpackedExtensionDirs = resolveCompanionExtensionDirs({
-                projectRoot: packageJsonDir,
-                config: merged.extensions
-            });
-            const unpackedExtensionDirsToLoad = (0, extensions_to_load.n)(external_path_.resolve(__dirname, '..'), 'production', browser, outputPath, companionUnpackedExtensionDirs, projectStructure.manifestPath);
-            const resolvedOpts = {
-                browser,
-                outPath: outputPath,
-                contextDir: packageJsonDir,
-                readyPath: metadata.readyPath,
-                extensionsToLoad: unpackedExtensionDirsToLoad,
-                noOpen: merged.noOpen,
-                profile: merged.profile,
-                persistProfile: merged.persistProfile,
-                preferences: darkDefaults.preferences,
-                browserFlags: darkDefaults.browserFlags,
-                excludeBrowserFlags: merged.excludeBrowserFlags,
-                startingUrl: merged.startingUrl,
-                chromiumBinary: merged.chromiumBinary,
-                geckoBinary: merged.geckoBinary,
-                instanceId: merged.instanceId,
-                port: merged.port,
-                dryRun: merged.dryRun
-            };
-            if (!browserLauncher) throw new Error("extensionPreview requires a browserLauncher callback. The browser launch code has moved to programs/extension/browsers/.");
-            await browserLauncher(resolvedOpts);
-            metadata.writeReady();
-        }
-    },
-    "./plugin-js-frameworks/frameworks-lib/integrations.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            qQ: ()=>isUsingJSFramework,
-            ws: ()=>_lib_has_dependency__rspack_import_0.w
-        });
-        var _lib_has_dependency__rspack_import_0 = __webpack_require__("./lib/has-dependency.ts");
-        __webpack_require__("./lib/develop-context.ts");
-        function isUsingJSFramework(projectPath) {
-            const frameworks = [
-                'react',
-                'vue',
-                '@angular/core',
-                'svelte',
-                'solid-js',
-                'preact'
-            ];
-            return frameworks.some((fw)=>(0, _lib_has_dependency__rspack_import_0.w)(projectPath, fw));
-        }
-    },
-    "./plugin-js-frameworks/js-frameworks-lib/messages.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            Ei: ()=>jsFrameworksHmrSummary,
-            LR: ()=>creatingTSConfig,
-            MH: ()=>jsFrameworksConfigsDetected,
-            Ty: ()=>isUsingCustomLoader,
-            jH: ()=>jsFrameworksIntegrationsEnabled,
-            zA: ()=>isUsingIntegration
-        });
-        var pintor__rspack_import_0 = __webpack_require__("pintor");
-        var pintor__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_0);
-        function isUsingIntegration(name) {
-            return `${pintor__rspack_import_0_default().gray('⏵⏵⏵')} Using ${pintor__rspack_import_0_default().brightBlue(name)}...`;
-        }
-        function creatingTSConfig() {
-            return `${pintor__rspack_import_0_default().gray('⏵⏵⏵')} Creating default tsconfig.json...`;
-        }
-        function isUsingCustomLoader(loaderPath) {
-            return `${pintor__rspack_import_0_default().gray('⏵⏵⏵')} Using custom loader: ${pintor__rspack_import_0_default().yellow(loaderPath)}.`;
-        }
-        function jsFrameworksIntegrationsEnabled(integrations) {
-            const list = integrations.length > 0 ? integrations.map((n)=>pintor__rspack_import_0_default().yellow(n)).join(', ') : pintor__rspack_import_0_default().gray('none');
-            return `${pintor__rspack_import_0_default().gray('⏵⏵⏵')} JS: Integrations enabled (${pintor__rspack_import_0_default().gray(String(integrations.length))}) ${list}`;
-        }
-        function jsFrameworksConfigsDetected(tsConfigPath, tsRoot, targets) {
-            const fmt = (v)=>v ? pintor__rspack_import_0_default().underline(v) : pintor__rspack_import_0_default().gray('none');
-            const tgt = targets && targets.length ? targets.map((t)=>pintor__rspack_import_0_default().gray(t)).join(', ') : pintor__rspack_import_0_default().gray('default');
-            return `${pintor__rspack_import_0_default().gray('⏵⏵⏵')} JS: Configs\n${pintor__rspack_import_0_default().gray('TSCONFIG')} ${fmt(tsConfigPath)}\n${pintor__rspack_import_0_default().gray('TSROOT')} ${fmt(tsRoot)}\n${pintor__rspack_import_0_default().gray('SWC_TARGETS')} ${tgt}`;
-        }
-        function jsFrameworksHmrSummary(enabled, frameworks) {
-            const list = frameworks.length > 0 ? frameworks.map((n)=>pintor__rspack_import_0_default().yellow(n)).join(', ') : pintor__rspack_import_0_default().gray('none');
-            return `${pintor__rspack_import_0_default().gray('⏵⏵⏵')} JS: HMR ${enabled ? pintor__rspack_import_0_default().green('enabled') : pintor__rspack_import_0_default().gray('disabled')} for ${list}`;
-        }
-    },
-    "./plugin-js-frameworks/js-tools/typescript.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            eE: ()=>isUsingTypeScript,
-            hB: ()=>getUserTypeScriptConfigFile
-        });
-        var path__rspack_import_0 = __webpack_require__("path");
-        var fs__rspack_import_1 = __webpack_require__("fs");
-        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__("./plugin-js-frameworks/js-frameworks-lib/messages.ts");
-        var _frameworks_lib_integrations__rspack_import_4 = __webpack_require__("./plugin-js-frameworks/frameworks-lib/integrations.ts");
-        __webpack_require__("./lib/optional-deps-resolver.ts");
-        var _lib_parse_json_safe__rspack_import_6 = __webpack_require__("./lib/parse-json-safe.ts");
-        let hasShownUserMessage = false;
-        function findNearestPackageJsonDirectory(startPath) {
-            let currentDirectory = startPath;
-            const maxDepth = 6;
-            for(let i = 0; i < maxDepth; i++){
-                const candidate = path__rspack_import_0.join(currentDirectory, 'package.json');
-                if (fs__rspack_import_1.existsSync(candidate)) return currentDirectory;
-                const parentDirectory = path__rspack_import_0.dirname(currentDirectory);
-                if (parentDirectory === currentDirectory) break;
-                currentDirectory = parentDirectory;
-            }
-        }
-        function hasTypeScriptSourceFiles(projectPath) {
-            try {
-                const entries = fs__rspack_import_1.readdirSync(projectPath, {
-                    withFileTypes: true
-                });
-                return entries.some((entry)=>{
-                    if (entry.isFile()) {
-                        const name = entry.name;
-                        if (!/\.(ts|tsx|mts|mtsx)$/i.test(name)) return false;
-                        if (/\.(d\.ts|d\.mts|d\.mtsx)$/i.test(name)) return false;
-                        if (/\.(spec|test)\.(ts|tsx|mts|mtsx)$/i.test(name)) return false;
-                        return true;
-                    }
-                    if (entry.isDirectory()) {
-                        if (![
-                            'src',
-                            'content',
-                            'sidebar',
-                            'background'
-                        ].includes(entry.name)) return false;
-                        const sub = path__rspack_import_0.join(projectPath, entry.name);
-                        return hasTypeScriptSourceFiles(sub);
-                    }
-                    return false;
-                });
-            } catch  {
-                return false;
-            }
-        }
-        function isUsingTypeScript(projectPath) {
-            const packageJsonDirectory = findNearestPackageJsonDirectory(projectPath);
-            const tsConfigFilePath = getUserTypeScriptConfigFile(projectPath);
-            const packageJson = packageJsonDirectory ? (0, _lib_parse_json_safe__rspack_import_6.p)(fs__rspack_import_1.readFileSync(path__rspack_import_0.join(packageJsonDirectory, 'package.json'), 'utf8')) : void 0;
-            const TypeScriptAsDevDep = packageJson?.devDependencies?.typescript;
-            const TypeScriptAsDep = packageJson?.dependencies?.typescript;
-            const hasTsFiles = hasTypeScriptSourceFiles(projectPath);
-            if (!hasShownUserMessage) {
-                if (TypeScriptAsDevDep || TypeScriptAsDep || hasTsFiles) if (tsConfigFilePath) {
-                    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('TypeScript')}`);
-                } else if (hasTsFiles) {
-                    const errorMessage = '[Extension.js] Missing tsconfig.json next to package.json. Create one to use TypeScript.';
-                    throw new Error(errorMessage);
-                } else {
-                    console.log(_js_frameworks_lib_messages__rspack_import_3.LR());
-                    writeTsConfig(projectPath);
-                }
-                hasShownUserMessage = true;
-            }
-            return !!tsConfigFilePath && !!(TypeScriptAsDevDep || TypeScriptAsDep || hasTsFiles);
-        }
-        function defaultTypeScriptConfig(projectPath, _opts) {
-            return {
-                compilerOptions: {
-                    allowJs: true,
-                    allowSyntheticDefaultImports: true,
-                    esModuleInterop: true,
-                    forceConsistentCasingInFileNames: true,
-                    jsx: (0, _frameworks_lib_integrations__rspack_import_4.qQ)(projectPath) ? 'react-jsx' : 'preserve',
-                    lib: [
-                        'dom',
-                        'dom.iterable',
-                        'esnext'
-                    ],
-                    moduleResolution: 'node',
-                    module: 'esnext',
-                    resolveJsonModule: true,
-                    strict: true,
-                    target: 'esnext',
-                    isolatedModules: false,
-                    skipLibCheck: true
-                },
-                exclude: [
-                    'node_modules',
-                    'dist'
-                ]
-            };
-        }
-        function getUserTypeScriptConfigFile(projectPath) {
-            const pkgDir = findNearestPackageJsonDirectory(projectPath);
-            if (pkgDir) {
-                const tsconfigPath = path__rspack_import_0.join(pkgDir, 'tsconfig.json');
-                if (fs__rspack_import_1.existsSync(tsconfigPath)) return tsconfigPath;
-            }
-        }
-        function writeTsConfig(projectPath) {
-            fs__rspack_import_1.writeFileSync(path__rspack_import_0.join(projectPath, 'tsconfig.json'), JSON.stringify(defaultTypeScriptConfig(projectPath, {
-                mode: 'development'
-            }), null, 2));
-        }
-    },
-    "./plugin-playwright/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            Ih: ()=>createPlaywrightMetadataWriter,
-            Tb: ()=>PlaywrightPlugin
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        var _lib_paths__rspack_import_2 = __webpack_require__("./lib/paths.ts");
-        function _define_property(obj, key, value) {
-            if (key in obj) Object.defineProperty(obj, key, {
-                value: value,
-                enumerable: true,
-                configurable: true,
-                writable: true
-            });
-            else obj[key] = value;
-            return obj;
-        }
-        function nowISO() {
-            return new Date().toISOString();
-        }
-        function createRunId() {
-            return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-        }
-        function ensureDirSync(dirPath) {
-            try {
-                fs__rspack_import_0.mkdirSync(dirPath, {
-                    recursive: true
-                });
-            } catch  {}
-        }
-        function writeJsonAtomic(filePath, value) {
-            try {
-                const tmpPath = `${filePath}.tmp-${process.pid}`;
-                fs__rspack_import_0.writeFileSync(tmpPath, JSON.stringify(value, null, 2) + '\n', 'utf-8');
-                fs__rspack_import_0.renameSync(tmpPath, filePath);
-            } catch  {}
-        }
-        function getPlaywrightMetadataDir(packageJsonDir, browser) {
-            return (0, _lib_paths__rspack_import_2.G6)(path__rspack_import_1.join(packageJsonDir, 'dist', 'extension-js', browser));
-        }
-        function createPlaywrightMetadataWriter(options) {
-            const metadataDir = getPlaywrightMetadataDir(options.packageJsonDir, options.browser);
-            const readyPath = (0, _lib_paths__rspack_import_2.G6)(path__rspack_import_1.join(metadataDir, 'ready.json'));
-            const eventsPath = (0, _lib_paths__rspack_import_2.G6)(path__rspack_import_1.join(metadataDir, 'events.ndjson'));
-            const base = {
-                command: options.command,
-                browser: options.browser,
-                runId: createRunId(),
-                startedAt: nowISO(),
-                distPath: options.distPath,
-                manifestPath: options.manifestPath,
-                port: (()=>{
-                    if ('number' == typeof options.port && Number.isFinite(options.port)) return options.port;
-                    if ('string' == typeof options.port) {
-                        const parsed = parseInt(options.port, 10);
-                        return Number.isFinite(parsed) ? parsed : null;
-                    }
-                    return null;
-                })()
-            };
-            function writeReady(status, extra) {
-                ensureDirSync(metadataDir);
-                const payload = {
-                    ...base,
-                    status,
-                    pid: process.pid,
-                    ts: nowISO(),
-                    compiledAt: extra?.compiledAt ?? null,
-                    errors: Array.isArray(extra?.errors) ? extra.errors : []
-                };
-                if (extra?.code) payload.code = extra.code;
-                if (extra?.message) payload.message = extra.message;
-                writeJsonAtomic(readyPath, payload);
-            }
-            function appendEvent(event) {
-                ensureDirSync(metadataDir);
-                try {
-                    fs__rspack_import_0.appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, 'utf-8');
-                } catch  {}
-            }
-            return {
-                metadataDir,
-                readyPath,
-                eventsPath,
-                writeStarting () {
-                    writeReady('starting');
-                },
-                writeReady (compiledAt) {
-                    writeReady('ready', {
-                        compiledAt: compiledAt || nowISO()
-                    });
-                },
-                writeError (code, message, errors) {
-                    writeReady('error', {
-                        code,
-                        message,
-                        errors: Array.isArray(errors) ? errors : [],
-                        compiledAt: null
-                    });
-                },
-                appendEvent
-            };
-        }
-        class PlaywrightPlugin {
-            apply(compiler) {
-                this.writer.writeStarting();
-                compiler.hooks.compile.tap(PlaywrightPlugin.name, ()=>{
-                    this.writer.appendEvent({
-                        type: 'compile_start',
-                        ts: nowISO(),
-                        command: this.command,
-                        browser: this.browser
-                    });
-                });
-                compiler.hooks.done.tap(PlaywrightPlugin.name, (stats)=>{
-                    const durationMs = Number((stats?.compilation?.endTime || 0) - (stats?.compilation?.startTime || 0));
-                    const hasErrors = Boolean(stats?.hasErrors?.());
-                    const errorsCount = Number(Array.isArray(stats?.toJson?.({
-                        all: false,
-                        errors: true
-                    })?.errors) ? stats.toJson({
-                        all: false,
-                        errors: true
-                    }).errors.length : 0);
-                    if (hasErrors) {
-                        this.writer.appendEvent({
-                            type: 'compile_error',
-                            ts: nowISO(),
-                            command: this.command,
-                            browser: this.browser,
-                            durationMs: Number.isFinite(durationMs) ? durationMs : void 0,
-                            errorCount: Number.isFinite(errorsCount) ? errorsCount : 1
-                        });
-                        this.writer.writeError('compile_error', 'Compilation failed', [
-                            `errors: ${String(errorsCount || 1)}`
-                        ]);
-                        return;
-                    }
-                    this.writer.appendEvent({
-                        type: 'compile_success',
-                        ts: nowISO(),
-                        command: this.command,
-                        browser: this.browser,
-                        durationMs: Number.isFinite(durationMs) ? durationMs : void 0,
-                        errorCount: 0
-                    });
-                    this.writer.writeReady(nowISO());
-                });
-                compiler.hooks.failed.tap(PlaywrightPlugin.name, (error)=>{
-                    this.writer.appendEvent({
-                        type: 'compile_error',
-                        ts: nowISO(),
-                        command: this.command,
-                        browser: this.browser,
-                        errorCount: 1
-                    });
-                    this.writer.writeError('compile_failed', error instanceof Error ? error.message : String(error));
-                });
-                compiler.hooks.watchClose.tap(PlaywrightPlugin.name, ()=>{
-                    this.writer.appendEvent({
-                        type: 'shutdown',
-                        ts: nowISO(),
-                        command: this.command,
-                        browser: this.browser
-                    });
-                });
-            }
-            constructor(options){
-                _define_property(this, "writer", void 0);
-                _define_property(this, "command", void 0);
-                _define_property(this, "browser", void 0);
-                this.browser = String(options.browser || 'chromium');
-                this.command = options.command || ('development' === options.mode ? 'dev' : 'start');
-                this.writer = createPlaywrightMetadataWriter({
-                    packageJsonDir: options.packageJsonDir,
-                    browser: this.browser,
-                    command: this.command,
-                    distPath: options.outputPath,
-                    manifestPath: options.manifestPath,
-                    port: options.port
-                });
-            }
-        }
-        _define_property(PlaywrightPlugin, "name", 'plugin-playwright');
-    },
-    "./plugin-special-folders/folder-extensions/resolve-config.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            R: ()=>resolveCompanionExtensionsConfig
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        var extension_from_store__rspack_import_2 = __webpack_require__("extension-from-store");
-        var _utils__rspack_import_3 = __webpack_require__("./plugin-special-folders/folder-extensions/utils.ts");
-        function isPathLike(value) {
-            if (path__rspack_import_1.isAbsolute(value)) return true;
-            if (value.startsWith('./') || value.startsWith('../')) return true;
-            return value.includes('/') || value.includes('\\');
-        }
-        function isSubpathOf(parent, child) {
-            const rel = path__rspack_import_1.relative(parent, child);
-            return '' !== rel && !rel.startsWith('..') && !path__rspack_import_1.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 = path__rspack_import_1.resolve(projectRoot, 'extensions');
-            return paths.map((p)=>{
-                const abs = (0, _utils__rspack_import_3.A$)(projectRoot, p);
-                if (abs !== extensionsRoot && !isSubpathOf(extensionsRoot, abs) && path__rspack_import_1.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__rspack_import_3.Q7)(current)) return;
-                if ((0, _utils__rspack_import_3.Uy)(current)) return void found.push(current);
-                let entries = [];
-                try {
-                    entries = fs__rspack_import_0.readdirSync(current, {
-                        withFileTypes: true
-                    });
-                } catch  {
-                    return;
-                }
-                for (const ent of entries)if (ent.isDirectory()) {
-                    if (!ent.name.startsWith('.')) walk(path__rspack_import_1.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, extension_from_store__rspack_import_2.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 = path__rspack_import_1.resolve(projectRoot, 'extensions');
-            const targetRoot = path__rspack_import_1.join(extensionsRoot, browser, id);
-            const manifestPath = path__rspack_import_1.join(targetRoot, 'manifest.json');
-            if ((0, _utils__rspack_import_3.fo)(manifestPath)) return targetRoot;
-            await runExtensionFromStore(storeUrl, path__rspack_import_1.join(extensionsRoot, browser));
-            const candidates = findExtensionRoots(path__rspack_import_1.join(extensionsRoot, browser));
-            let selected;
-            if (1 === candidates.length) selected = candidates[0];
-            else if (candidates.length > 1) {
-                const directMatch = candidates.find((c)=>path__rspack_import_1.basename(c) === id);
-                const versionedMatch = candidates.find((c)=>path__rspack_import_1.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}.`);
-            fs__rspack_import_0.mkdirSync(path__rspack_import_1.dirname(targetRoot), {
-                recursive: true
-            });
-            if (path__rspack_import_1.basename(selected).startsWith(`${id}@`)) fs__rspack_import_0.renameSync(selected, targetRoot);
-            return targetRoot;
-        }
-        async function resolveCompanionExtensionsConfig(opts) {
-            const { projectRoot, browser, config } = opts;
-            if (!config) return;
-            const normalized = (0, _utils__rspack_import_3.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__rspack_import_3.A$)(projectRoot, normalized.dir);
-                const extensionsRoot = path__rspack_import_1.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;
-        }
-    },
-    "./plugin-special-folders/folder-extensions/utils.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __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
-            };
-        }
-    },
-    "./plugin-special-folders/get-data.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __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 browser_extension_manifest_fields__rspack_import_1 = __webpack_require__("browser-extension-manifest-fields");
-        function isUnderPublicDir(entry, projectRoot, publicDir) {
-            if (!entry) return false;
-            const normalizedEntry = String(entry);
-            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_1.getSpecialFoldersData)({
-                manifestPath: path__rspack_import_0_default().join(projectRoot, 'package.json')
-            });
-            return finalizeSpecialFoldersData(data, projectRoot, publicDir);
-        }
-        function getSpecialFoldersDataForProjectRoot(projectRoot) {
-            const publicDir = path__rspack_import_0_default().join(projectRoot, 'public');
-            const data = (0, browser_extension_manifest_fields__rspack_import_1.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: {
-                    dir: './extensions'
-                }
-            };
-        }
-    },
-    "./plugin-web-extension/feature-scripts/contracts.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            $t: ()=>EXTENSIONJS_CONTENT_SCRIPT_LAYER,
-            J4: ()=>getCanonicalContentScriptCssAssetName,
-            Y0: ()=>getCanonicalContentScriptEntryName,
-            es: ()=>parseCanonicalContentScriptAsset,
-            f6: ()=>getCanonicalContentScriptJsAssetName
-        });
-        const EXTENSIONJS_CONTENT_SCRIPT_LAYER = "extensionjs-content-script";
-        const CANONICAL_CONTENT_SCRIPT_ENTRY_PREFIX = "content_scripts/content-";
-        function getCanonicalContentScriptEntryName(index) {
-            return `${CANONICAL_CONTENT_SCRIPT_ENTRY_PREFIX}${index}`;
-        }
-        function getCanonicalContentScriptJsAssetName(index) {
-            return `${getCanonicalContentScriptEntryName(index)}.js`;
-        }
-        function getCanonicalContentScriptCssAssetName(index) {
-            return `${getCanonicalContentScriptEntryName(index)}.css`;
-        }
-        function parseCanonicalContentScriptAsset(assetName) {
-            const match = /^content_scripts\/content-(\d+)(?:\.[a-f0-9]+)?\.(js|css)$/i.exec(String(assetName || ''));
-            if (!match) return;
-            const index = Number(match[1]);
-            if (!Number.isInteger(index)) return;
-            return {
-                index,
-                extension: match[2]
-            };
-        }
-    },
-    "@rspack/core" (module) {
-        module.exports = require("@rspack/core");
-    },
-    "@rspack/dev-server" (module) {
-        module.exports = require("@rspack/dev-server");
-    },
-    "adm-zip" (module) {
-        module.exports = require("adm-zip");
-    },
-    "browser-extension-manifest-fields" (module) {
-        module.exports = require("browser-extension-manifest-fields");
-    },
-    "case-sensitive-paths-webpack-plugin" (module) {
-        module.exports = require("case-sensitive-paths-webpack-plugin");
-    },
-    "content-security-policy-parser" (module) {
-        module.exports = require("content-security-policy-parser");
-    },
-    crypto (module) {
-        module.exports = require("crypto");
-    },
-    dotenv (module) {
-        module.exports = require("dotenv");
-    },
-    "extension-from-store" (module) {
-        module.exports = require("extension-from-store");
-    },
-    fs (module) {
-        module.exports = require("fs");
-    },
-    ignore (module) {
-        module.exports = require("ignore");
-    },
-    module (module) {
-        module.exports = require("module");
-    },
-    net (module) {
-        module.exports = require("net");
-    },
-    os (module) {
-        module.exports = require("os");
-    },
-    "parse5-utilities" (module) {
-        module.exports = require("parse5-utilities");
-    },
-    path (module) {
-        module.exports = require("path");
-    },
-    pintor (module) {
-        module.exports = require("pintor");
-    },
-    stream (module) {
-        module.exports = require("stream");
-    },
-    "tiny-glob" (module) {
-        module.exports = require("tiny-glob");
-    },
-    url (module) {
-        module.exports = require("url");
-    },
-    vm (module) {
-        module.exports = require("vm");
-    },
-    "webpack-merge" (module) {
-        module.exports = require("webpack-merge");
-    },
-    "./package.json" (module) {
-        module.exports = JSON.parse('{"rE":"3.15.1","El":{"@prefresh/core":"1.5.9","@prefresh/utils":"1.2.1","@rspack/core":"^2.0.1","@rspack/dev-server":"^2.0.1","@rspack/plugin-preact-refresh":"1.1.5","@rspack/plugin-react-refresh":"1.6.2","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","@vue/compiler-sfc":"3.5.26","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.3","case-sensitive-paths-webpack-plugin":"^2.4.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","extension-from-store":"^0.1.1","go-git-it":"^5.1.5","ignore":"^7.0.5","less":"4.5.1","less-loader":"12.3.2","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5-utilities":"^1.0.0","pintor":"0.3.0","postcss":"8.5.10","postcss-loader":"8.2.1","postcss-preset-env":"11.1.1","postcss-scss":"4.0.9","preact":"10.27.3","react-refresh":"0.18.0","sass-loader":"16.0.7","schema-utils":"^4.3.3","svelte-loader":"3.2.4","tiny-glob":"^0.2.9","typescript":"5.9.3","unique-names-generator":"^4.7.1","vue":"3.5.26","vue-loader":"17.4.2","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3"}}');
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-__webpack_require__.m = __webpack_modules__;
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.f = {};
-    __webpack_require__.e = (chunkId)=>Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key)=>{
-            __webpack_require__.f[key](chunkId, promises);
-            return promises;
-        }, []));
-})();
-(()=>{
-    __webpack_require__.u = (chunkId)=>"" + chunkId + ".cjs";
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-(()=>{
-    var installedChunks = {
-        364: 1
-    };
-    var installChunk = (chunk)=>{
-        var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;
-        for(var moduleId in moreModules)if (__webpack_require__.o(moreModules, moduleId)) __webpack_require__.m[moduleId] = moreModules[moduleId];
-        if (runtime) runtime(__webpack_require__);
-        for(var i = 0; i < chunkIds.length; i++)installedChunks[chunkIds[i]] = 1;
-    };
-    __webpack_require__.f.require = (chunkId, promises)=>{
-        if (!installedChunks[chunkId]) installChunk(require("./" + __webpack_require__.u(chunkId)));
-    };
-})();
-var __webpack_exports__ = __webpack_require__("./module.ts");
-exports.BuildEmitter = __webpack_exports__.BuildEmitter;
-exports.extensionBuild = __webpack_exports__.extensionBuild;
-exports.extensionDev = __webpack_exports__.extensionDev;
-exports.extensionPreview = __webpack_exports__.extensionPreview;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "BuildEmitter",
-    "extensionBuild",
-    "extensionDev",
-    "extensionPreview"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});