extension-develop 3.14.5 → 3.15.0-next.1

package/dist/module.cjs

@@ -1487,1928 +1487,1936 @@ var __webpack_modules__ = {
             return Object.fromEntries(Object.entries(obj || {}).filter(([, value])=>void 0 !== value));
         }
     },
-    "./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__) {
+    "./module.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
         __webpack_require__.d(__webpack_exports__, {
-            Ei: ()=>jsFrameworksHmrSummary,
-            LR: ()=>creatingTSConfig,
-            MH: ()=>jsFrameworksConfigsDetected,
-            Ty: ()=>isUsingCustomLoader,
-            jH: ()=>jsFrameworksIntegrationsEnabled,
-            zA: ()=>isUsingIntegration
+            BuildEmitter: ()=>BuildEmitter,
+            extensionDev: ()=>extensionDev,
+            extensionPreview: ()=>extensionPreview,
+            extensionBuild: ()=>extensionBuild
         });
-        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 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
+            };
         }
-        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}`;
+        var external_module_ = __webpack_require__("module");
+        var external_path_ = __webpack_require__("path");
+        var external_fs_ = __webpack_require__("fs");
+        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);
+            }
         }
-        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}`;
+        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;
+            }
         }
-    },
-    "./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 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;
             }
         }
-        function hasTypeScriptSourceFiles(projectPath) {
+        const isUrl = (url)=>{
             try {
-                const entries = fs__rspack_import_1.readdirSync(projectPath, {
-                    withFileTypes: true
+                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
                 });
-                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;
+                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;
                     }
-                    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);
+                    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 false;
-                });
-            } catch  {
-                return false;
+                    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
+            };
         }
-        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);
+        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);
                 }
-                hasShownUserMessage = true;
+            } catch (error) {
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(error);
             }
-            return !!tsConfigFilePath && !!(TypeScriptAsDevDep || TypeScriptAsDep || hasTsFiles);
         }
-        function defaultTypeScriptConfig(projectPath, _opts) {
+        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 {
-                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'
-                ]
+                name: inferredName,
+                execPath
             };
         }
-        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 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 writeTsConfig(projectPath) {
-            fs__rspack_import_1.writeFileSync(path__rspack_import_0.join(projectPath, 'tsconfig.json'), JSON.stringify(defaultTypeScriptConfig(projectPath, {
-                mode: 'development'
-            }), null, 2));
+        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;
         }
-    },
-    "./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 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 nowISO() {
-            return new Date().toISOString();
+        function isWindowsExecutablePath(value) {
+            if (!value || 'win32' !== process.platform) return false;
+            return /\.(cmd|bat|exe)$/i.test(value);
         }
-        function createRunId() {
-            return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+        function isNodeScriptPath(value) {
+            if (!value) return false;
+            return /\.(mjs|cjs|js)$/i.test(value);
         }
-        function ensureDirSync(dirPath) {
+        function resolveWindowsCommandPath(command) {
+            if ('win32' !== process.platform) return;
             try {
-                fs__rspack_import_0.mkdirSync(dirPath, {
-                    recursive: true
+                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
                 });
-            } catch  {}
+                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 writeJsonAtomic(filePath, value) {
+        function resolveUnixCommandPath(command) {
+            if ('win32' === process.platform) return;
             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  {}
+                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 getPlaywrightMetadataDir(packageJsonDir, browser) {
-            return (0, _lib_paths__rspack_import_2.G6)(path__rspack_import_1.join(packageJsonDir, 'dist', 'extension-js', browser));
+        function resolveCommandOnPath(command) {
+            return resolveWindowsCommandPath(command) || resolveUnixCommandPath(command) || void 0;
         }
-        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 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
             };
-            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 ('npm' === name) {
+                const bundledNpmCli = resolveBundledNpmCliPath();
+                if (bundledNpmCli) return {
+                    name: 'npm',
+                    execPath: bundledNpmCli,
+                    runnerCommand: process.execPath,
+                    runnerArgs: [
+                        bundledNpmCli
+                    ]
                 };
-                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  {}
+        }
+        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 {
-                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
+                command: pm.name,
+                args
             };
         }
-        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
-                    });
+        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
+                    } : {}
                 });
