extension-develop 3.14.5 → 3.15.0-next.1

package/dist/preview.cjs

@@ -137,1302 +137,1302 @@ var __webpack_modules__ = {
             return `${getLoggingPrefix('error')} Your project declares dependencies that are managed by ${pintor__rspack_import_2_default().blue('Extension.js')} and referenced in ${pintor__rspack_import_2_default().underline('extension.config.js')}\n${pintor__rspack_import_2_default().red('This can cause version conflicts and break the development/build process.')}\n\n${pintor__rspack_import_2_default().gray('Managed dependencies (remove these from your package.json):')}\n${list}\n\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(userPackageJsonPath)}\nIf you need a different version, open an issue so we can consider bundling it safely.\nOperation aborted.`;
         }
     },
-    "adm-zip" (module) {
-        module.exports = require("adm-zip");
-    },
-    fs (module) {
-        module.exports = require("fs");
-    },
-    path (module) {
-        module.exports = require("path");
-    },
-    pintor (module) {
-        module.exports = require("pintor");
-    },
-    "./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
+    "./preview-entry.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            extensionPreview: ()=>extensionPreview
         });
-    };
-})();
-(()=>{
-    var installedChunks = {
-        534: 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__, {
-        extensionPreview: ()=>extensionPreview
-    });
-    var external_path_ = __webpack_require__("path");
-    var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_);
-    var external_fs_ = __webpack_require__("fs");
-    var lib_messages = __webpack_require__("./lib/messages.ts");
-    async function findUpLocal(filename, options) {
-        const root = external_path_.parse(options.cwd).root;
-        let currentDir = options.cwd;
-        while(true){
-            const candidate = external_path_.join(currentDir, filename);
-            try {
-                const stat = await external_fs_.promises.stat(candidate);
-                if (stat.isFile()) return candidate;
-            } catch  {}
-            if (currentDir === root) return;
-            currentDir = external_path_.dirname(currentDir);
-        }
-    }
-    async function findNearestPackageJson(manifestPath) {
-        try {
-            const manifestDir = external_path_.dirname(manifestPath);
-            const packageJsonPath = await findUpLocal('package.json', {
-                cwd: manifestDir
-            });
-            return packageJsonPath || null;
-        } catch (error) {
-            console.warn('Failed to find package.json:', error);
-            return null;
+        var external_path_ = __webpack_require__("path");
+        var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_);
+        var external_fs_ = __webpack_require__("fs");
+        var lib_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 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;
+        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;
+            }
         }
-    }
-    const isUrl = (url)=>{
-        try {
-            new URL(url);
-            return true;
-        } catch (e) {
-            return false;
+        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;
+            }
         }