-                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;
+                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(512).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);
+                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
                     }
-                    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));
+                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
                 });
-                compiler.hooks.watchClose.tap(PlaywrightPlugin.name, ()=>{
-                    this.writer.appendEvent({
-                        type: 'shutdown',
-                        ts: nowISO(),
-                        command: this.command,
-                        browser: this.browser
+                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();
+                        }
                     });
                 });
-            }
-            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
-                });
+                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);
             }
         }
-        _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('\\');
+        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));
+                }
+            }
         }
-        function isSubpathOf(parent, child) {
-            const rel = path__rspack_import_1.relative(parent, child);
-            return '' !== rel && !rel.startsWith('..') && !path__rspack_import_1.isAbsolute(rel);
+        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;
         }
-        function getBrowserFolder(browser) {
-            if ('firefox' === browser || 'gecko-based' === browser || 'firefox-based' === browser) return 'firefox';
-            if ('edge' === browser) return 'edge';
-            return 'chrome';
+        class BuildEmitter extends external_node_events_namespaceObject.EventEmitter {
+            constructor(){
+                super();
+                this.on('error', ()=>{});
+            }
         }
-        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;
+        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
+                    };
+                    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
+                                };
+                            }
+                        }
+                    }
+                    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;
         }
-        function parseStoreUrl(raw) {
-            let url;
+        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 {
-                url = new URL(raw);
-            } catch  {
-                return null;
+                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(512),
+                    __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);
             }
-            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) {
+        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 = [];
-            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);
+            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);
+                    }
                 }
             }
-            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;
+            const unique = [];
+            const seen = new Set();
+            for (const p of found)if (!seen.has(p)) {
+                seen.add(p);
+                unique.push(p);
             }
-            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;
+            return unique;
         }
-        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;
+        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'
                 }
-                if (isPathLike(entry)) localPaths.push(entry);
+            };
+            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));
             }
-            if (localPaths.length > 0) {
-                const absLocalPaths = ensurePathsUnderExtensions(projectRoot, localPaths);
-                resolvedPaths.push(...absLocalPaths);
+            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 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;
+            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;
             }
-            if (resolvedPaths.length > 0) output.paths = resolvedPaths;
-            return output;
+            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-special-folders/folder-extensions/utils.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+    "./plugin-js-frameworks/frameworks-lib/integrations.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            A$: ()=>toAbs,
-            Q7: ()=>isDir,
-            Uy: ()=>isValidExtensionRoot,
-            cz: ()=>normalizeCompanionConfig,
-            fo: ()=>isFile
+            qQ: ()=>isUsingJSFramework,
+            ws: ()=>_lib_has_dependency__rspack_import_0.w
         });
-        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;
-            }
+        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));
         }
-        function isFile(p) {
-            try {
-                return fs__rspack_import_0.existsSync(p) && fs__rspack_import_0.statSync(p).isFile();
-            } catch  {
-                return false;
-            }
+    },
+    "./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 toAbs(projectRoot, p) {
-            return path__rspack_import_1.isAbsolute(p) ? p : path__rspack_import_1.resolve(projectRoot, p);
+        function creatingTSConfig() {
+            return `${pintor__rspack_import_0_default().gray('⏵⏵⏵')} Creating default tsconfig.json...`;
         }
-        function isValidExtensionRoot(dir) {
-            if (!isDir(dir)) return false;
-            return isFile(path__rspack_import_1.join(dir, 'manifest.json'));
+        function isUsingCustomLoader(loaderPath) {
+            return `${pintor__rspack_import_0_default().gray('⏵⏵⏵')} Using custom loader: ${pintor__rspack_import_0_default().yellow(loaderPath)}.`;
         }
-        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
-            };
+        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-special-folders/get-data.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+    "./plugin-js-frameworks/js-tools/typescript.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            B: ()=>getSpecialFoldersDataForCompiler,
-            H: ()=>getSpecialFoldersDataForProjectRoot
+            eE: ()=>isUsingTypeScript,
+            hB: ()=>getUserTypeScriptConfigFile
         });
         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;
-                }
+        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;
             }
-            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 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 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 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 finalizeSpecialFoldersData(data, projectRoot, publicDir) {
+        function defaultTypeScriptConfig(projectPath, _opts) {
             return {
-                ...data,
-                pages: filterPublicEntrypoints(data.pages, projectRoot, publicDir),
-                scripts: filterPublicEntrypoints(data.scripts, projectRoot, publicDir),
-                extensions: {
-                    dir: './extensions'
-                }
+                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-web-extension/feature-scripts/contracts.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+    "./plugin-playwright/index.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
+            Ih: ()=>createPlaywrightMetadataWriter,
+            Tb: ()=>PlaywrightPlugin
         });
-        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}`;
+        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 getCanonicalContentScriptJsAssetName(index) {
-            return `${getCanonicalContentScriptEntryName(index)}.js`;
+        function nowISO() {
+            return new Date().toISOString();
         }
-        function getCanonicalContentScriptCssAssetName(index) {
-            return `${getCanonicalContentScriptEntryName(index)}.css`;
+        function createRunId() {
+            return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
         }
-        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]
-            };
+        function ensureDirSync(dirPath) {
+            try {
+                fs__rspack_import_0.mkdirSync(dirPath, {
+                    recursive: true
+                });
+            } catch  {}
         }
-    },
-    "@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.14.5","El":{"@prefresh/core":"1.5.9","@prefresh/utils":"1.2.1","@rspack/core":"^1.7.5","@rspack/dev-server":"^1.2.1","@rspack/plugin-preact-refresh":"1.1.4","@rspack/plugin-react-refresh":"1.6.0","@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.1","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.0","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5-utilities":"^1.0.0","pintor":"0.3.0","postcss":"8.5.6","postcss-loader":"8.2.0","postcss-preset-env":"11.1.1","postcss-scss":"4.0.9","preact":"10.27.3","react-refresh":"0.18.0","sass-loader":"16.0.6","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__.r(__webpack_exports__);
-    __webpack_require__.d(__webpack_exports__, {
-        BuildEmitter: ()=>BuildEmitter,
-        extensionDev: ()=>extensionDev,
-        extensionPreview: ()=>extensionPreview,
-        extensionBuild: ()=>extensionBuild
-    });
-    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 external_fs_ = __webpack_require__("fs");
-    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);
+        function writeJsonAtomic(filePath, value) {
             try {
-                const stat = await external_fs_.promises.stat(candidate);
-                if (stat.isFile()) return candidate;
+                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  {}
-            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;
+        function getPlaywrightMetadataDir(packageJsonDir, browser) {
+            return (0, _lib_paths__rspack_import_2.G6)(path__rspack_import_1.join(packageJsonDir, 'dist', 'extension-js', browser));
         }
-    }
-    const isUrl = (url)=>{
-        try {
-            new URL(url);
-            return true;
-        } catch (e) {
-            return false;
+        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
+            };
         }
-    };
-    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
+        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
                         });
-                        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));
-                        }
+                        this.writer.writeError('compile_error', 'Compilation failed', [
+                            `errors: ${String(errorsCount || 1)}`
+                        ]);
+                        return;
                     }
-                    return false;
-                };
-                if (hasManifest(expectedPath)) return expectedPath;
-                external_fs_.rmSync(expectedPath, {
-                    recursive: true,
-                    force: true
+                    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
+                    });
                 });
             }
-        } 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("893").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;
+            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;
                 }
-                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;
-                    }
+                for (const ent of entries)if (ent.isDirectory()) {
+                    if (!ent.name.startsWith('.')) walk(path__rspack_import_1.join(current, ent.name), depth + 1);
                 }
-                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
-            };
+            walk(dir, 0);
+            return found;
         }
-    }
-    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
+        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
             });
-            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'
-                ]
+        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
             });
-            const candidate = String(output).trim();
-            return candidate || void 0;
-        } catch  {
-            return;
+            if (path__rspack_import_1.basename(selected).startsWith(`${id}@`)) fs__rspack_import_0.renameSync(selected, targetRoot);
+            return targetRoot;
         }
-    }
-    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;
+        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;
         }
-    }
-    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
-                ]
-            };
+    },
+    "./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 resolvePackageManager(opts) {
-        const lockPm = detectByLockfile(opts?.cwd);
-        if (lockPm) {
-            const hydrated = hydrateResolvedPackageManager(lockPm);
-            if (hydrated) return hydrated;
-            return {
-                name: lockPm
-            };
+        function isFile(p) {
+            try {
+                return fs__rspack_import_0.existsSync(p) && fs__rspack_import_0.statSync(p).isFile();
+            } catch  {
+                return false;
+            }
         }
-        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
-            };
+        function toAbs(projectRoot, p) {
+            return path__rspack_import_1.isAbsolute(p) ? p : path__rspack_import_1.resolve(projectRoot, p);
         }
-        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
-            };
+        function isValidExtensionRoot(dir) {
+            if (!isDir(dir)) return false;
+            return isFile(path__rspack_import_1.join(dir, 'manifest.json'));
         }
-        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("750").then(__webpack_require__.bind(__webpack_require__, "./lib/stats-handler.ts")),
-                __webpack_require__.e("740").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);
-            if (debug) {
-                console.log(messages.SG(manifestDir, packageJsonDir));
-                console.log(messages._A(browser, buildOptions?.chromiumBinary, buildOptions?.geckoBinary || buildOptions?.firefoxBinary));
-                console.log(messages.AC(distPath));
+        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();
             }
-            const mergedExtensionsConfig = buildOptions?.extensions ?? commandConfig.extensions ?? specialFoldersData.extensions;
-            const resolvedExtensionsConfig = await (0, resolve_config.R)({
-                projectRoot: packageJsonDir,
-                browser,
-                config: mergedExtensionsConfig
-            });
-            const baseConfig = webpackConfig(projectStructure, {
-                ...commandConfig,
-                ...buildOptions,
-                extensions: resolvedExtensionsConfig,
-                browser,
-                mode: 'production',
-                output: {
-                    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
+            return {
+                dir: scanDir,
+                paths: explicitPaths
             };
-            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));
-            }
+    },
+    "./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));
         }
-    }
-    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 {
-    }
-    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
-                };
-                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
-                            };
-                        }
-                    }
+        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;
                 }
-                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)
-                        ]
-                    });
+                if ('string' == typeof value) {
+                    if (!isUnderPublicDir(value, projectRoot, publicDir)) next[key] = value;
+                    continue;
                 }
-                else if (this.controller && reloadInstruction) try {
-                    await this.controller.reload(reloadInstruction);
-                } catch  {}
-                this.emitter.emit('compiled', {
-                    outputPath,
-                    contextDir,
-                    isFirstCompile: wasFirstCompile,
-                    reloadInstruction,
-                    extensionsToLoad: wasFirstCompile ? this.extensionsToLoad : void 0
-                });
-            });
+            }
+            return next;
         }
-        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;
+        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);
         }
-    }
-    _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("740"),
-                __webpack_require__.e("481")
-            ]).then(__webpack_require__.bind(__webpack_require__, "./dev-server/index.ts"));
-            await devServer(projectStructure, {
-                ...devOptions,
-                mode: 'development',
-                browser,
-                geckoBinary,
-                browsersPlugin
+        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 emitter;
-        } catch (error) {
-            console.error(error);
-            process.exit(1);
+            return finalizeSpecialFoldersData(data, projectRoot, publicDir);
         }
-    }
-    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);
+        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}`;
         }
-        const unique = [];
-        const seen = new Set();
-        for (const p of found)if (!seen.has(p)) {
-            seen.add(p);
-            unique.push(p);
+        function getCanonicalContentScriptJsAssetName(index) {
+            return `${getCanonicalContentScriptEntryName(index)}.js`;
         }
-        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
-        };
+        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.0-next.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.1","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 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
+};
+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
         });
-        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
+        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]
         });
-        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
+    };
+})();
+(()=>{
+    __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'
         });
-        const companionUnpackedExtensionDirs = resolveCompanionExtensionDirs({
-            projectRoot: packageJsonDir,
-            config: merged.extensions
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
         });
-        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();
-    }
+    };
+})();
+(()=>{
+    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;