-    };
-    async function importUrlSourceFromGithub(pathOrRemoteUrl, text) {
-        const cwd = process.cwd();
-        const url = new URL(pathOrRemoteUrl);
-        const segments = url.pathname.split('/').filter(Boolean);
-        const repoName = segments.length >= 2 ? segments[1] : segments[segments.length - 1];
-        const treeIndex = segments.indexOf('tree');
-        const expectedName = -1 !== treeIndex && segments.length > treeIndex + 2 ? segments[segments.length - 1] : repoName;
-        const expectedPath = external_path_.resolve(cwd, expectedName);
-        if (external_fs_.existsSync(expectedPath)) try {
-            const entries = external_fs_.readdirSync(expectedPath);
-            if (0 === entries.length) external_fs_.rmSync(expectedPath, {
-                recursive: true,
-                force: true
-            });
-            else {
-                const hasManifest = (dir)=>{
-                    const stack = [
-                        dir
-                    ];
-                    while(stack.length){
-                        const current = stack.pop();
-                        const items = external_fs_.readdirSync(current, {
-                            withFileTypes: true
-                        });
-                        for (const it of items){
-                            if (it.isFile() && 'manifest.json' === it.name) return true;
-                            if (it.isDirectory() && 'node_modules' !== it.name && 'dist' !== it.name && !it.name.startsWith('.')) stack.push(external_path_.join(current, it.name));
-                        }
-                    }
-                    return false;
-                };
-                if (hasManifest(expectedPath)) return expectedPath;
-                external_fs_.rmSync(expectedPath, {
+        const isUrl = (url)=>{
+            try {
+                new URL(url);
+                return true;
+            } catch (e) {
+                return false;
+            }
+        };
+        async function importUrlSourceFromGithub(pathOrRemoteUrl, text) {
+            const cwd = process.cwd();
+            const url = new URL(pathOrRemoteUrl);
+            const segments = url.pathname.split('/').filter(Boolean);
+            const repoName = segments.length >= 2 ? segments[1] : segments[segments.length - 1];
+            const treeIndex = segments.indexOf('tree');
+            const expectedName = -1 !== treeIndex && segments.length > treeIndex + 2 ? segments[segments.length - 1] : repoName;
+            const expectedPath = external_path_.resolve(cwd, expectedName);
+            if (external_fs_.existsSync(expectedPath)) try {
+                const entries = external_fs_.readdirSync(expectedPath);
+                if (0 === entries.length) external_fs_.rmSync(expectedPath, {
                     recursive: true,
                     force: true
                 });
+                else {
+                    const hasManifest = (dir)=>{
+                        const stack = [
+                            dir
+                        ];
+                        while(stack.length){
+                            const current = stack.pop();
+                            const items = external_fs_.readdirSync(current, {
+                                withFileTypes: true
+                            });
+                            for (const it of items){
+                                if (it.isFile() && 'manifest.json' === it.name) return true;
+                                if (it.isDirectory() && 'node_modules' !== it.name && 'dist' !== it.name && !it.name.startsWith('.')) stack.push(external_path_.join(current, it.name));
+                            }
+                        }
+                        return false;
+                    };
+                    if (hasManifest(expectedPath)) return expectedPath;
+                    external_fs_.rmSync(expectedPath, {
+                        recursive: true,
+                        force: true
+                    });
+                }
+            } catch  {}
+            async function tryGitClone() {
+                const { default: goGitIt } = await import("go-git-it");
+                await goGitIt(pathOrRemoteUrl, cwd, text);
+            }
+            async function tryZipFallback() {
+                const branch = -1 !== treeIndex && segments.length > treeIndex + 1 ? segments[treeIndex + 1] : 'main';
+                const owner = segments[0];
+                const repo = segments[1];
+                const subdir = -1 !== treeIndex && segments.length > treeIndex + 2 ? segments.slice(treeIndex + 2).join('/') : '';
+                const zipUrl = `https://codeload.github.com/${owner}/${repo}/zip/refs/heads/${branch}`;
+                const extractedPath = await importUrlSourceFromZip(zipUrl);
+                const extractedDirs = external_fs_.readdirSync(extractedPath, {
+                    withFileTypes: true
+                }).filter((d)=>d.isDirectory()).map((d)=>d.name);
+                const repoRootDir = extractedDirs.find((d)=>d.startsWith(`${repo}-${branch}`));
+                const repoRoot = repoRootDir ? external_path_.join(extractedPath, repoRootDir) : extractedPath;
+                return subdir ? external_path_.join(repoRoot, subdir) : repoRoot;
+            }
+            try {
+                await tryGitClone();
+            } catch  {
+                return await tryZipFallback();
+            }
+            const candidates = [];
+            if (-1 !== treeIndex && segments.length > treeIndex + 2) candidates.push(segments[segments.length - 1]);
+            candidates.push(repoName);
+            for (const name of candidates){
+                const p = external_path_.resolve(cwd, name);
+                if (external_fs_.existsSync(p)) return p;
             }
-        } 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(lib_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);
+            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(lib_messages.ax(cwd, candidates));
+        }
+        async function importUrlSourceFromZip(pathOrRemoteUrl) {
+            const cwd = process.cwd();
+            const { downloadAndExtractZip } = await __webpack_require__.e(787).then(__webpack_require__.bind(__webpack_require__, "./lib/zip.ts"));
+            const extractedPath = await downloadAndExtractZip(pathOrRemoteUrl, cwd);
+            return extractedPath;
+        }
+        async function getProjectPath(pathOrRemoteUrl) {
+            if (!pathOrRemoteUrl) return process.cwd();
+            if (isUrl(pathOrRemoteUrl)) {
+                const url = new URL(pathOrRemoteUrl);
+                if (url.protocol.startsWith('http')) {
+                    const pathname = url.pathname.toLowerCase();
+                    if (pathname.endsWith('.zip')) return await importUrlSourceFromZip(pathOrRemoteUrl);
+                    if ('https://github.com' !== url.origin) {
+                        const urlSource = await importUrlSourceFromZip(pathOrRemoteUrl);
+                        return urlSource;
+                    }
+                    const urlData = url.pathname.split('/');
+                    const owner = urlData.slice(1, 3)[0];
+                    const project = urlData.slice(1, 3)[1];
+                    console.log(lib_messages.tQ(owner, project));
+                    const projectName = external_path_.basename(url.pathname);
+                    const urlSource = await importUrlSourceFromGithub(pathOrRemoteUrl, lib_messages.F$(projectName));
+                    console.log(lib_messages.W4(url.pathname));
                     return urlSource;
                 }
-                const urlData = url.pathname.split('/');
-                const owner = urlData.slice(1, 3)[0];
-                const project = urlData.slice(1, 3)[1];
-                console.log(lib_messages.tQ(owner, project));
-                const projectName = external_path_.basename(url.pathname);
-                const urlSource = await importUrlSourceFromGithub(pathOrRemoteUrl, lib_messages.F$(projectName));
-                console.log(lib_messages.W4(url.pathname));
-                return urlSource;
             }
+            return external_path_.resolve(process.cwd(), pathOrRemoteUrl);
         }
-        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(lib_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;
+        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(lib_messages.dx(manifestPath));
+                const findManifest = (dir)=>{
+                    const files = external_fs_.readdirSync(dir, {
+                        withFileTypes: true
+                    });
+                    for (const file of files){
+                        if (file.isFile() && 'manifest.json' === file.name) return external_path_.join(dir, file.name);
+                        if (file.isDirectory() && !file.name.startsWith('.') && 'node_modules' !== file.name && 'dist' !== file.name && 'public' !== file.name) {
+                            const found = findManifest(external_path_.join(dir, file.name));
+                            if (found) return found;
+                        }
                     }
+                    return null;
+                };
+                const foundManifest = findManifest(projectPath);
+                if (foundManifest) manifestPath = foundManifest;
+                else throw new Error(lib_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(lib_messages.dx(fallbackRoot));
                 }
-                return null;
-            };
-            const foundManifest = findManifest(projectPath);
-            if (foundManifest) manifestPath = foundManifest;
-            else throw new Error(lib_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(lib_messages.dx(fallbackRoot));
             }
+            if (!packageJsonPath || !validatePackageJson(packageJsonPath)) return {
+                manifestPath
+            };
+            return {
+                manifestPath,
+                packageJsonPath
+            };
         }
-        if (!packageJsonPath || !validatePackageJson(packageJsonPath)) return {
-            manifestPath
-        };
-        return {
-            manifestPath,
-            packageJsonPath
-        };
-    }
-    const external_os_namespaceObject = require("os");
-    const external_vm_namespaceObject = require("vm");
-    const external_url_namespaceObject = require("url");
-    const external_module_namespaceObject = require("module");
-    const external_dotenv_namespaceObject = require("dotenv");
-    var external_dotenv_default = /*#__PURE__*/ __webpack_require__.n(external_dotenv_namespaceObject);
-    function loadCommonJsConfigWithStableDirname(absolutePath) {
-        const code = external_fs_.readFileSync(absolutePath, 'utf-8');
-        const dirname = external_path_.dirname(absolutePath);
-        const requireFn = (0, external_module_namespaceObject.createRequire)(absolutePath);
-        const module = {
-            exports: {}
-        };
-        const exports1 = module.exports;
-        const wrapped = `(function (exports, require, module, __filename, __dirname) {\n${code}\n})`;
-        const fn = new external_vm_namespaceObject.Script(wrapped, {
-            filename: absolutePath
-        }).runInThisContext();
-        fn(exports1, requireFn, module, absolutePath, dirname);
-        return module.exports?.default || module.exports;
-    }
-    function findNearestWorkspaceRoot(startDir) {
-        let current = external_path_.resolve(startDir);
-        while(true){
-            if (external_fs_.existsSync(external_path_.join(current, 'pnpm-workspace.yaml'))) return current;
-            const parent = external_path_.dirname(current);
-            if (parent === current) return;
-            current = parent;
-        }
-    }
-    function preloadEnvFilesFromDir(envDir, options) {
-        let loadedAny = false;
-        try {
-            const defaultsPath = external_path_.join(envDir, '.env.defaults');
-            if (external_fs_.existsSync(defaultsPath)) {
-                external_dotenv_default().config({
-                    path: defaultsPath,
-                    override: Boolean(options?.override),
-                    quiet: true
-                });
-                loadedAny = true;
+        const external_os_namespaceObject = require("os");
+        const external_vm_namespaceObject = require("vm");
+        const external_url_namespaceObject = require("url");
+        const external_module_namespaceObject = require("module");
+        const external_dotenv_namespaceObject = require("dotenv");
+        var external_dotenv_default = /*#__PURE__*/ __webpack_require__.n(external_dotenv_namespaceObject);
+        function loadCommonJsConfigWithStableDirname(absolutePath) {
+            const code = external_fs_.readFileSync(absolutePath, 'utf-8');
+            const dirname = external_path_.dirname(absolutePath);
+            const requireFn = (0, external_module_namespaceObject.createRequire)(absolutePath);
+            const module = {
+                exports: {}
+            };
+            const exports1 = module.exports;
+            const wrapped = `(function (exports, require, module, __filename, __dirname) {\n${code}\n})`;
+            const fn = new external_vm_namespaceObject.Script(wrapped, {
+                filename: absolutePath
+            }).runInThisContext();
+            fn(exports1, requireFn, module, absolutePath, dirname);
+            return module.exports?.default || module.exports;
+        }
+        function findNearestWorkspaceRoot(startDir) {
+            let current = external_path_.resolve(startDir);
+            while(true){
+                if (external_fs_.existsSync(external_path_.join(current, 'pnpm-workspace.yaml'))) return current;
+                const parent = external_path_.dirname(current);
+                if (parent === current) return;
+                current = parent;
             }
-            const envCandidates = [
-                '.env.development',
-                '.env.local',
-                '.env'
-            ];
-            for (const filename of envCandidates){
-                const filePath = external_path_.join(envDir, filename);
-                if (external_fs_.existsSync(filePath)) {
+        }
+        function preloadEnvFilesFromDir(envDir, options) {
+            let loadedAny = false;
+            try {
+                const defaultsPath = external_path_.join(envDir, '.env.defaults');
+                if (external_fs_.existsSync(defaultsPath)) {
                     external_dotenv_default().config({
-                        path: filePath,
+                        path: defaultsPath,
                         override: Boolean(options?.override),
                         quiet: true
                     });
                     loadedAny = true;
-                    break;
                 }
-            }
-        } catch  {}
-        return {
-            loadedAny,
-            envDir
-        };
-    }
-    function findConfigFile(projectPath) {
-        const candidates = [
-            external_path_.join(projectPath, 'extension.config.js'),
-            external_path_.join(projectPath, 'extension.config.mjs'),
-            external_path_.join(projectPath, 'extension.config.cjs')
-        ];
-        return candidates.find((p)=>external_fs_.existsSync(p));
-    }
-    function preloadEnvFiles(projectDir) {
-        const local = preloadEnvFilesFromDir(projectDir);
-        if (local.loadedAny) return local;
-        const workspaceRoot = findNearestWorkspaceRoot(projectDir);
-        if (workspaceRoot && workspaceRoot !== projectDir) return preloadEnvFilesFromDir(workspaceRoot);
-        return local;
-    }
-    async function loadConfigFile(configPath) {
-        const absolutePath = external_path_.resolve(configPath);
-        const projectDir = external_path_.dirname(absolutePath);
-        preloadEnvFiles(projectDir);
-        try {
-            if (absolutePath.endsWith('.cjs')) {
-                const requireFn = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
-                const required = requireFn(absolutePath);
-                return required?.default || required;
-            }
-            let esmImportPath = absolutePath;
-            try {
-                const originalContent = external_fs_.readFileSync(absolutePath, 'utf-8');
-                if (originalContent.includes('import.meta.env')) {
-                    const tmpDir = external_fs_.mkdtempSync(external_path_.join(external_os_namespaceObject.tmpdir(), 'extension-config-esm-'));
-                    const tmpPath = external_path_.join(tmpDir, external_path_.basename(absolutePath));
-                    const envObjectLiteral = JSON.stringify(Object.fromEntries(Object.entries(process.env).map(([k, v])=>[
-                            k,
-                            v
-                        ])), null, 0);
-                    const shimHeader = `const __IMPORT_META_ENV__ = Object.freeze(${envObjectLiteral});\n`;
-                    const replaced = originalContent.replace(/import\.meta\.env/g, '__IMPORT_META_ENV__');
-                    external_fs_.writeFileSync(tmpPath, `${shimHeader}${replaced}`, 'utf-8');
-                    esmImportPath = tmpPath;
+                const envCandidates = [
+                    '.env.development',
+                    '.env.local',
+                    '.env'
+                ];
+                for (const filename of envCandidates){
+                    const filePath = external_path_.join(envDir, filename);
+                    if (external_fs_.existsSync(filePath)) {
+                        external_dotenv_default().config({
+                            path: filePath,
+                            override: Boolean(options?.override),
+                            quiet: true
+                        });
+                        loadedAny = true;
+                        break;
+                    }
                 }
             } catch  {}
-            const module = await import((0, external_url_namespaceObject.pathToFileURL)(esmImportPath).href);
-            return module.default || module;
-        } catch (err) {
-            const error = err;
+            return {
+                loadedAny,
+                envDir
+            };
+        }
+        function findConfigFile(projectPath) {
+            const candidates = [
+                external_path_.join(projectPath, 'extension.config.js'),
+                external_path_.join(projectPath, 'extension.config.mjs'),
+                external_path_.join(projectPath, 'extension.config.cjs')
+            ];
+            return candidates.find((p)=>external_fs_.existsSync(p));
+        }
+        function preloadEnvFiles(projectDir) {
+            const local = preloadEnvFilesFromDir(projectDir);
+            if (local.loadedAny) return local;
+            const workspaceRoot = findNearestWorkspaceRoot(projectDir);
+            if (workspaceRoot && workspaceRoot !== projectDir) return preloadEnvFilesFromDir(workspaceRoot);
+            return local;
+        }
+        async function loadConfigFile(configPath) {
+            const absolutePath = external_path_.resolve(configPath);
+            const projectDir = external_path_.dirname(absolutePath);
+            preloadEnvFiles(projectDir);
             try {
-                if (!absolutePath.endsWith('.mjs')) {
+                if (absolutePath.endsWith('.cjs')) {
                     const requireFn = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
-                    let required;
-                    try {
-                        required = requireFn(absolutePath);
-                    } catch (requireErr) {
-                        const message = String(error?.message || '') + ' ' + String(requireErr?.message || '');
-                        const looksLikeCommonJsInEsm = message.includes('require is not defined in ES module scope') || message.includes('Cannot use import statement outside a module') || message.includes('ERR_REQUIRE_ESM');
-                        if (looksLikeCommonJsInEsm) try {
-                            required = loadCommonJsConfigWithStableDirname(absolutePath);
-                        } catch  {
-                            const tmpDir = external_fs_.mkdtempSync(external_path_.join(external_os_namespaceObject.tmpdir(), 'extension-config-'));
-                            const tmpCjsPath = external_path_.join(tmpDir, external_path_.basename(absolutePath, external_path_.extname(absolutePath)) + '.cjs');
-                            external_fs_.copyFileSync(absolutePath, tmpCjsPath);
-                            required = requireFn(tmpCjsPath);
-                        }
-                        else throw requireErr;
-                    }
+                    const required = requireFn(absolutePath);
                     return required?.default || required;
                 }
-            } catch  {}
-            try {
-                const content = external_fs_.readFileSync(absolutePath, 'utf-8');
-                return JSON.parse(content);
-            } catch (jsonErr) {
-                throw new Error(`Failed to load config file: ${configPath}\nError: ${error.message || error}`);
-            }
-        }
-    }
-    async function loadCommandConfig(projectPath, command) {
-        const configPath = findConfigFile(projectPath);
-        if (configPath) {
-            if (await isUsingExperimentalConfig(projectPath)) try {
-                const userConfig = await loadConfigFile(configPath);
-                const baseExtensions = userConfig && userConfig.extensions ? {
-                    extensions: userConfig.extensions
-                } : {};
-                const baseTranspilePackages = userConfig && Array.isArray(userConfig.transpilePackages) ? {
-                    transpilePackages: userConfig.transpilePackages
-                } : {};
-                const perCommand = userConfig && userConfig.commands && userConfig.commands[command] ? userConfig.commands[command] : {};
-                return {
-                    ...baseExtensions,
-                    ...baseTranspilePackages,
-                    ...perCommand
-                };
+                let esmImportPath = absolutePath;
+                try {
+                    const originalContent = external_fs_.readFileSync(absolutePath, 'utf-8');
+                    if (originalContent.includes('import.meta.env')) {
+                        const tmpDir = external_fs_.mkdtempSync(external_path_.join(external_os_namespaceObject.tmpdir(), 'extension-config-esm-'));
+                        const tmpPath = external_path_.join(tmpDir, external_path_.basename(absolutePath));
+                        const envObjectLiteral = JSON.stringify(Object.fromEntries(Object.entries(process.env).map(([k, v])=>[
+                                k,
+                                v
+                            ])), null, 0);
+                        const shimHeader = `const __IMPORT_META_ENV__ = Object.freeze(${envObjectLiteral});\n`;
+                        const replaced = originalContent.replace(/import\.meta\.env/g, '__IMPORT_META_ENV__');
+                        external_fs_.writeFileSync(tmpPath, `${shimHeader}${replaced}`, 'utf-8');
+                        esmImportPath = tmpPath;
+                    }
+                } catch  {}
+                const module = await import((0, external_url_namespaceObject.pathToFileURL)(esmImportPath).href);
+                return module.default || module;
             } catch (err) {
                 const error = err;
-                console.error(lib_messages.f7(configPath, error));
-                throw err;
+                try {
+                    if (!absolutePath.endsWith('.mjs')) {
+                        const requireFn = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+                        let required;
+                        try {
+                            required = requireFn(absolutePath);
+                        } catch (requireErr) {
+                            const message = String(error?.message || '') + ' ' + String(requireErr?.message || '');
+                            const looksLikeCommonJsInEsm = message.includes('require is not defined in ES module scope') || message.includes('Cannot use import statement outside a module') || message.includes('ERR_REQUIRE_ESM');
+                            if (looksLikeCommonJsInEsm) try {
+                                required = loadCommonJsConfigWithStableDirname(absolutePath);
+                            } catch  {
+                                const tmpDir = external_fs_.mkdtempSync(external_path_.join(external_os_namespaceObject.tmpdir(), 'extension-config-'));
+                                const tmpCjsPath = external_path_.join(tmpDir, external_path_.basename(absolutePath, external_path_.extname(absolutePath)) + '.cjs');
+                                external_fs_.copyFileSync(absolutePath, tmpCjsPath);
+                                required = requireFn(tmpCjsPath);
+                            }
+                            else throw requireErr;
+                        }
+                        return required?.default || required;
+                    }
+                } catch  {}
+                try {
+                    const content = external_fs_.readFileSync(absolutePath, 'utf-8');
+                    return JSON.parse(content);
+                } catch (jsonErr) {
+                    throw new Error(`Failed to load config file: ${configPath}\nError: ${error.message || error}`);
+                }
             }
         }
-        return {};
-    }
-    async function loadBrowserConfig(projectPath, browser = 'chrome') {
-        const configPath = findConfigFile(projectPath);
-        if (configPath) {
-            if (await isUsingExperimentalConfig(projectPath)) try {
-                const userConfig = await loadConfigFile(configPath);
-                if (userConfig && userConfig.browser) {
-                    const browsers = userConfig.browser;
-                    if ('chromium-based' === browser) {
-                        if (browsers['chromium-based']) return browsers['chromium-based'];
-                        if (browsers.chromium) return browsers.chromium;
-                    } else if ('gecko-based' === browser) {
-                        if (browsers['gecko-based']) return browsers['gecko-based'];
-                        if (browsers.firefox) return browsers.firefox;
-                    } else {
-                        const direct = browsers[browser];
-                        if (direct) return direct;
+        async function loadCommandConfig(projectPath, command) {
+            const configPath = findConfigFile(projectPath);
+            if (configPath) {
+                if (await isUsingExperimentalConfig(projectPath)) try {
+                    const userConfig = await loadConfigFile(configPath);
+                    const baseExtensions = userConfig && userConfig.extensions ? {
+                        extensions: userConfig.extensions
+                    } : {};
+                    const baseTranspilePackages = userConfig && Array.isArray(userConfig.transpilePackages) ? {
+                        transpilePackages: userConfig.transpilePackages
+                    } : {};
+                    const perCommand = userConfig && userConfig.commands && userConfig.commands[command] ? userConfig.commands[command] : {};
+                    return {
+                        ...baseExtensions,
+                        ...baseTranspilePackages,
+                        ...perCommand
+                    };
+                } catch (err) {
+                    const error = err;
+                    console.error(lib_messages.f7(configPath, error));
+                    throw err;
+                }
+            }
+            return {};
+        }
+        async function loadBrowserConfig(projectPath, browser = 'chrome') {
+            const configPath = findConfigFile(projectPath);
+            if (configPath) {
+                if (await isUsingExperimentalConfig(projectPath)) try {
+                    const userConfig = await loadConfigFile(configPath);
+                    if (userConfig && userConfig.browser) {
+                        const browsers = userConfig.browser;
+                        if ('chromium-based' === browser) {
+                            if (browsers['chromium-based']) return browsers['chromium-based'];
+                            if (browsers.chromium) return browsers.chromium;
+                        } else if ('gecko-based' === browser) {
+                            if (browsers['gecko-based']) return browsers['gecko-based'];
+                            if (browsers.firefox) return browsers.firefox;
+                        } else {
+                            const direct = browsers[browser];
+                            if (direct) return direct;
+                        }
                     }
+                } catch (err) {
+                    const error = err;
+                    console.error(lib_messages.f7(configPath, error));
+                    throw err;
                 }
-            } catch (err) {
-                const error = err;
-                console.error(lib_messages.f7(configPath, error));
-                throw err;
             }
+            return {
+                browser: browser || 'chrome'
+            };
         }
-        return {
-            browser: browser || 'chrome'
-        };
-    }
-    let userMessageDelivered = false;
-    async function isUsingExperimentalConfig(projectPath) {
-        const configPath = findConfigFile(projectPath);
-        if (configPath) {
-            if (!userMessageDelivered) {
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(lib_messages.BX('extension.config.js'));
-                userMessageDelivered = true;
+        let userMessageDelivered = false;
+        async function isUsingExperimentalConfig(projectPath) {
+            const configPath = findConfigFile(projectPath);
+            if (configPath) {
+                if (!userMessageDelivered) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(lib_messages.BX('extension.config.js'));
+                    userMessageDelivered = true;
+                }
+                return true;
             }
-            return true;
+            return false;
         }
-        return false;
-    }
-    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(lib_messages.H3(duplicates, userPackageJsonPath));
-                process.exit(1);
+        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(lib_messages.H3(duplicates, userPackageJsonPath));
+                    process.exit(1);
+                }
+            } catch (error) {
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(error);
             }
-        } catch (error) {
-            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(error);
         }
-    }
-    function asAbsolute(p) {
-        return external_path_.isAbsolute(p) ? p : external_path_.resolve(p);
-    }
-    function getDirs(struct) {
-        const manifestDir = asAbsolute(external_path_.dirname(struct.manifestPath));
-        const packageJsonDir = asAbsolute(struct.packageJsonPath ? external_path_.dirname(struct.packageJsonPath) : manifestDir);
-        return {
-            manifestDir,
-            packageJsonDir
-        };
-    }
-    function normalizeBrowser(browser, chromiumBinary, geckoBinary) {
-        const requested = String(browser || '');
-        if (chromiumBinary) {
-            if (!requested || 'chromium-based' === requested) return 'chromium-based';
-            if ('chromium' === requested) return 'chromium';
-            if ('edge' === requested) return 'edge';
-            if ('chrome' === requested) return 'chrome';
-        }
-        if (geckoBinary) {
-            if (!requested || 'gecko-based' === requested || 'firefox-based' === requested) return 'gecko-based';
-            if ('firefox' === requested) return 'firefox';
-        }
-        switch(requested){
-            case 'chrome':
-                return 'chrome';
-            case 'edge':
-                return 'edge';
-            case 'chromium':
-                return 'chromium';
-            case 'chromium-based':
-                return 'chromium-based';
-            case 'firefox':
-                return 'firefox';
-            case 'gecko-based':
-            case 'firefox-based':
-                return 'gecko-based';
-            default:
-                return browser || 'chrome';
+        function asAbsolute(p) {
+            return external_path_.isAbsolute(p) ? p : external_path_.resolve(p);
         }
-    }
-    function getDistPath(packageJsonDir, browser) {
-        return asAbsolute(external_path_.join(packageJsonDir, 'dist', browser));
-    }
-    function computePreviewOutputPath(struct, browser, explicitOutputPath) {
-        const { manifestDir, packageJsonDir } = getDirs(struct);
-        if (explicitOutputPath) return asAbsolute(explicitOutputPath);
-        if (struct.packageJsonPath) {
-            const distDir = getDistPath(packageJsonDir, browser);
-            try {
-                if (external_fs_.existsSync(external_path_.join(distDir, 'manifest.json'))) return distDir;
-            } catch  {}
+        function getDirs(struct) {
+            const manifestDir = asAbsolute(external_path_.dirname(struct.manifestPath));
+            const packageJsonDir = asAbsolute(struct.packageJsonPath ? external_path_.dirname(struct.packageJsonPath) : manifestDir);
+            return {
+                manifestDir,
+                packageJsonDir
+            };
         }
-        return manifestDir;
-    }
-    function devtoolsEngineFor(browser) {
-        switch(browser){
-            case 'chrome':
-                return 'chrome';
-            case 'edge':
-                return 'edge';
-            case 'chromium':
-            case 'chromium-based':
-                return 'chromium';
-            case 'firefox':
-            case 'gecko-based':
-                return 'firefox';
-            default:
-                return 'chrome';
+        function normalizeBrowser(browser, chromiumBinary, geckoBinary) {
+            const requested = String(browser || '');
+            if (chromiumBinary) {
+                if (!requested || 'chromium-based' === requested) return 'chromium-based';
+                if ('chromium' === requested) return 'chromium';
+                if ('edge' === requested) return 'edge';
+                if ('chrome' === requested) return 'chrome';
+            }
+            if (geckoBinary) {
+                if (!requested || 'gecko-based' === requested || 'firefox-based' === requested) return 'gecko-based';
+                if ('firefox' === requested) return 'firefox';
+            }
+            switch(requested){
+                case 'chrome':
+                    return 'chrome';
+                case 'edge':
+                    return 'edge';
+                case 'chromium':
+                    return 'chromium';
+                case 'chromium-based':
+                    return 'chromium-based';
+                case 'firefox':
+                    return 'firefox';
+                case 'gecko-based':
+                case 'firefox-based':
+                    return 'gecko-based';
+                default:
+                    return browser || 'chrome';
+            }
         }
-    }
-    function _define_property(obj, key, value) {
-        if (key in obj) Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-        else obj[key] = value;
-        return obj;
-    }
-    function nowISO() {
-        return new Date().toISOString();
-    }
-    function createRunId() {
-        return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-    }
-    function plugin_playwright_ensureDirSync(dirPath) {
-        try {
-            external_fs_.mkdirSync(dirPath, {
-                recursive: true
+        function getDistPath(packageJsonDir, browser) {
+            return asAbsolute(external_path_.join(packageJsonDir, 'dist', browser));
+        }
+        function computePreviewOutputPath(struct, browser, explicitOutputPath) {
+            const { manifestDir, packageJsonDir } = getDirs(struct);
+            if (explicitOutputPath) return asAbsolute(explicitOutputPath);
+            if (struct.packageJsonPath) {
+                const distDir = getDistPath(packageJsonDir, browser);
+                try {
+                    if (external_fs_.existsSync(external_path_.join(distDir, 'manifest.json'))) return distDir;
+                } catch  {}
+            }
+            return manifestDir;
+        }
+        function devtoolsEngineFor(browser) {
+            switch(browser){
+                case 'chrome':
+                    return 'chrome';
+                case 'edge':
+                    return 'edge';
+                case 'chromium':
+                case 'chromium-based':
+                    return 'chromium';
+                case 'firefox':
+                case 'gecko-based':
+                    return 'firefox';
+                default:
+                    return 'chrome';
+            }
+        }
+        function _define_property(obj, key, value) {
+            if (key in obj) Object.defineProperty(obj, key, {
+                value: value,
+                enumerable: true,
+                configurable: true,
+                writable: true
             });
-        } catch  {}
-    }
-    function writeJsonAtomic(filePath, value) {
-        try {
-            const tmpPath = `${filePath}.tmp-${process.pid}`;
-            external_fs_.writeFileSync(tmpPath, JSON.stringify(value, null, 2) + '\n', 'utf-8');
-            external_fs_.renameSync(tmpPath, filePath);
-        } catch  {}
-    }
-    function getPlaywrightMetadataDir(packageJsonDir, browser) {
-        return asAbsolute(external_path_.join(packageJsonDir, 'dist', 'extension-js', browser));
-    }
-    function createPlaywrightMetadataWriter(options) {
-        const metadataDir = getPlaywrightMetadataDir(options.packageJsonDir, options.browser);
-        const readyPath = asAbsolute(external_path_.join(metadataDir, 'ready.json'));
-        const eventsPath = asAbsolute(external_path_.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) {
-            plugin_playwright_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);
+            else obj[key] = value;
+            return obj;
+        }
+        function nowISO() {
+            return new Date().toISOString();
+        }
+        function createRunId() {
+            return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
         }
-        function appendEvent(event) {
-            plugin_playwright_ensureDirSync(metadataDir);
+        function plugin_playwright_ensureDirSync(dirPath) {
             try {
-                external_fs_.appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, 'utf-8');
+                external_fs_.mkdirSync(dirPath, {
+                    recursive: true
+                });
             } catch  {}
         }
-        return {
-            metadataDir,
-            readyPath,
-            eventsPath,
-            writeStarting () {
-                writeReady('starting');
-            },
-            writeReady (compiledAt) {
-                writeReady('ready', {
-                    compiledAt: compiledAt || nowISO()
-                });
-            },
-            writeError (code, message, errors) {
-                writeReady('error', {
-                    code,
-                    message,
-                    errors: Array.isArray(errors) ? errors : [],
-                    compiledAt: null
-                });
-            },
-            appendEvent
-        };
-    }
-    class PlaywrightPlugin {
-        apply(compiler) {
-            this.writer.writeStarting();
-            compiler.hooks.compile.tap(PlaywrightPlugin.name, ()=>{
-                this.writer.appendEvent({
-                    type: 'compile_start',
+        function writeJsonAtomic(filePath, value) {
+            try {
+                const tmpPath = `${filePath}.tmp-${process.pid}`;
+                external_fs_.writeFileSync(tmpPath, JSON.stringify(value, null, 2) + '\n', 'utf-8');
+                external_fs_.renameSync(tmpPath, filePath);
+            } catch  {}
+        }
+        function getPlaywrightMetadataDir(packageJsonDir, browser) {
+            return asAbsolute(external_path_.join(packageJsonDir, 'dist', 'extension-js', browser));
+        }
+        function createPlaywrightMetadataWriter(options) {
+            const metadataDir = getPlaywrightMetadataDir(options.packageJsonDir, options.browser);
+            const readyPath = asAbsolute(external_path_.join(metadataDir, 'ready.json'));
+            const eventsPath = asAbsolute(external_path_.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) {
+                plugin_playwright_ensureDirSync(metadataDir);
+                const payload = {
+                    ...base,
+                    status,
+                    pid: process.pid,
                     ts: nowISO(),
-                    command: this.command,
-                    browser: this.browser
+                    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) {
+                plugin_playwright_ensureDirSync(metadataDir);
+                try {
+                    external_fs_.appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, 'utf-8');
+                } catch  {}
+            }
+            return {
+                metadataDir,
+                readyPath,
+                eventsPath,
+                writeStarting () {
+                    writeReady('starting');
+                },
+                writeReady (compiledAt) {
+                    writeReady('ready', {
+                        compiledAt: compiledAt || nowISO()
+                    });
+                },
+                writeError (code, message, errors) {
+                    writeReady('error', {
+                        code,
+                        message,
+                        errors: Array.isArray(errors) ? errors : [],
+                        compiledAt: null
+                    });
+                },
+                appendEvent
+            };
+        }
+        class PlaywrightPlugin {
+            apply(compiler) {
+                this.writer.writeStarting();
+                compiler.hooks.compile.tap(PlaywrightPlugin.name, ()=>{
+                    this.writer.appendEvent({
+                        type: 'compile_start',
+                        ts: nowISO(),
+                        command: this.command,
+                        browser: this.browser
+                    });
                 });
-            });
-            compiler.hooks.done.tap(PlaywrightPlugin.name, (stats)=>{
-                const durationMs = Number((stats?.compilation?.endTime || 0) - (stats?.compilation?.startTime || 0));
-                const hasErrors = Boolean(stats?.hasErrors?.());
-                const errorsCount = Number(Array.isArray(stats?.toJson?.({
-                    all: false,
-                    errors: true
-                })?.errors) ? stats.toJson({
-                    all: false,
-                    errors: true
-                }).errors.length : 0);
-                if (hasErrors) {
+                compiler.hooks.done.tap(PlaywrightPlugin.name, (stats)=>{
+                    const durationMs = Number((stats?.compilation?.endTime || 0) - (stats?.compilation?.startTime || 0));
+                    const hasErrors = Boolean(stats?.hasErrors?.());
+                    const errorsCount = Number(Array.isArray(stats?.toJson?.({
+                        all: false,
+                        errors: true
+                    })?.errors) ? stats.toJson({
+                        all: false,
+                        errors: true
+                    }).errors.length : 0);
+                    if (hasErrors) {
+                        this.writer.appendEvent({
+                            type: 'compile_error',
+                            ts: nowISO(),
+                            command: this.command,
+                            browser: this.browser,
+                            durationMs: Number.isFinite(durationMs) ? durationMs : void 0,
+                            errorCount: Number.isFinite(errorsCount) ? errorsCount : 1
+                        });
+                        this.writer.writeError('compile_error', 'Compilation failed', [
+                            `errors: ${String(errorsCount || 1)}`
+                        ]);
+                        return;
+                    }
                     this.writer.appendEvent({
-                        type: 'compile_error',
+                        type: 'compile_success',
                         ts: nowISO(),
                         command: this.command,
                         browser: this.browser,
                         durationMs: Number.isFinite(durationMs) ? durationMs : void 0,
-                        errorCount: Number.isFinite(errorsCount) ? errorsCount : 1
+                        errorCount: 0
                     });
-                    this.writer.writeError('compile_error', 'Compilation failed', [
-                        `errors: ${String(errorsCount || 1)}`
-                    ]);
-                    return;
-                }
-                this.writer.appendEvent({
-                    type: 'compile_success',
-                    ts: nowISO(),
-                    command: this.command,
-                    browser: this.browser,
-                    durationMs: Number.isFinite(durationMs) ? durationMs : void 0,
-                    errorCount: 0
+                    this.writer.writeReady(nowISO());
                 });
-                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
+                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));
                 });
-                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(),
+                compiler.hooks.watchClose.tap(PlaywrightPlugin.name, ()=>{
+                    this.writer.appendEvent({
+                        type: 'shutdown',
+                        ts: nowISO(),
+                        command: this.command,
+                        browser: this.browser
+                    });
+                });
+            }
+            constructor(options){
+                _define_property(this, "writer", void 0);
+                _define_property(this, "command", void 0);
+                _define_property(this, "browser", void 0);
+                this.browser = String(options.browser || 'chromium');
+                this.command = options.command || ('development' === options.mode ? 'dev' : 'start');
+                this.writer = createPlaywrightMetadataWriter({
+                    packageJsonDir: options.packageJsonDir,
+                    browser: this.browser,
                     command: this.command,
-                    browser: this.browser
+                    distPath: options.outputPath,
+                    manifestPath: options.manifestPath,
+                    port: options.port
                 });
-            });
-        }
-        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');
-    function sanitize(obj) {
-        return Object.fromEntries(Object.entries(obj || {}).filter(([, value])=>void 0 !== value));
-    }
-    const external_extension_from_store_namespaceObject = require("extension-from-store");
-    function isDir(p) {
-        try {
-            return external_fs_.existsSync(p) && external_fs_.statSync(p).isDirectory();
-        } catch  {
-            return false;
-        }
-    }
-    function isFile(p) {
-        try {
-            return external_fs_.existsSync(p) && external_fs_.statSync(p).isFile();
-        } catch  {
-            return false;
+            }
         }
-    }
-    function toAbs(projectRoot, p) {
-        return external_path_.isAbsolute(p) ? p : external_path_.resolve(projectRoot, p);
-    }
-    function isValidExtensionRoot(dir) {
-        if (!isDir(dir)) return false;
-        return isFile(external_path_.join(dir, 'manifest.json'));
-    }
-    function normalizeCompanionConfig(config) {
-        const explicitPaths = [];
-        let scanDir;
-        if (Array.isArray(config)) explicitPaths.push(...config.filter((p)=>'string' == typeof p));
-        else if (config && 'object' == typeof config) {
-            if (Array.isArray(config.paths)) explicitPaths.push(...config.paths.filter((p)=>'string' == typeof p));
-            if ('string' == typeof config.dir && config.dir.trim().length > 0) scanDir = config.dir.trim();
-        }
-        return {
-            dir: scanDir,
-            paths: explicitPaths
-        };
-    }
-    function isPathLike(value) {
-        if (external_path_.isAbsolute(value)) return true;
-        if (value.startsWith('./') || value.startsWith('../')) return true;
-        return value.includes('/') || value.includes('\\');
-    }
-    function isSubpathOf(parent, child) {
-        const rel = external_path_.relative(parent, child);
-        return '' !== rel && !rel.startsWith('..') && !external_path_.isAbsolute(rel);
-    }
-    function getBrowserFolder(browser) {
-        if ('firefox' === browser || 'gecko-based' === browser || 'firefox-based' === browser) return 'firefox';
-        if ('edge' === browser) return 'edge';
-        return 'chrome';
-    }
-    function parseChromeWebStoreId(url) {
-        if ('chromewebstore.google.com' !== url.hostname) return null;
-        const match = url.pathname.match(/\/([a-z]{32})(?:\/|$)/i);
-        return match ? match[1] : null;
-    }
-    function parseEdgeAddonsId(url) {
-        if ('microsoftedge.microsoft.com' !== url.hostname) return null;
-        const match = url.pathname.match(/\/([a-z]{32})(?:\/|$)/i);
-        return match ? match[1] : null;
-    }
-    function parseAmoSlug(url) {
-        if ('addons.mozilla.org' !== url.hostname) return null;
-        const match = url.pathname.match(/\/addon\/([^/]+)(?:\/|$)/i);
-        return match ? match[1] : null;
-    }
-    function parseStoreUrl(raw) {
-        let url;
-        try {
-            url = new URL(raw);
-        } catch  {
-            return null;
+        _define_property(PlaywrightPlugin, "name", 'plugin-playwright');
+        function sanitize(obj) {
+            return Object.fromEntries(Object.entries(obj || {}).filter(([, value])=>void 0 !== value));
         }
-        const chromeId = parseChromeWebStoreId(url);
-        if (chromeId) return {
-            browser: 'chrome',
-            id: chromeId
-        };
-        const edgeId = parseEdgeAddonsId(url);
-        if (edgeId) return {
-            browser: 'edge',
-            id: edgeId
-        };
-        const amoSlug = parseAmoSlug(url);
-        if (amoSlug) return {
-            browser: 'firefox',
-            id: amoSlug
-        };
-        return null;
-    }
-    function ensurePathsUnderExtensions(projectRoot, paths) {
-        const extensionsRoot = external_path_.resolve(projectRoot, 'extensions');
-        return paths.map((p)=>{
-            const abs = toAbs(projectRoot, p);
-            if (abs !== extensionsRoot && !isSubpathOf(extensionsRoot, abs) && external_path_.resolve(abs) !== extensionsRoot) throw new Error(`Companion extensions must be inside ${extensionsRoot}.\nInvalid path: ${abs}`);
-            return abs;
-        });
-    }
-    function findExtensionRoots(dir, maxDepth = 3) {
-        const found = [];
-        function walk(current, depth) {
-            if (depth > maxDepth) return;
-            if (!isDir(current)) return;
-            if (isValidExtensionRoot(current)) return void found.push(current);
-            let entries = [];
+        const external_extension_from_store_namespaceObject = require("extension-from-store");
+        function isDir(p) {
             try {
-                entries = external_fs_.readdirSync(current, {
-                    withFileTypes: true
-                });
+                return external_fs_.existsSync(p) && external_fs_.statSync(p).isDirectory();
             } catch  {
-                return;
+                return false;
             }
-            for (const ent of entries)if (ent.isDirectory()) {
-                if (!ent.name.startsWith('.')) walk(external_path_.join(current, ent.name), depth + 1);
+        }
+        function isFile(p) {
+            try {
+                return external_fs_.existsSync(p) && external_fs_.statSync(p).isFile();
+            } catch  {
+                return false;
             }
         }
-        walk(dir, 0);
-        return found;
-    }
-    async function runExtensionFromStore(url, outDir) {
-        const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-        await (0, external_extension_from_store_namespaceObject.fetchExtensionFromStore)(url, {
-            outDir,
-            extract: true,
-            logger: isAuthor ? {
-                onInfo: (message)=>console.log(message),
-                onWarn: (message)=>console.warn(message),
-                onError: (message, error)=>console.error(message, error)
-            } : void 0
-        });
-    }
-    async function resolveStoreExtensionToPath(opts) {
-        const { projectRoot, storeUrl, browser, id } = opts;
-        const extensionsRoot = external_path_.resolve(projectRoot, 'extensions');
-        const targetRoot = external_path_.join(extensionsRoot, browser, id);
-        const manifestPath = external_path_.join(targetRoot, 'manifest.json');
-        if (isFile(manifestPath)) return targetRoot;
-        await runExtensionFromStore(storeUrl, external_path_.join(extensionsRoot, browser));
-        const candidates = findExtensionRoots(external_path_.join(extensionsRoot, browser));
-        let selected;
-        if (1 === candidates.length) selected = candidates[0];
-        else if (candidates.length > 1) {
-            const directMatch = candidates.find((c)=>external_path_.basename(c) === id);
-            const versionedMatch = candidates.find((c)=>external_path_.basename(c).startsWith(`${id}@`));
-            if (directMatch) selected = directMatch;
-            else if (versionedMatch) selected = versionedMatch;
-        }
-        if (!selected) throw new Error(`Could not locate an unpacked extension from ${storeUrl}.`);
-        external_fs_.mkdirSync(external_path_.dirname(targetRoot), {
-            recursive: true
-        });
-        if (external_path_.basename(selected).startsWith(`${id}@`)) external_fs_.renameSync(selected, targetRoot);
-        return targetRoot;
-    }
-    async function resolveCompanionExtensionsConfig(opts) {
-        const { projectRoot, browser, config } = opts;
-        if (!config) return;
-        const normalized = normalizeCompanionConfig(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;
+        function toAbs(projectRoot, p) {
+            return external_path_.isAbsolute(p) ? p : external_path_.resolve(projectRoot, p);
+        }
+        function isValidExtensionRoot(dir) {
+            if (!isDir(dir)) return false;
+            return isFile(external_path_.join(dir, 'manifest.json'));
+        }
+        function normalizeCompanionConfig(config) {
+            const explicitPaths = [];
+            let scanDir;
+            if (Array.isArray(config)) explicitPaths.push(...config.filter((p)=>'string' == typeof p));
+            else if (config && 'object' == typeof config) {
+                if (Array.isArray(config.paths)) explicitPaths.push(...config.paths.filter((p)=>'string' == typeof p));
+                if ('string' == typeof config.dir && config.dir.trim().length > 0) scanDir = config.dir.trim();
             }
-            if (isPathLike(entry)) localPaths.push(entry);
+            return {
+                dir: scanDir,
+                paths: explicitPaths
+            };
         }
-        if (localPaths.length > 0) {
-            const absLocalPaths = ensurePathsUnderExtensions(projectRoot, localPaths);
-            resolvedPaths.push(...absLocalPaths);
+        function isPathLike(value) {
+            if (external_path_.isAbsolute(value)) return true;
+            if (value.startsWith('./') || value.startsWith('../')) return true;
+            return value.includes('/') || value.includes('\\');
+        }
+        function isSubpathOf(parent, child) {
+            const rel = external_path_.relative(parent, child);
+            return '' !== rel && !rel.startsWith('..') && !external_path_.isAbsolute(rel);
+        }
+        function getBrowserFolder(browser) {
+            if ('firefox' === browser || 'gecko-based' === browser || 'firefox-based' === browser) return 'firefox';
+            if ('edge' === browser) return 'edge';
+            return 'chrome';
+        }
+        function parseChromeWebStoreId(url) {
+            if ('chromewebstore.google.com' !== url.hostname) return null;
+            const match = url.pathname.match(/\/([a-z]{32})(?:\/|$)/i);
+            return match ? match[1] : null;
+        }
+        function parseEdgeAddonsId(url) {
+            if ('microsoftedge.microsoft.com' !== url.hostname) return null;
+            const match = url.pathname.match(/\/([a-z]{32})(?:\/|$)/i);
+            return match ? match[1] : null;
+        }
+        function parseAmoSlug(url) {
+            if ('addons.mozilla.org' !== url.hostname) return null;
+            const match = url.pathname.match(/\/addon\/([^/]+)(?:\/|$)/i);
+            return match ? match[1] : null;
+        }
+        function parseStoreUrl(raw) {
+            let url;
+            try {
+                url = new URL(raw);
+            } catch  {
+                return null;
+            }
+            const chromeId = parseChromeWebStoreId(url);
+            if (chromeId) return {
+                browser: 'chrome',
+                id: chromeId
+            };
+            const edgeId = parseEdgeAddonsId(url);
+            if (edgeId) return {
+                browser: 'edge',
+                id: edgeId
+            };
+            const amoSlug = parseAmoSlug(url);
+            if (amoSlug) return {
+                browser: 'firefox',
+                id: amoSlug
+            };
+            return null;
         }
-        const output = {};
-        if ('string' == typeof normalized.dir) {
-            const absDir = toAbs(projectRoot, normalized.dir);
+        function ensurePathsUnderExtensions(projectRoot, paths) {
             const extensionsRoot = external_path_.resolve(projectRoot, 'extensions');
-            if (absDir !== extensionsRoot && !isSubpathOf(extensionsRoot, absDir)) throw new Error(`extensions.dir must be inside ${extensionsRoot}.\nInvalid dir: ${absDir}`);
-            output.dir = normalized.dir;
+            return paths.map((p)=>{
+                const abs = toAbs(projectRoot, p);
+                if (abs !== extensionsRoot && !isSubpathOf(extensionsRoot, abs) && external_path_.resolve(abs) !== extensionsRoot) throw new Error(`Companion extensions must be inside ${extensionsRoot}.\nInvalid path: ${abs}`);
+                return abs;
+            });
         }
-        if (resolvedPaths.length > 0) output.paths = resolvedPaths;
-        return output;
-    }
-    function resolveCompanionExtensionDirs(opts) {
-        const { projectRoot, config } = opts;
-        const normalized = normalizeCompanionConfig(config);
-        const explicitPaths = normalized.paths;
-        const scanDir = normalized.dir;
-        const found = [];
-        for (const p of explicitPaths){
-            const abs = toAbs(projectRoot, p);
-            if (isValidExtensionRoot(abs)) found.push(abs);
-        }
-        if (scanDir) {
-            const absScan = toAbs(projectRoot, scanDir);
-            if (isDir(absScan)) {
+        function findExtensionRoots(dir, maxDepth = 3) {
+            const found = [];
+            function walk(current, depth) {
+                if (depth > maxDepth) return;
+                if (!isDir(current)) return;
+                if (isValidExtensionRoot(current)) return void found.push(current);
                 let entries = [];
                 try {
-                    entries = external_fs_.readdirSync(absScan, {
+                    entries = external_fs_.readdirSync(current, {
                         withFileTypes: true
                     });
                 } catch  {
-                    entries = [];
+                    return;
+                }
+                for (const ent of entries)if (ent.isDirectory()) {
+                    if (!ent.name.startsWith('.')) walk(external_path_.join(current, ent.name), depth + 1);
+                }
+            }
+            walk(dir, 0);
+            return found;
+        }
+        async function runExtensionFromStore(url, outDir) {
+            const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+            await (0, external_extension_from_store_namespaceObject.fetchExtensionFromStore)(url, {
+                outDir,
+                extract: true,
+                logger: isAuthor ? {
+                    onInfo: (message)=>console.log(message),
+                    onWarn: (message)=>console.warn(message),
+                    onError: (message, error)=>console.error(message, error)
+                } : void 0
+            });
+        }
+        async function resolveStoreExtensionToPath(opts) {
+            const { projectRoot, storeUrl, browser, id } = opts;
+            const extensionsRoot = external_path_.resolve(projectRoot, 'extensions');
+            const targetRoot = external_path_.join(extensionsRoot, browser, id);
+            const manifestPath = external_path_.join(targetRoot, 'manifest.json');
+            if (isFile(manifestPath)) return targetRoot;
+            await runExtensionFromStore(storeUrl, external_path_.join(extensionsRoot, browser));
+            const candidates = findExtensionRoots(external_path_.join(extensionsRoot, browser));
+            let selected;
+            if (1 === candidates.length) selected = candidates[0];
+            else if (candidates.length > 1) {
+                const directMatch = candidates.find((c)=>external_path_.basename(c) === id);
+                const versionedMatch = candidates.find((c)=>external_path_.basename(c).startsWith(`${id}@`));
+                if (directMatch) selected = directMatch;
+                else if (versionedMatch) selected = versionedMatch;
+            }
+            if (!selected) throw new Error(`Could not locate an unpacked extension from ${storeUrl}.`);
+            external_fs_.mkdirSync(external_path_.dirname(targetRoot), {
+                recursive: true
+            });
+            if (external_path_.basename(selected).startsWith(`${id}@`)) external_fs_.renameSync(selected, targetRoot);
+            return targetRoot;
+        }
+        async function resolveCompanionExtensionsConfig(opts) {
+            const { projectRoot, browser, config } = opts;
+            if (!config) return;
+            const normalized = normalizeCompanionConfig(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;
                 }
-                const scanOneLevel = (rootDir)=>{
-                    let dirEntries = [];
+                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 = toAbs(projectRoot, normalized.dir);
+                const extensionsRoot = external_path_.resolve(projectRoot, 'extensions');
+                if (absDir !== extensionsRoot && !isSubpathOf(extensionsRoot, absDir)) throw new Error(`extensions.dir must be inside ${extensionsRoot}.\nInvalid dir: ${absDir}`);
+                output.dir = normalized.dir;
+            }
+            if (resolvedPaths.length > 0) output.paths = resolvedPaths;
+            return output;
+        }
+        function resolveCompanionExtensionDirs(opts) {
+            const { projectRoot, config } = opts;
+            const normalized = normalizeCompanionConfig(config);
+            const explicitPaths = normalized.paths;
+            const scanDir = normalized.dir;
+            const found = [];
+            for (const p of explicitPaths){
+                const abs = toAbs(projectRoot, p);
+                if (isValidExtensionRoot(abs)) found.push(abs);
+            }
+            if (scanDir) {
+                const absScan = toAbs(projectRoot, scanDir);
+                if (isDir(absScan)) {
+                    let entries = [];
                     try {
-                        dirEntries = external_fs_.readdirSync(rootDir, {
+                        entries = external_fs_.readdirSync(absScan, {
                             withFileTypes: true
                         });
                     } catch  {
-                        dirEntries = [];
+                        entries = [];
                     }
-                    for (const ent of dirEntries){
+                    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 (isValidExtensionRoot(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 candidate = external_path_.join(rootDir, ent.name);
-                        if (isValidExtensionRoot(candidate)) found.push(candidate);
+                        const browserDir = external_path_.join(absScan, ent.name);
+                        scanOneLevel(browserDir);
                     }
-                };
-                scanOneLevel(absScan);
-                if ('extensions' === external_path_.basename(absScan)) for (const ent of entries){
-                    if (!ent.isDirectory()) continue;
-                    if (ent.name.startsWith('.')) continue;
-                    const browserDir = external_path_.join(absScan, ent.name);
-                    scanOneLevel(browserDir);
                 }
             }
+            const unique = [];
+            const seen = new Set();
+            for (const p of found)if (!seen.has(p)) {
+                seen.add(p);
+                unique.push(p);
+            }
+            return unique;
+        }
+        const external_browser_extension_manifest_fields_namespaceObject = require("browser-extension-manifest-fields");
+        function isUnderPublicDir(entry, projectRoot, publicDir) {
+            if (!entry) return false;
+            const normalizedEntry = String(entry);
+            const candidate = external_path_default().isAbsolute(normalizedEntry) ? normalizedEntry : external_path_default().join(projectRoot, normalizedEntry);
+            const rel = external_path_default().relative(publicDir, candidate);
+            return Boolean(rel && !rel.startsWith('..') && !external_path_default().isAbsolute(rel));
+        }
+        function filterPublicEntrypoints(list, projectRoot, publicDir) {
+            const next = {};
+            for (const [key, value] of Object.entries(list || {})){
+                if (Array.isArray(value)) {
+                    const filtered = value.filter((entry)=>!isUnderPublicDir(String(entry), projectRoot, publicDir));
+                    if (filtered.length > 0) next[key] = filtered;
+                    continue;
+                }
+                if ('string' == typeof value) {
+                    if (!isUnderPublicDir(value, projectRoot, publicDir)) next[key] = value;
+                    continue;
+                }
+            }
+            return next;
         }
-        const unique = [];
-        const seen = new Set();
-        for (const p of found)if (!seen.has(p)) {
-            seen.add(p);
-            unique.push(p);
+        function getSpecialFoldersDataForProjectRoot(projectRoot) {
+            const publicDir = external_path_default().join(projectRoot, 'public');
+            const data = (0, external_browser_extension_manifest_fields_namespaceObject.getSpecialFoldersData)({
+                manifestPath: external_path_default().join(projectRoot, 'package.json')
+            });
+            return finalizeSpecialFoldersData(data, projectRoot, publicDir);
+        }
+        function finalizeSpecialFoldersData(data, projectRoot, publicDir) {
+            return {
+                ...data,
+                pages: filterPublicEntrypoints(data.pages, projectRoot, publicDir),
+                scripts: filterPublicEntrypoints(data.scripts, projectRoot, publicDir),
+                extensions: {
+                    dir: './extensions'
+                }
+            };
         }
-        return unique;
-    }
-    const external_browser_extension_manifest_fields_namespaceObject = require("browser-extension-manifest-fields");
-    function isUnderPublicDir(entry, projectRoot, publicDir) {
-        if (!entry) return false;
-        const normalizedEntry = String(entry);
-        const candidate = external_path_default().isAbsolute(normalizedEntry) ? normalizedEntry : external_path_default().join(projectRoot, normalizedEntry);
-        const rel = external_path_default().relative(publicDir, candidate);
-        return Boolean(rel && !rel.startsWith('..') && !external_path_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;
+        function hasNewTabOverride(extensionDir) {
+            const manifestPath = external_path_.join(extensionDir, 'manifest.json');
+            if (!external_fs_.existsSync(manifestPath)) return false;
+            try {
+                const raw = external_fs_.readFileSync(manifestPath, 'utf-8');
+                const manifest = JSON.parse(raw);
+                const newtab = manifest?.chrome_url_overrides?.newtab;
+                return 'string' == typeof newtab && newtab.trim().length > 0;
+            } catch  {
+                return false;
             }
         }
-        return next;
-    }
-    function getSpecialFoldersDataForProjectRoot(projectRoot) {
-        const publicDir = external_path_default().join(projectRoot, 'public');
-        const data = (0, external_browser_extension_manifest_fields_namespaceObject.getSpecialFoldersData)({
-            manifestPath: external_path_default().join(projectRoot, 'package.json')
-        });
-        return finalizeSpecialFoldersData(data, projectRoot, publicDir);
-    }
-    function finalizeSpecialFoldersData(data, projectRoot, publicDir) {
-        return {
-            ...data,
-            pages: filterPublicEntrypoints(data.pages, projectRoot, publicDir),
-            scripts: filterPublicEntrypoints(data.scripts, projectRoot, publicDir),
-            extensions: {
-                dir: './extensions'
+        function resolveBuiltInExtensionForBrowser(input) {
+            const engine = devtoolsEngineFor(input.browser);
+            const packageRelativeCandidates = [
+                external_path_.join('dist', input.packageName, engine)
+            ];
+            const normalizedBaseDir = external_path_.normalize(input.baseDir);
+            const parentName = external_path_.basename(external_path_.dirname(normalizedBaseDir));
+            const baseName = external_path_.basename(normalizedBaseDir);
+            if ('programs' === parentName && 'develop' === baseName) packageRelativeCandidates.push(external_path_.join('..', '..', 'extensions', input.packageName, 'dist', engine));
+            for (const rel of packageRelativeCandidates){
+                const candidate = external_path_.resolve(input.baseDir, rel);
+                if (external_fs_.existsSync(candidate)) return candidate;
             }
-        };
-    }
-    function hasNewTabOverride(extensionDir) {
-        const manifestPath = external_path_.join(extensionDir, 'manifest.json');
-        if (!external_fs_.existsSync(manifestPath)) return false;
-        try {
-            const raw = external_fs_.readFileSync(manifestPath, 'utf-8');
-            const manifest = JSON.parse(raw);
-            const newtab = manifest?.chrome_url_overrides?.newtab;
-            return 'string' == typeof newtab && newtab.trim().length > 0;
-        } catch  {
-            return false;
         }
-    }
-    function resolveBuiltInExtensionForBrowser(input) {
-        const engine = devtoolsEngineFor(input.browser);
-        const packageRelativeCandidates = [
-            external_path_.join('dist', input.packageName, engine)
-        ];
-        const normalizedBaseDir = external_path_.normalize(input.baseDir);
-        const parentName = external_path_.basename(external_path_.dirname(normalizedBaseDir));
-        const baseName = external_path_.basename(normalizedBaseDir);
-        if ('programs' === parentName && 'develop' === baseName) packageRelativeCandidates.push(external_path_.join('..', '..', 'extensions', input.packageName, 'dist', engine));
-        for (const rel of packageRelativeCandidates){
-            const candidate = external_path_.resolve(input.baseDir, rel);
-            if (external_fs_.existsSync(candidate)) return candidate;
+        function computeExtensionsToLoad(baseDir, mode, browser, userExtensionOutputPath, extraExtensionDirs = [], userManifestPath) {
+            const list = [];
+            try {
+                const devtoolsForBrowser = resolveBuiltInExtensionForBrowser({
+                    baseDir,
+                    packageName: 'extension-js-devtools',
+                    browser
+                });
+                const themeForBrowser = resolveBuiltInExtensionForBrowser({
+                    baseDir,
+                    packageName: 'extension-js-theme',
+                    browser
+                });
+                const userHasNewTabOverride = hasNewTabOverride(userExtensionOutputPath) || ('string' == typeof userManifestPath ? hasNewTabOverride(external_path_.dirname(userManifestPath)) : false);
+                const devtoolsHasNewTabOverride = devtoolsForBrowser ? hasNewTabOverride(devtoolsForBrowser) : false;
+                const shouldSkipDevtoolsForNtpConflict = userHasNewTabOverride && devtoolsHasNewTabOverride;
+                if (devtoolsForBrowser && !shouldSkipDevtoolsForNtpConflict) list.push(devtoolsForBrowser);
+                if (themeForBrowser) list.push(themeForBrowser);
+            } catch  {}
+            for (const p of extraExtensionDirs)list.push(p);
+            list.push(userExtensionOutputPath);
+            return list;
+        }
+        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 computeExtensionsToLoad(baseDir, mode, browser, userExtensionOutputPath, extraExtensionDirs = [], userManifestPath) {
-        const list = [];
-        try {
-            const devtoolsForBrowser = resolveBuiltInExtensionForBrowser({
-                baseDir,
-                packageName: 'extension-js-devtools',
-                browser
-            });
-            const themeForBrowser = resolveBuiltInExtensionForBrowser({
-                baseDir,
-                packageName: 'extension-js-theme',
-                browser
-            });
-            const userHasNewTabOverride = hasNewTabOverride(userExtensionOutputPath) || ('string' == typeof userManifestPath ? hasNewTabOverride(external_path_.dirname(userManifestPath)) : false);
-            const devtoolsHasNewTabOverride = devtoolsForBrowser ? hasNewTabOverride(devtoolsForBrowser) : false;
-            const shouldSkipDevtoolsForNtpConflict = userHasNewTabOverride && devtoolsHasNewTabOverride;
-            if (devtoolsForBrowser && !shouldSkipDevtoolsForNtpConflict) list.push(devtoolsForBrowser);
-            if (themeForBrowser) list.push(themeForBrowser);
-        } catch  {}
-        for (const p of extraExtensionDirs)list.push(p);
-        list.push(userExtensionOutputPath);
-        return list;
-    }
-    function getDarkModeDefaults(browser) {
-        if ('chrome' === browser || 'edge' === browser || 'chromium' === browser || 'chromium-based' === browser) return {
-            browserFlags: [
-                '--force-dark-mode',
-                '--enable-features=WebUIDarkMode'
-            ],
-            preferences: {}
-        };
-        if ('firefox' === browser || 'gecko-based' === browser || 'firefox-based' === browser) return {
-            browserFlags: [],
-            preferences: {
-                'ui.systemUsesDarkTheme': 1,
-                'layout.css.prefers-color-scheme.content-override': 2,
-                'devtools.theme': 'dark'
-            }
-        };
-        return {
-            browserFlags: [],
-            preferences: {}
-        };
-    }
-    function withDarkMode(config) {
-        const defaults = getDarkModeDefaults(config.browser);
-        const existingFlags = Array.isArray(config.browserFlags) ? [
-            ...config.browserFlags
-        ] : [];
-        const nextFlags = [
-            ...existingFlags
-        ];
-        for (const flag of defaults.browserFlags || [])if (!nextFlags.some((f)=>String(f).trim() === flag)) nextFlags.push(flag);
-        const nextPreferences = {
-            ...config.preferences || {},
-            ...Object.fromEntries(Object.entries(defaults.preferences || {}).filter(([k])=>!(k in (config.preferences || {}))))
-        };
-        return {
-            ...config,
-            browserFlags: nextFlags,
-            preferences: nextPreferences
-        };
-    }
-    var external_pintor_ = __webpack_require__("pintor");
-    var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_);
-    function readJsonRecord(filePath) {
-        try {
-            return JSON.parse(external_fs_.readFileSync(filePath, 'utf8'));
-        } catch  {
-            return null;
+        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 capitalizeToken(value) {
-        return value.split('-').filter(Boolean).map((token)=>token.charAt(0).toUpperCase() + token.slice(1)).join('-');
-    }
-    function getExtensionVersion() {
-        return process.env.EXTENSION_DEVELOP_VERSION || process.env.EXTENSION_CLI_VERSION || (()=>{
+        var external_pintor_ = __webpack_require__("pintor");
+        var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_);
+        function readJsonRecord(filePath) {
             try {
-                return __webpack_require__("./package.json").rE;
+                return JSON.parse(external_fs_.readFileSync(filePath, 'utf8'));
             } catch  {
-                return 'unknown';
+                return null;
             }
-        })();
-    }
-    function browserRunnerDisabled(args) {
-        const manifest = readJsonRecord(args.manifestPath);
-        const ready = readJsonRecord(args.readyPath);
-        const browserLabel = capitalizeToken(String(args.browser || 'unknown'));
-        const runId = String(ready?.runId || '').trim();
-        const pid = Number.isInteger(ready?.pid) ? String(ready?.pid) : '';
-        const runLabel = runId ? `${external_pintor_default().gray(runId)}${pid ? ` · ${external_pintor_default().gray(`PID ${pid}`)}` : ''}` : pid ? external_pintor_default().gray(`PID ${pid}`) : external_pintor_default().gray('n/a');
-        const extensionName = String(manifest?.name || 'Extension');
-        const extensionVersion = String(manifest?.version || '').trim();
-        const extensionLabel = extensionVersion ? `${extensionName} ${extensionVersion}` : extensionName;
-        const extensionJsVersion = getExtensionVersion();
-        return [
-            ` 🧩 ${external_pintor_default().brightBlue('Extension.js')} ${external_pintor_default().gray(extensionJsVersion)}`,
-            `    Browser        ${external_pintor_default().gray(args.browserModeLabel || `${browserLabel} (build-only mode)`)}`,
-            `    Extension      ${external_pintor_default().gray(extensionLabel)}`,
-            `    Run ID         ${runLabel}`
-        ].join('\n');
-    }
-    function spacerLine() {
-        return ' ';
-    }
-    async function extensionPreview(pathOrRemoteUrl, previewOptions, browserLauncher) {
-        const projectStructure = await getProjectStructure(pathOrRemoteUrl);
-        const debug = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-        const { manifestDir, packageJsonDir } = getDirs(projectStructure);
-        if (projectStructure.packageJsonPath) assertNoManagedDependencyConflicts(projectStructure.packageJsonPath, packageJsonDir);
-        const browser = normalizeBrowser(previewOptions.browser || 'chrome', previewOptions.chromiumBinary, previewOptions.geckoBinary || previewOptions.firefoxBinary);
-        const outputPath = computePreviewOutputPath(projectStructure, browser, previewOptions.outputPath);
-        const distPath = getDistPath(packageJsonDir, browser);
-        const metadataCommand = 'start' === previewOptions.metadataCommand ? 'start' : 'preview';
-        const metadata = createPlaywrightMetadataWriter({
-            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(lib_messages.SG(manifestDir, packageJsonDir));
-            console.log(lib_messages._A(browser, previewOptions.chromiumBinary, previewOptions.geckoBinary || previewOptions.firefoxBinary));
-            console.log(lib_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 loadCommandConfig(packageJsonDir, metadataCommand);
-        const browserConfig = await loadBrowserConfig(packageJsonDir, browser);
-        console.log(lib_messages.V_(browser));
-        if (previewOptions.noBrowser) {
-            console.log(lib_messages.k4(browser));
-            metadata.writeReady();
-            console.log(spacerLine());
-            const browserLabel = String(browser || 'unknown');
-            console.log(browserRunnerDisabled({
-                browser: browserLabel,
+        }
+        function capitalizeToken(value) {
+            return value.split('-').filter(Boolean).map((token)=>token.charAt(0).toUpperCase() + token.slice(1)).join('-');
+        }
+        function getExtensionVersion() {
+            return process.env.EXTENSION_DEVELOP_VERSION || process.env.EXTENSION_CLI_VERSION || (()=>{
+                try {
+                    return __webpack_require__("./package.json").rE;
+                } catch  {
+                    return 'unknown';
+                }
+            })();
+        }
+        function browserRunnerDisabled(args) {
+            const manifest = readJsonRecord(args.manifestPath);
+            const ready = readJsonRecord(args.readyPath);
+            const browserLabel = capitalizeToken(String(args.browser || 'unknown'));
+            const runId = String(ready?.runId || '').trim();
+            const pid = Number.isInteger(ready?.pid) ? String(ready?.pid) : '';
+            const runLabel = runId ? `${external_pintor_default().gray(runId)}${pid ? ` · ${external_pintor_default().gray(`PID ${pid}`)}` : ''}` : pid ? external_pintor_default().gray(`PID ${pid}`) : external_pintor_default().gray('n/a');
+            const extensionName = String(manifest?.name || 'Extension');
+            const extensionVersion = String(manifest?.version || '').trim();
+            const extensionLabel = extensionVersion ? `${extensionName} ${extensionVersion}` : extensionName;
+            const extensionJsVersion = getExtensionVersion();
+            return [
+                ` 🧩 ${external_pintor_default().brightBlue('Extension.js')} ${external_pintor_default().gray(extensionJsVersion)}`,
+                `    Browser        ${external_pintor_default().gray(args.browserModeLabel || `${browserLabel} (build-only mode)`)}`,
+                `    Extension      ${external_pintor_default().gray(extensionLabel)}`,
+                `    Run ID         ${runLabel}`
+            ].join('\n');
+        }
+        function spacerLine() {
+            return ' ';
+        }
+        async function extensionPreview(pathOrRemoteUrl, previewOptions, browserLauncher) {
+            const projectStructure = await getProjectStructure(pathOrRemoteUrl);
+            const debug = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+            const { manifestDir, packageJsonDir } = getDirs(projectStructure);
+            if (projectStructure.packageJsonPath) assertNoManagedDependencyConflicts(projectStructure.packageJsonPath, packageJsonDir);
+            const browser = normalizeBrowser(previewOptions.browser || 'chrome', previewOptions.chromiumBinary, previewOptions.geckoBinary || previewOptions.firefoxBinary);
+            const outputPath = computePreviewOutputPath(projectStructure, browser, previewOptions.outputPath);
+            const distPath = getDistPath(packageJsonDir, browser);
+            const metadataCommand = 'start' === previewOptions.metadataCommand ? 'start' : 'preview';
+            const metadata = createPlaywrightMetadataWriter({
+                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(lib_messages.SG(manifestDir, packageJsonDir));
+                console.log(lib_messages._A(browser, previewOptions.chromiumBinary, previewOptions.geckoBinary || previewOptions.firefoxBinary));
+                console.log(lib_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 loadCommandConfig(packageJsonDir, metadataCommand);
+            const browserConfig = await loadBrowserConfig(packageJsonDir, browser);
+            console.log(lib_messages.V_(browser));
+            if (previewOptions.noBrowser) {
+                console.log(lib_messages.k4(browser));
+                metadata.writeReady();
+                console.log(spacerLine());
+                const browserLabel = String(browser || 'unknown');
+                console.log(browserRunnerDisabled({
+                    browser: browserLabel,
+                    manifestPath: projectStructure.manifestPath,
+                    readyPath: metadata.readyPath,
+                    browserModeLabel: `${browserLabel.charAt(0).toUpperCase() + browserLabel.slice(1)} (no-browser mode)`
+                }));
+                return;
+            }
+            const safeBrowserConfig = sanitize(browserConfig);
+            const safeCommandConfig = sanitize(commandConfig);
+            const safePreviewOptions = sanitize(previewOptions);
+            const specialFoldersData = getSpecialFoldersDataForProjectRoot(packageJsonDir);
+            const mergedExtensionsConfig = safePreviewOptions.extensions ?? safeCommandConfig.extensions ?? safeBrowserConfig.extensions ?? specialFoldersData.extensions;
+            const resolvedExtensionsConfig = await resolveCompanionExtensionsConfig({
+                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 = computeExtensionsToLoad(external_path_.resolve(__dirname, '..'), 'production', browser, outputPath, companionUnpackedExtensionDirs, projectStructure.manifestPath);
+            const resolvedOpts = {
+                browser,
+                outPath: outputPath,
+                contextDir: packageJsonDir,
                 readyPath: metadata.readyPath,
-                browserModeLabel: `${browserLabel.charAt(0).toUpperCase() + browserLabel.slice(1)} (no-browser mode)`
-            }));
-            return;
-        }
-        const safeBrowserConfig = sanitize(browserConfig);
-        const safeCommandConfig = sanitize(commandConfig);
-        const safePreviewOptions = sanitize(previewOptions);
-        const specialFoldersData = getSpecialFoldersDataForProjectRoot(packageJsonDir);
-        const mergedExtensionsConfig = safePreviewOptions.extensions ?? safeCommandConfig.extensions ?? safeBrowserConfig.extensions ?? specialFoldersData.extensions;
-        const resolvedExtensionsConfig = await resolveCompanionExtensionsConfig({
-            projectRoot: packageJsonDir,
-            browser,
-            config: mergedExtensionsConfig
+                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();
+        }
+    },
+    "adm-zip" (module) {
+        module.exports = require("adm-zip");
+    },
+    fs (module) {
+        module.exports = require("fs");
+    },
+    path (module) {
+        module.exports = require("path");
+    },
+    pintor (module) {
+        module.exports = require("pintor");
+    },
+    "./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 __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
         });
-        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
+        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'
         });
-        const companionUnpackedExtensionDirs = resolveCompanionExtensionDirs({
-            projectRoot: packageJsonDir,
-            config: merged.extensions
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
         });
-        const unpackedExtensionDirsToLoad = computeExtensionsToLoad(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 = {
+        534: 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__("./preview-entry.ts");
 exports.extensionPreview = __webpack_exports__.extensionPreview;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "extensionPreview"