extension-develop 3.10.3 → 3.10.4-canary.1

package/dist/module.cjs

@@ -3,7 +3,7 @@ const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
     return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
 }();
 var __webpack_modules__ = {
-    "../../node_modules/.pnpm/immutable@5.1.5/node_modules/immutable/dist/immutable.es.js" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+    "../../node_modules/immutable/dist/immutable.es.js" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.r(__webpack_exports__);
         __webpack_require__.d(__webpack_exports__, {
@@ -3988,7 +3988,7 @@ var __webpack_modules__ = {
         var version1 = "5.1.5";
         var Iterable = Collection;
     },
-    "../../node_modules/.pnpm/sass@1.97.2/node_modules/sass/sass.dart.js" () {
+    "../../node_modules/sass/sass.dart.js" () {
         if (!globalThis._cliPkgExports) globalThis._cliPkgExports = [];
         let _cliPkgExports = {};
         globalThis._cliPkgExports.push(_cliPkgExports);
@@ -127118,8 +127118,8 @@ var __webpack_modules__ = {
             })();
         };
     },
-    "../../node_modules/.pnpm/sass@1.97.2/node_modules/sass/sass.node.js" (module, __unused_rspack_exports, __webpack_require__) {
-        __webpack_require__("../../node_modules/.pnpm/sass@1.97.2/node_modules/sass/sass.dart.js");
+    "../../node_modules/sass/sass.node.js" (module, __unused_rspack_exports, __webpack_require__) {
+        __webpack_require__("../../node_modules/sass/sass.dart.js");
         const library = globalThis._cliPkgExports.pop();
         if (0 === globalThis._cliPkgExports.length) delete globalThis._cliPkgExports;
         library.load({
@@ -127127,7 +127127,7 @@ var __webpack_modules__ = {
             stream: __webpack_require__("stream"),
             nodeModule: __webpack_require__("module"),
             fs: __webpack_require__("fs"),
-            immutable: __webpack_require__("../../node_modules/.pnpm/immutable@5.1.5/node_modules/immutable/dist/immutable.es.js")
+            immutable: __webpack_require__("../../node_modules/immutable/dist/immutable.es.js")
         });
         module.exports = library;
     },
@@ -127515,623 +127515,6 @@ var __webpack_modules__ = {
             };
         }
     },
-    "./webpack/optional-deps-lib/cache-state.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        "use strict";
-        __webpack_require__.d(__webpack_exports__, {
-            M: ()=>prepareOptionalInstallState
-        });
-        var path__rspack_import_0 = __webpack_require__("path");
-        var fs__rspack_import_1 = __webpack_require__("fs");
-        var _package_json__rspack_import_2 = __webpack_require__("./package.json");
-        var _webpack_lib_optional_dependencies__rspack_import_3 = __webpack_require__("./webpack/webpack-lib/optional-dependencies.ts");
-        function parseJsonSafe(text) {
-            const raw = 'string' == typeof text ? text : String(text || '');
-            const s = raw && 0xfeff === raw.charCodeAt(0) ? raw.slice(1) : raw;
-            return JSON.parse(s || '{}');
-        }
-        function ensureOptionalInstallBaseDir(installBaseDir) {
-            fs__rspack_import_1.mkdirSync(installBaseDir, {
-                recursive: true
-            });
-            const packageJsonPath = path__rspack_import_0.join(installBaseDir, 'package.json');
-            if (!fs__rspack_import_1.existsSync(packageJsonPath)) fs__rspack_import_1.writeFileSync(packageJsonPath, JSON.stringify({
-                name: `extensionjs-optional-deps-${_package_json__rspack_import_2.rE}`,
-                private: true,
-                version: _package_json__rspack_import_2.rE
-            }, null, 2) + '\n');
-        }
-        function removePathIfExists(targetPath) {
-            if (!fs__rspack_import_1.existsSync(targetPath)) return;
-            fs__rspack_import_1.rmSync(targetPath, {
-                recursive: true,
-                force: true
-            });
-        }
-        function resetOptionalInstallRoot(installBaseDir) {
-            removePathIfExists(path__rspack_import_0.join(installBaseDir, 'node_modules'));
-            removePathIfExists(path__rspack_import_0.join(installBaseDir, 'package-lock.json'));
-            removePathIfExists(path__rspack_import_0.join(installBaseDir, 'npm-shrinkwrap.json'));
-            removePathIfExists(path__rspack_import_0.join(installBaseDir, 'pnpm-lock.yaml'));
-            removePathIfExists(path__rspack_import_0.join(installBaseDir, 'yarn.lock'));
-            removePathIfExists(path__rspack_import_0.join(installBaseDir, 'bun.lock'));
-        }
-        function getPinnedOptionalDependencyMap(dependencies) {
-            const specs = (0, _webpack_lib_optional_dependencies__rspack_import_3.ad)(dependencies);
-            const pinned = {};
-            for(let i = 0; i < dependencies.length; i++){
-                const dependencyId = dependencies[i];
-                const spec = specs[i] || '';
-                const versionSeparator = spec.lastIndexOf('@');
-                if (dependencyId && !(versionSeparator <= 0)) pinned[dependencyId] = spec.slice(versionSeparator + 1);
-            }
-            return pinned;
-        }
-        function ensureOptionalDependenciesManifest(installBaseDir, dependencies) {
-            if (!dependencies.length) return;
-            const packageJsonPath = path__rspack_import_0.join(installBaseDir, 'package.json');
-            const current = parseJsonSafe(fs__rspack_import_1.readFileSync(packageJsonPath, 'utf8'));
-            const nextOptionalDependencies = {
-                ...current.optionalDependencies || {},
-                ...getPinnedOptionalDependencyMap(dependencies)
-            };
-            const didChange = dependencies.some((dependencyId)=>current.optionalDependencies?.[dependencyId] !== nextOptionalDependencies[dependencyId]);
-            if (!didChange) return;
-            fs__rspack_import_1.writeFileSync(packageJsonPath, JSON.stringify({
-                ...current,
-                private: true,
-                optionalDependencies: nextOptionalDependencies
-            }, null, 2) + '\n');
-        }
-        function prepareOptionalInstallState(input) {
-            if (input.forceRecreateInstallRoot) resetOptionalInstallRoot(input.installBaseDir);
-            ensureOptionalInstallBaseDir(input.installBaseDir);
-            ensureOptionalDependenciesManifest(input.installBaseDir, input.dependencies);
-        }
-    },
-    "./webpack/optional-deps-lib/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        "use strict";
-        __webpack_require__.d(__webpack_exports__, {
-            Dy: ()=>_installer_engine__rspack_import_0.D,
-            He: ()=>_runtime_context__rspack_import_1.He,
-            Iy: ()=>_runtime_context__rspack_import_1.Iy,
-            tm: ()=>_installer_engine__rspack_import_0.t,
-            ws: ()=>_runtime_context__rspack_import_1.ws
-        });
-        var _installer_engine__rspack_import_0 = __webpack_require__("./webpack/optional-deps-lib/installer-engine.ts");
-        var _runtime_context__rspack_import_1 = __webpack_require__("./webpack/optional-deps-lib/runtime-context.ts");
-    },
-    "./webpack/optional-deps-lib/install-root-packages.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        "use strict";
-        __webpack_require__.d(__webpack_exports__, {
-            G: ()=>resolvePackageFromInstallRoot
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        function isPackageEntry(entry) {
-            return entry.isDirectory() || entry.isSymbolicLink();
-        }
-        function getDirectPackageDir(dependencyId, installRoot) {
-            return path__rspack_import_1.join(installRoot, 'node_modules', ...dependencyId.split('/'));
-        }
-        function listInstalledPackageDirs(nodeModulesDir) {
-            if (!fs__rspack_import_0.existsSync(nodeModulesDir)) return [];
-            try {
-                const entries = fs__rspack_import_0.readdirSync(nodeModulesDir, {
-                    withFileTypes: true
-                });
-                const packageDirs = [];
-                for (const entry of entries){
-                    if (!isPackageEntry(entry) || '.bin' === entry.name) continue;
-                    const entryPath = path__rspack_import_1.join(nodeModulesDir, entry.name);
-                    if (!entry.name.startsWith('@')) {
-                        packageDirs.push(entryPath);
-                        continue;
-                    }
-                    const scopedEntries = fs__rspack_import_0.readdirSync(entryPath, {
-                        withFileTypes: true
-                    });
-                    for (const scopedEntry of scopedEntries)if (isPackageEntry(scopedEntry)) packageDirs.push(path__rspack_import_1.join(entryPath, scopedEntry.name));
-                }
-                return packageDirs;
-            } catch  {
-                return [];
-            }
-        }
-        function findPackageDirInPnpmStore(dependencyId, installRoot) {
-            const pnpmStoreDir = path__rspack_import_1.join(installRoot, 'node_modules', '.pnpm');
-            if (!fs__rspack_import_0.existsSync(pnpmStoreDir)) return;
-            try {
-                const storeEntries = fs__rspack_import_0.readdirSync(pnpmStoreDir, {
-                    withFileTypes: true
-                });
-                for (const entry of storeEntries){
-                    if (!isPackageEntry(entry) || 'node_modules' === entry.name) continue;
-                    const candidatePackageJson = path__rspack_import_1.join(pnpmStoreDir, entry.name, 'node_modules', ...dependencyId.split('/'), 'package.json');
-                    if (fs__rspack_import_0.existsSync(candidatePackageJson)) return path__rspack_import_1.dirname(candidatePackageJson);
-                }
-            } catch  {}
-        }
-        function findNestedPackageDir(dependencyId, installRoot) {
-            const directPackageJson = path__rspack_import_1.join(getDirectPackageDir(dependencyId, installRoot), 'package.json');
-            if (fs__rspack_import_0.existsSync(directPackageJson)) return path__rspack_import_1.dirname(directPackageJson);
-            const fromPnpmStore = findPackageDirInPnpmStore(dependencyId, installRoot);
-            if (fromPnpmStore) return fromPnpmStore;
-            const visited = new Set();
-            const queue = [
-                {
-                    nodeModulesDir: path__rspack_import_1.join(installRoot, 'node_modules'),
-                    depth: 0
-                }
-            ];
-            const maxDepth = 4;
-            while(queue.length > 0){
-                const current = queue.shift();
-                if (visited.has(current.nodeModulesDir)) continue;
-                visited.add(current.nodeModulesDir);
-                const candidatePackageJson = path__rspack_import_1.join(current.nodeModulesDir, ...dependencyId.split('/'), 'package.json');
-                if (fs__rspack_import_0.existsSync(candidatePackageJson)) return path__rspack_import_1.dirname(candidatePackageJson);
-                if (current.depth >= maxDepth) continue;
-                for (const packageDir of listInstalledPackageDirs(current.nodeModulesDir)){
-                    const nestedNodeModulesDir = path__rspack_import_1.join(packageDir, 'node_modules');
-                    if (fs__rspack_import_0.existsSync(nestedNodeModulesDir)) queue.push({
-                        nodeModulesDir: nestedNodeModulesDir,
-                        depth: current.depth + 1
-                    });
-                }
-            }
-        }
-        function readPackageJsonFromDir(packageDir) {
-            const manifestPath = path__rspack_import_1.join(packageDir, 'package.json');
-            if (!fs__rspack_import_0.existsSync(manifestPath)) return;
-            try {
-                return JSON.parse(fs__rspack_import_0.readFileSync(manifestPath, 'utf8') || '{}');
-            } catch  {
-                return;
-            }
-        }
-        function getPackageEntryCandidates(pkg) {
-            const candidateEntries = [];
-            if ('string' == typeof pkg?.main) candidateEntries.push(pkg.main);
-            if ('string' == typeof pkg?.module) candidateEntries.push(pkg.module);
-            if ('string' == typeof pkg?.exports) candidateEntries.push(pkg.exports);
-            const dotExport = pkg?.exports?.['.'];
-            if ('string' == typeof dotExport) candidateEntries.push(dotExport);
-            if (dotExport && 'object' == typeof dotExport) {
-                if ('string' == typeof dotExport.require) candidateEntries.push(dotExport.require);
-                if ('string' == typeof dotExport.default) candidateEntries.push(dotExport.default);
-                if ('string' == typeof dotExport.import) candidateEntries.push(dotExport.import);
-            }
-            candidateEntries.push('index.js', 'index.cjs', 'index.mjs');
-            return candidateEntries;
-        }
-        function resolveFromPackageDir(packageDir) {
-            if (!fs__rspack_import_0.existsSync(packageDir)) return;
-            const pkg = readPackageJsonFromDir(packageDir);
-            if (!pkg) return;
-            for (const relativeEntry of getPackageEntryCandidates(pkg)){
-                const absoluteEntry = path__rspack_import_1.resolve(packageDir, relativeEntry);
-                if (fs__rspack_import_0.existsSync(absoluteEntry)) return absoluteEntry;
-            }
-        }
-        function resolvePackageFromInstallRoot(dependencyId, installRoot) {
-            const packageDir = findNestedPackageDir(dependencyId, installRoot);
-            if (!packageDir) return;
-            return resolveFromPackageDir(packageDir);
-        }
-    },
-    "./webpack/optional-deps-lib/installer-engine.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        "use strict";
-        __webpack_require__.d(__webpack_exports__, {
-            D: ()=>installOptionalDependenciesBatch,
-            t: ()=>installOptionalDependencies
-        });
-        var pintor__rspack_import_0 = __webpack_require__("pintor");
-        var pintor__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_0);
-        var _plugin_css_css_lib_messages__rspack_import_1 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
-        var _webpack_lib_optional_dependencies__rspack_import_2 = __webpack_require__("./webpack/webpack-lib/optional-dependencies.ts");
-        var _webpack_lib_package_manager__rspack_import_3 = __webpack_require__("./webpack/webpack-lib/package-manager.ts");
-        var _cache_state__rspack_import_4 = __webpack_require__("./webpack/optional-deps-lib/cache-state.ts");
-        var _install_root_packages__rspack_import_5 = __webpack_require__("./webpack/optional-deps-lib/install-root-packages.ts");
-        var _runtime_context__rspack_import_6 = __webpack_require__("./webpack/optional-deps-lib/runtime-context.ts");
-        function getMissingDependenciesAtInstallRoot(dependencies, installBaseDir) {
-            return dependencies.filter((dependencyId)=>!(0, _install_root_packages__rspack_import_5.G)(dependencyId, installBaseDir));
-        }
-        function parseWslUncPath(value) {
-            const match = /^\\\\wsl(?:\.localhost)?\\([^\\]+)\\(.+)$/.exec(value);
-            if (!match) return null;
-            const distro = match[1];
-            const rel = match[2].replace(/\\/g, '/').replace(/^\/+/, '');
-            return {
-                distro,
-                path: `/${rel}`
-            };
-        }
-        function isWslMountPath(value) {
-            return /^\/mnt\/[a-z]\//i.test(value);
-        }
-        function resolveWslContext(installBaseDir) {
-            if ('win32' !== process.platform) return {
-                useWsl: false
-            };
-            const trimmed = String(installBaseDir || '').trim();
-            if (!trimmed) return {
-                useWsl: false
-            };
-            const unc = parseWslUncPath(trimmed);
-            if (unc) return {
-                useWsl: true,
-                distro: unc.distro,
-                installDir: unc.path
-            };
-            if (isWslMountPath(trimmed)) return {
-                useWsl: true,
-                installDir: trimmed
-            };
-            return {
-                useWsl: false
-            };
-        }
-        function wrapCommandForWsl(command, context) {
-            if (!context.useWsl) return command;
-            const args = [
-                ...context.distro ? [
-                    '-d',
-                    context.distro
-                ] : [],
-                '--'
-            ];
-            args.push(command.command, ...command.args);
-            return {
-                command: 'wsl.exe',
-                args
-            };
-        }
-        function isMissingManagerError(error) {
-            const err = error;
-            return err?.code === 'ENOENT' || String(err?.message || '').includes('ENOENT') || String(err?.message || '').includes('not found');
-        }
-        function isInstallExitFailure(error) {
-            return /Install failed with exit code \d+/.test(String(error?.message || error || ''));
-        }
-        async function execInstallWithFallback(command, options) {
-            try {
-                await (0, _webpack_lib_package_manager__rspack_import_3.Qt)(command.command, command.args, {
-                    cwd: options.cwd,
-                    stdio: 'inherit'
-                });
-                return;
-            } catch (error) {
-                if (options.fallbackNpmCommand && (isMissingManagerError(error) || options.allowFallbackOnFailure && isInstallExitFailure(error))) return void await (0, _webpack_lib_package_manager__rspack_import_3.Qt)(options.fallbackNpmCommand.command, options.fallbackNpmCommand.args, {
-                    cwd: options.cwd,
-                    stdio: 'inherit'
-                });
-                throw error;
-            }
-        }
-        async function preferCorepackFallback(pm) {
-            if ('npm' !== pm.name || pm.execPath || pm.runnerCommand) return pm;
-            const npmUserAgent = process.env.npm_config_user_agent || '';
-            const npmExecPath = process.env.npm_execpath || process.env.NPM_EXEC_PATH || '';
-            if (npmUserAgent.includes('npm') || npmExecPath) return pm;
-            try {
-                const { spawnSync } = await import("child_process");
-                const result = spawnSync('corepack', [
-                    '--version'
-                ], {
-                    stdio: 'ignore',
-                    windowsHide: true
-                });
-                if (result?.status === 0) return {
-                    name: 'pnpm',
-                    runnerCommand: 'corepack',
-                    runnerArgs: [
-                        'pnpm'
-                    ]
-                };
-            } catch  {}
-            return pm;
-        }
-        function getOptionalInstallCommand(pm, dependencies, installBaseDir) {
-            const pmName = pm.name;
-            const dependencySpecs = (0, _webpack_lib_optional_dependencies__rspack_import_2.ad)(dependencies);
-            if ('yarn' === pmName) return (0, _webpack_lib_package_manager__rspack_import_3.tj)(pm, [
-                '--silent',
-                'add',
-                ...dependencySpecs,
-                '--cwd',
-                installBaseDir,
-                '--optional'
-            ]);
-            if ('npm' === pmName) return getRootInstallCommand(pm, installBaseDir);
-            if ('pnpm' === pmName) return (0, _webpack_lib_package_manager__rspack_import_3.tj)(pm, [
-                'install',
-                '--dir',
-                installBaseDir,
-                '--ignore-workspace',
-                '--lockfile=false',
-                '--silent'
-            ]);
-            if ('bun' === pmName) return (0, _webpack_lib_package_manager__rspack_import_3.tj)(pm, [
-                'add',
-                ...dependencySpecs,
-                '--cwd',
-                installBaseDir,
-                '--optional'
-            ]);
-            return (0, _webpack_lib_package_manager__rspack_import_3.tj)(pm, [
-                '--silent',
-                'install',
-                ...dependencySpecs,
-                '--cwd',
-                installBaseDir,
-                '--optional'
-            ]);
-        }
-        function getRootInstallCommand(pm, installBaseDir) {
-            const pmName = pm.name;
-            const dirArgs = installBaseDir ? 'yarn' === pmName ? [
-                '--cwd',
-                installBaseDir
-            ] : 'pnpm' === pmName ? [
-                '--dir',
-                installBaseDir
-            ] : 'bun' === pmName ? [
-                '--cwd',
-                installBaseDir
-            ] : [
-                '--prefix',
-                installBaseDir
-            ] : [];
-            if ('yarn' === pmName) return (0, _webpack_lib_package_manager__rspack_import_3.tj)(pm, [
-                'install',
-                '--silent',
-                ...dirArgs
-            ]);
-            if ('npm' === pmName) return (0, _webpack_lib_package_manager__rspack_import_3.tj)(pm, [
-                'install',
-                '--silent',
-                ...dirArgs
-            ]);
-            if ('pnpm' === pmName) return (0, _webpack_lib_package_manager__rspack_import_3.tj)(pm, [
-                'install',
-                '--silent',
-                ...dirArgs,
-                '--ignore-workspace',
-                '--lockfile=false'
-            ]);
-            if ('bun' === pmName) return (0, _webpack_lib_package_manager__rspack_import_3.tj)(pm, [
-                'install',
-                ...dirArgs
-            ]);
-            return (0, _webpack_lib_package_manager__rspack_import_3.tj)(pm, [
-                'install',
-                '--silent',
-                ...dirArgs
-            ]);
-        }
-        async function runInstallAttempt(input) {
-            const installCommand = getOptionalInstallCommand(input.pm, input.dependencies, input.wslContext.installDir || input.installBaseDir);
-            const execCommand = wrapCommandForWsl(installCommand, input.wslContext);
-            const fallbackNpmCommand = input.wslContext.useWsl ? void 0 : (0, _webpack_lib_package_manager__rspack_import_3.sX)([
-                '--silent',
-                'install',
-                ...(0, _webpack_lib_optional_dependencies__rspack_import_2.ad)(input.dependencies),
-                '--prefix',
-                input.installBaseDir,
-                '--save-optional'
-            ]);
-            await execInstallWithFallback(execCommand, {
-                cwd: input.wslContext.useWsl ? void 0 : input.installBaseDir,
-                fallbackNpmCommand,
-                allowFallbackOnFailure: !input.wslContext.useWsl && 'npm' !== input.pm.name && void 0 !== fallbackNpmCommand
-            });
-            await new Promise((resolve)=>setTimeout(resolve, 500));
-            const needsRootRelink = 'npm' !== input.pm.name && (input.isAuthor || input.dependencies.length > 1);
-            if (!needsRootRelink) return;
-            if (input.isAuthor) console.log(_plugin_css_css_lib_messages__rspack_import_1.cr(input.integration));
-            const rootInstall = getRootInstallCommand(input.pm, input.wslContext.useWsl ? input.wslContext.installDir : void 0);
-            const rootCommand = wrapCommandForWsl(rootInstall, input.wslContext);
-            const rootFallbackCommand = input.wslContext.useWsl ? void 0 : (0, _webpack_lib_package_manager__rspack_import_3.sX)([
-                '--silent',
-                'install',
-                '--prefix',
-                input.installBaseDir
-            ]);
-            await execInstallWithFallback(rootCommand, {
-                cwd: input.wslContext.useWsl ? void 0 : input.installBaseDir,
-                fallbackNpmCommand: rootFallbackCommand,
-                allowFallbackOnFailure: !input.wslContext.useWsl && 'npm' !== input.pm.name && void 0 !== rootFallbackCommand
-            });
-            if (input.isAuthor) console.log(_plugin_css_css_lib_messages__rspack_import_1.ys(input.integration));
-        }
-        async function installOptionalDependencies(integration, dependencies, options) {
-            if (!dependencies.length) return;
-            let pm;
-            let wslContext;
-            let installBaseDir;
-            try {
-                installBaseDir = (0, _runtime_context__rspack_import_6.Iy)();
-                (0, _cache_state__rspack_import_4.M)({
-                    installBaseDir,
-                    dependencies,
-                    forceRecreateInstallRoot: options?.forceRecreateInstallRoot
-                });
-                pm = (0, _webpack_lib_package_manager__rspack_import_3._c)({
-                    cwd: installBaseDir
-                });
-                wslContext = resolveWslContext(installBaseDir);
-                if (!wslContext.useWsl) pm = await preferCorepackFallback(pm);
-                const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-                const setupMessages = _plugin_css_css_lib_messages__rspack_import_1._j([
-                    integration
-                ], integration, isAuthor);
-                const setupMessage = setupMessages[0];
-                const hasIndex = Boolean(options?.index && options?.total);
-                const setupMessageWithIndex = hasIndex ? setupMessage.replace('►►► ', `►►► [${options?.index}/${options?.total}] `) : setupMessage;
-                if (isAuthor) console.warn(setupMessageWithIndex);
-                else console.log(setupMessageWithIndex);
-                await runInstallAttempt({
-                    pm,
-                    wslContext,
-                    installBaseDir,
-                    dependencies,
-                    isAuthor,
-                    integration
-                });
-                let missingDependencies = getMissingDependenciesAtInstallRoot(dependencies, installBaseDir);
-                if (missingDependencies.length > 0 && 'npm' !== pm.name) {
-                    await runInstallAttempt({
-                        pm,
-                        wslContext,
-                        installBaseDir,
-                        dependencies: missingDependencies,
-                        isAuthor,
-                        integration
-                    });
-                    missingDependencies = getMissingDependenciesAtInstallRoot(dependencies, installBaseDir);
-                }
-                if (missingDependencies.length > 0) {
-                    (0, _cache_state__rspack_import_4.M)({
-                        installBaseDir,
-                        dependencies,
-                        forceRecreateInstallRoot: true
-                    });
-                    await runInstallAttempt({
-                        pm,
-                        wslContext,
-                        installBaseDir,
-                        dependencies,
-                        isAuthor,
-                        integration
-                    });
-                    missingDependencies = getMissingDependenciesAtInstallRoot(dependencies, installBaseDir);
-                }
-                if (missingDependencies.length > 0) throw new Error(`[${integration}] Optional dependency install reported success but packages are missing: ${missingDependencies.join(', ')}`);
-                return true;
-            } catch (error) {
-                console.error('[extension.js][optional-deps] debug', {
-                    platform: process.platform,
-                    execPath: process.execPath,
-                    cwd: process.cwd(),
-                    path: process.env.PATH || process.env.Path,
-                    comspec: process.env.ComSpec,
-                    systemRoot: process.env.SystemRoot,
-                    npm_execpath: process.env.npm_execpath,
-                    npm_config_user_agent: process.env.npm_config_user_agent,
-                    npm_config_prefix: process.env.npm_config_prefix,
-                    npm_config_cache: process.env.npm_config_cache,
-                    npm_config_userconfig: process.env.npm_config_userconfig,
-                    installBaseDir,
-                    wslContext,
-                    pm,
-                    errorCode: error?.code,
-                    errorMessage: error instanceof Error ? error.message : String(error || 'unknown error')
-                });
-                const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-                if (isMissingManagerError(error)) console.error(_plugin_css_css_lib_messages__rspack_import_1.Vo(integration));
-                else console.error(_plugin_css_css_lib_messages__rspack_import_1.DX(integration, error, isAuthor));
-                return false;
-            }
-        }
-        async function installOptionalDependenciesBatch(plans) {
-            if (!plans.length) return;
-            console.log(`${pintor__rspack_import_0_default().gray('►►►')} Found ${pintor__rspack_import_0_default().yellow(String(plans.length))} specialized integration${1 === plans.length ? '' : 's'} needing installation...`);
-            for (const [index, plan] of plans.entries()){
-                const didInstall = await installOptionalDependencies(plan.integration, plan.dependencies, {
-                    index: index + 1,
-                    total: plans.length
-                });
-                if (!didInstall) return false;
-            }
-            return true;
-        }
-    },
-    "./webpack/optional-deps-lib/runtime-context.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        "use strict";
-        __webpack_require__.d(__webpack_exports__, {
-            He: ()=>resolveDevelopInstallRoot,
-            Iy: ()=>resolveOptionalInstallRoot,
-            ws: ()=>hasDependency
-        });
-        var path__rspack_import_0 = __webpack_require__("path");
-        var fs__rspack_import_1 = __webpack_require__("fs");
-        var os__rspack_import_2 = __webpack_require__("os");
-        var _package_json__rspack_import_3 = __webpack_require__("./package.json");
-        var _webpack_lib_check_build_dependencies__rspack_import_4 = __webpack_require__("./webpack/webpack-lib/check-build-dependencies.ts");
-        function parseJsonSafe(text) {
-            const raw = 'string' == typeof text ? text : String(text || '');
-            const s = raw && 0xfeff === raw.charCodeAt(0) ? raw.slice(1) : raw;
-            return JSON.parse(s || '{}');
-        }
-        function resolveDevelopRootFromDir(dir) {
-            try {
-                const packageJsonPath = path__rspack_import_0.join(dir, 'package.json');
-                if (!fs__rspack_import_1.existsSync(packageJsonPath)) return;
-                const pkg = parseJsonSafe(fs__rspack_import_1.readFileSync(packageJsonPath, 'utf8'));
-                if (pkg?.name === 'extension-develop') return dir;
-            } catch  {}
-        }
-        function findDevelopRootFrom(startDir) {
-            let currentDir = startDir;
-            const maxDepth = 6;
-            for(let i = 0; i < maxDepth; i++){
-                const root = resolveDevelopRootFromDir(currentDir);
-                if (root) return root;
-                const parent = path__rspack_import_0.dirname(currentDir);
-                if (parent === currentDir) break;
-                currentDir = parent;
-            }
-        }
-        function resolveDevelopInstallRoot() {
-            const directRoot = (0, _webpack_lib_check_build_dependencies__rspack_import_4.w1)();
-            if (directRoot) return directRoot;
-            try {
-                const candidateRoot = findDevelopRootFrom(__dirname);
-                if (candidateRoot) return candidateRoot;
-            } catch  {}
-            try {
-                const pkgPath = require.resolve('extension-develop/package.json', {
-                    paths: [
-                        __dirname
-                    ]
-                });
-                return resolveDevelopRootFromDir(path__rspack_import_0.dirname(pkgPath));
-            } catch  {
-                return;
-            }
-        }
-        function getExtensionJsCacheBaseDir() {
-            const override = process.env.EXTENSION_JS_CACHE_DIR;
-            if (override) return path__rspack_import_0.resolve(override);
-            if ('win32' === process.platform && process.env.LOCALAPPDATA) return path__rspack_import_0.join(process.env.LOCALAPPDATA, 'extensionjs');
-            if (process.env.XDG_CACHE_HOME) return path__rspack_import_0.join(process.env.XDG_CACHE_HOME, 'extensionjs');
-            return path__rspack_import_0.join(os__rspack_import_2.homedir(), '.cache', 'extensionjs');
-        }
-        function resolveOptionalInstallRoot() {
-            return path__rspack_import_0.join(getExtensionJsCacheBaseDir(), 'optional-deps', _package_json__rspack_import_3.rE);
-        }
-        function hasDependency(projectPath, dependency) {
-            const findNearestPackageJsonDirectory = (startPath)=>{
-                let currentDirectory = startPath;
-                const maxDepth = 4;
-                for(let i = 0; i < maxDepth; i++){
-                    const candidate = path__rspack_import_0.join(currentDirectory, 'package.json');
-                    if (fs__rspack_import_1.existsSync(candidate)) return currentDirectory;
-                    const parentDirectory = path__rspack_import_0.dirname(currentDirectory);
-                    if (parentDirectory === currentDirectory) break;
-                    currentDirectory = parentDirectory;
-                }
-            };
-            const packageJsonDirectory = findNearestPackageJsonDirectory(projectPath);
-            if (!packageJsonDirectory) return false;
-            const packageJsonPath = path__rspack_import_0.join(packageJsonDirectory, 'package.json');
-            if (!fs__rspack_import_1.existsSync(packageJsonPath)) return false;
-            const parsed = parseJsonSafe(fs__rspack_import_1.readFileSync(packageJsonPath, 'utf8'));
-            const dependencies = parsed.dependencies || {};
-            const devDependencies = parsed.devDependencies || {};
-            return !!dependencies[dependency] || !!devDependencies[dependency];
-        }
-    },
     "./webpack/plugin-browsers/browsers-lib/banner.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -128314,6 +127697,342 @@ var __webpack_modules__ = {
             return true;
         }
     },
+    "./webpack/plugin-browsers/browsers-lib/content-script-targets.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            HE: ()=>isCanonicalContentScriptAsset,
+            Il: ()=>selectContentScriptRules,
+            JY: ()=>getChangedContentScriptEntryNames,
+            Rt: ()=>normalizeModuleResourcePath,
+            im: ()=>collectContentScriptDependencyPaths,
+            iw: ()=>readContentScriptRules,
+            lM: ()=>urlMatchesAnyContentScriptRule,
+            nG: ()=>resolveEmittedContentScriptFile,
+            wH: ()=>isContentScriptEntryName
+        });
+        var fs__rspack_import_0 = __webpack_require__("fs");
+        var path__rspack_import_1 = __webpack_require__("path");
+        var _plugin_web_extension_feature_scripts_contracts__rspack_import_2 = __webpack_require__("./webpack/plugin-web-extension/feature-scripts/contracts.ts");
+        function isContentScriptEntryName(entryName) {
+            return (0, _plugin_web_extension_feature_scripts_contracts__rspack_import_2.Mj)(entryName);
+        }
+        function isCanonicalContentScriptAsset(assetName) {
+            return (0, _plugin_web_extension_feature_scripts_contracts__rspack_import_2.HE)(assetName);
+        }
+        function resolveEmittedContentScriptFile(extensionOutPath, index, ext) {
+            const rel = 'js' === ext ? (0, _plugin_web_extension_feature_scripts_contracts__rspack_import_2.f6)(index) : (0, _plugin_web_extension_feature_scripts_contracts__rspack_import_2.J4)(index);
+            const canonical = path__rspack_import_1.join(extensionOutPath, rel);
+            if (fs__rspack_import_0.existsSync(canonical)) return canonical;
+            const dir = path__rspack_import_1.join(extensionOutPath, "content_scripts");
+            if (!fs__rspack_import_0.existsSync(dir)) return null;
+            try {
+                const re = new RegExp(`^content-${index}\\.[a-f0-9]+\\.${ext}$`, 'i');
+                for (const name of fs__rspack_import_0.readdirSync(dir))if (re.test(name)) return path__rspack_import_1.join(dir, name);
+            } catch  {}
+            return null;
+        }
+        function getChangedContentScriptEntryNames(modifiedFilePaths, dependencyPathsByEntry) {
+            const changed = new Set();
+            for (const modifiedFilePath of modifiedFilePaths)for (const [entryName, dependencyPaths] of dependencyPathsByEntry.entries()){
+                if (dependencyPaths.has(modifiedFilePath)) {
+                    changed.add(entryName);
+                    continue;
+                }
+                for (const dependencyPath of dependencyPaths)if (modifiedFilePath.endsWith(dependencyPath)) {
+                    changed.add(entryName);
+                    break;
+                }
+            }
+            return Array.from(changed).sort();
+        }
+        function collectContentScriptDependencyPaths(compilation) {
+            const dependencyPathsByEntry = new Map();
+            const entrypoints = compilation?.entrypoints;
+            const chunkGraph = compilation?.chunkGraph;
+            if (!entrypoints || !chunkGraph) return dependencyPathsByEntry;
+            for (const [entryName, entrypoint] of entrypoints.entries()){
+                if (!isContentScriptEntryName(entryName)) continue;
+                const resourcePaths = new Set();
+                const entrypointChunks = Array.from(entrypoint?.chunks || []);
+                for (const chunk of entrypointChunks){
+                    const modulesIterable = chunkGraph.getChunkModulesIterable?.(chunk) || chunkGraph.getChunkModulesIterableBySourceType?.(chunk, "javascript") || chunkGraph.getChunkModules?.(chunk);
+                    if (modulesIterable) for (const module of modulesIterable)collectModuleResourcePaths(module, resourcePaths);
+                }
+                collectDeclaredEntryImportPaths(compilation, entryName, resourcePaths);
+                collectTransitiveLocalDependencyPaths(resourcePaths);
+                if (resourcePaths.size > 0) dependencyPathsByEntry.set(entryName, resourcePaths);
+            }
+            return dependencyPathsByEntry;
+        }
+        function collectModuleResourcePaths(module, resourcePaths, seen = new Set()) {
+            if (!module || seen.has(module)) return;
+            seen.add(module);
+            const candidateResourcePaths = [
+                module?.resource,
+                module?.rootModule?.resource,
+                module?.originalSource?.()?.resource
+            ];
+            for (const resourcePath of candidateResourcePaths){
+                const normalizedResourcePath = normalizeModuleResourcePath(resourcePath);
+                if (normalizedResourcePath) resourcePaths.add(normalizedResourcePath);
+            }
+            const nestedCollections = [
+                module?.modules,
+                module?._modules,
+                module?.children,
+                module?.dependencies
+            ];
+            for (const nestedCollection of nestedCollections)if (nestedCollection) for (const nestedModule of nestedCollection)collectModuleResourcePaths(nestedModule, resourcePaths, seen);
+        }
+        function collectDeclaredEntryImportPaths(compilation, entryName, resourcePaths) {
+            const rawEntry = compilation?.options?.entry?.[entryName];
+            const importSpecifiers = normalizeEntryImportSpecifiers(rawEntry);
+            for (const importSpecifier of importSpecifiers){
+                const normalizedImportPath = normalizeModuleResourcePath(importSpecifier);
+                if (normalizedImportPath && fs__rspack_import_0.existsSync(normalizedImportPath)) {
+                    resourcePaths.add(normalizedImportPath);
+                    continue;
+                }
+                const dataUrlSource = decodeJavascriptDataUrl(importSpecifier);
+                if (dataUrlSource) for (const referencedPath of extractReferencedSourcePaths(dataUrlSource))resourcePaths.add(referencedPath);
+            }
+        }
+        function normalizeEntryImportSpecifiers(rawEntry) {
+            if (!rawEntry) return [];
+            if ('string' == typeof rawEntry) return [
+                rawEntry
+            ];
+            if (Array.isArray(rawEntry)) return rawEntry.map((value)=>String(value || ''));
+            const entryImport = rawEntry?.import;
+            if ('string' == typeof entryImport) return [
+                entryImport
+            ];
+            if (Array.isArray(entryImport)) return entryImport.map((value)=>String(value || ''));
+            return [];
+        }
+        function decodeJavascriptDataUrl(specifier) {
+            const value = String(specifier || '');
+            if (!value.startsWith("data:text/javascript")) return;
+            const commaIndex = value.indexOf(',');
+            if (-1 === commaIndex) return;
+            try {
+                return decodeURIComponent(value.slice(commaIndex + 1));
+            } catch  {
+                return;
+            }
+        }
+        function extractReferencedSourcePaths(source) {
+            const referencedPaths = new Set();
+            const patterns = [
+                /\bimport\s+(?:[^"'`]*?\s+from\s+)?["'`]([^"'`]+)["'`]/g,
+                /\bexport\s+[^"'`]*?\s+from\s+["'`]([^"'`]+)["'`]/g,
+                /\bimport\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
+                /\brequire\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
+                /new URL\(\s*["'`]([^"'`]+)["'`]\s*,\s*import\.meta\.url\s*\)/g
+            ];
+            for (const pattern of patterns){
+                let match;
+                while(match = pattern.exec(source)){
+                    const normalizedResourcePath = normalizeModuleResourcePath(match[1]);
+                    if (normalizedResourcePath && fs__rspack_import_0.existsSync(normalizedResourcePath)) referencedPaths.add(normalizedResourcePath);
+                }
+            }
+            return Array.from(referencedPaths);
+        }
+        function collectTransitiveLocalDependencyPaths(resourcePaths) {
+            const queue = Array.from(resourcePaths);
+            const seenFiles = new Set(queue);
+            while(queue.length > 0){
+                const currentPath = queue.shift();
+                if (!currentPath || !fs__rspack_import_0.existsSync(currentPath)) continue;
+                let stat;
+                try {
+                    stat = fs__rspack_import_0.statSync(currentPath);
+                } catch  {
+                    continue;
+                }
+                if (!stat.isFile()) continue;
+                let source = '';
+                try {
+                    source = fs__rspack_import_0.readFileSync(currentPath, 'utf8');
+                } catch  {
+                    continue;
+                }
+                for (const dependencyPath of resolveLocalSourceDependencies(currentPath, source))if (!seenFiles.has(dependencyPath)) {
+                    seenFiles.add(dependencyPath);
+                    resourcePaths.add(dependencyPath);
+                    queue.push(dependencyPath);
+                }
+            }
+        }
+        function resolveLocalSourceDependencies(absoluteFilePath, source) {
+            const resolvedPaths = new Set();
+            const patterns = [
+                /\bimport\s+(?:[^"'`]*?\s+from\s+)?["'`]([^"'`]+)["'`]/g,
+                /\bexport\s+[^"'`]*?\s+from\s+["'`]([^"'`]+)["'`]/g,
+                /\bimport\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
+                /\brequire\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
+                /new URL\(\s*["'`]([^"'`]+)["'`]\s*,\s*import\.meta\.url\s*\)/g
+            ];
+            for (const pattern of patterns){
+                let match;
+                while(match = pattern.exec(source)){
+                    const specifier = String(match[1] || '');
+                    if (!specifier || !specifier.startsWith('.') && !specifier.startsWith('/')) continue;
+                    const resolvedPath = resolveLocalDependencyPath(absoluteFilePath, specifier);
+                    if (resolvedPath) resolvedPaths.add(resolvedPath);
+                }
+            }
+            return Array.from(resolvedPaths);
+        }
+        function resolveLocalDependencyPath(absoluteFilePath, specifier) {
+            const specifierWithoutQuery = String(specifier || '').replace(/[?#].*$/, '');
+            if (!specifierWithoutQuery) return;
+            const basePath = specifierWithoutQuery.startsWith('/') ? specifierWithoutQuery : path__rspack_import_1.resolve(path__rspack_import_1.dirname(absoluteFilePath), specifierWithoutQuery);
+            const candidates = new Set([
+                basePath
+            ]);
+            const extensions = [
+                '.ts',
+                '.tsx',
+                '.mts',
+                '.cts',
+                '.js',
+                '.jsx',
+                '.mjs',
+                '.cjs',
+                '.css',
+                '.scss',
+                '.sass',
+                '.less'
+            ];
+            for (const extension of extensions){
+                candidates.add(`${basePath}${extension}`);
+                candidates.add(path__rspack_import_1.join(basePath, `index${extension}`));
+            }
+            for (const candidate of candidates){
+                const normalizedCandidate = normalizeModuleResourcePath(candidate);
+                if (normalizedCandidate && fs__rspack_import_0.existsSync(normalizedCandidate)) return normalizedCandidate;
+            }
+        }
+        function normalizeModuleResourcePath(resourcePath) {
+            if ('string' != typeof resourcePath || 0 === resourcePath.length) return;
+            let normalized = resourcePath.replace(/\\/g, '/').trim();
+            if (!normalized) return;
+            const loaderIndex = normalized.lastIndexOf('!');
+            if (loaderIndex >= 0) normalized = normalized.slice(loaderIndex + 1);
+            const queryIndex = normalized.search(/[?#]/);
+            if (queryIndex >= 0) normalized = normalized.slice(0, queryIndex);
+            normalized = normalized.trim();
+            return normalized || void 0;
+        }
+        function readContentScriptRules(compilation, extensionRoot) {
+            const manifest = readManifestFromCompilation(compilation) || readManifestFromDisk(extensionRoot) || {};
+            return getContentScriptRulesFromManifest(manifest);
+        }
+        function getContentScriptRulesFromManifest(manifest) {
+            const contentScripts = Array.isArray(manifest?.content_scripts) ? manifest.content_scripts : [];
+            return contentScripts.map((contentScript, index)=>({
+                    index,
+                    world: contentScript?.world === 'MAIN' ? 'main' : 'extension',
+                    matches: normalizeStringArray(contentScript?.matches),
+                    excludeMatches: normalizeStringArray(contentScript?.exclude_matches),
+                    includeGlobs: normalizeStringArray(contentScript?.include_globs),
+                    excludeGlobs: normalizeStringArray(contentScript?.exclude_globs)
+                }));
+        }
+        function selectContentScriptRules(rules, entryNames) {
+            const selectedIndices = new Set();
+            for (const entryName of entryNames){
+                const index = (0, _plugin_web_extension_feature_scripts_contracts__rspack_import_2.WG)(entryName);
+                if (void 0 !== index) selectedIndices.add(index);
+            }
+            return rules.filter((rule)=>selectedIndices.has(rule.index));
+        }
+        function urlMatchesContentScriptRule(rawUrl, rule) {
+            const url = safeParseUrl(rawUrl);
+            if (!url) return false;
+            const hasPositiveMatch = rule.matches.some((pattern)=>urlMatchesPattern(url, pattern)) && (0 === rule.includeGlobs.length || rule.includeGlobs.some((glob)=>urlMatchesGlob(rawUrl, glob)));
+            if (!hasPositiveMatch) return false;
+            if (rule.excludeMatches.some((pattern)=>urlMatchesPattern(url, pattern))) return false;
+            if (rule.excludeGlobs.some((glob)=>urlMatchesGlob(rawUrl, glob))) return false;
+            return true;
+        }
+        function urlMatchesAnyContentScriptRule(rawUrl, rules) {
+            return rules.some((rule)=>urlMatchesContentScriptRule(rawUrl, rule));
+        }
+        function readManifestFromCompilation(compilation) {
+            try {
+                const asset = compilation.getAsset?.('manifest.json');
+                if (!asset?.source) return;
+                return JSON.parse(String(asset.source.source()));
+            } catch  {
+                return;
+            }
+        }
+        function readManifestFromDisk(extensionRoot) {
+            if (!extensionRoot) return;
+            try {
+                const manifestPath = path__rspack_import_1.join(extensionRoot, 'manifest.json');
+                if (!fs__rspack_import_0.existsSync(manifestPath)) return;
+                return JSON.parse(fs__rspack_import_0.readFileSync(manifestPath, 'utf8'));
+            } catch  {
+                return;
+            }
+        }
+        function normalizeStringArray(input) {
+            return Array.isArray(input) ? input.filter((value)=>'string' == typeof value).map((value)=>value.trim()).filter(Boolean) : [];
+        }
+        function safeParseUrl(rawUrl) {
+            try {
+                return new URL(rawUrl);
+            } catch  {
+                return;
+            }
+        }
+        function urlMatchesPattern(url, pattern) {
+            if (!pattern) return false;
+            if ('<all_urls>' === pattern) return /^(https?|file|ftp|ws|wss):$/i.test(url.protocol);
+            const parsedPattern = parseMatchPattern(pattern);
+            if (!parsedPattern) return false;
+            if (!schemeMatches(url, parsedPattern.scheme)) return false;
+            if (!hostMatches(url, parsedPattern.host)) return false;
+            const urlPath = `${url.pathname}${url.search}${url.hash}`;
+            return wildcardToRegExp(parsedPattern.path).test(urlPath);
+        }
+        function parseMatchPattern(pattern) {
+            const match = /^(\*|http|https|file|ftp|ws|wss):\/\/([^/]*)(\/.*)$/.exec(pattern);
+            if (!match) return;
+            return {
+                scheme: match[1],
+                host: match[2],
+                path: match[3]
+            };
+        }
+        function schemeMatches(url, scheme) {
+            const protocol = url.protocol.replace(/:$/, '');
+            if ('*' === scheme) return 'http' === protocol || 'https' === protocol;
+            return protocol === scheme;
+        }
+        function hostMatches(url, hostPattern) {
+            if ('*' === hostPattern) return true;
+            if ('file:' === url.protocol) return '' === hostPattern || '*' === hostPattern;
+            const hostname = url.hostname;
+            if (!hostname) return false;
+            if (hostPattern.startsWith('*.')) {
+                const bareHost = hostPattern.slice(2);
+                return hostname === bareHost || hostname.endsWith(`.${bareHost}`);
+            }
+            return hostname === hostPattern;
+        }
+        function urlMatchesGlob(rawUrl, glob) {
+            return wildcardToRegExp(glob).test(rawUrl);
+        }
+        function wildcardToRegExp(pattern) {
+            const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+            return new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
+        }
+    },
     "./webpack/plugin-browsers/browsers-lib/instance-registry.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -129289,6 +129008,82 @@ var __webpack_modules__ = {
             return null;
         }
     },
+    "./webpack/plugin-browsers/browsers-lib/runtime-options.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            fT: ()=>toExtensionLoadList,
+            pA: ()=>pickSharedBrowserRuntimeOptions,
+            sl: ()=>publishUserExtensionRoot,
+            zU: ()=>buildBrowserLaunchRequest
+        });
+        const sharedBrowserRuntimeOptionKeys = [
+            'extension',
+            'browser',
+            'noOpen',
+            'browserFlags',
+            'excludeBrowserFlags',
+            'profile',
+            'preferences',
+            'startingUrl',
+            'instanceId',
+            'port',
+            'source',
+            'watchSource',
+            'sourceFormat',
+            'sourceSummary',
+            'sourceMeta',
+            'sourceProbe',
+            'sourceTree',
+            'sourceConsole',
+            'sourceDom',
+            'sourceMaxBytes',
+            'sourceRedact',
+            'sourceIncludeShadow',
+            'sourceDiff',
+            'dryRun',
+            'logLevel',
+            'logContexts',
+            'logFormat',
+            'logTimestamps',
+            'logColor',
+            'logUrl',
+            'logTab'
+        ];
+        function pickSharedBrowserRuntimeOptions(options) {
+            return sharedBrowserRuntimeOptionKeys.reduce((picked, key)=>{
+                picked[key] = options[key];
+                return picked;
+            }, {});
+        }
+        function buildBrowserLaunchRequest(options, mode, extras) {
+            return {
+                browser: options.browser,
+                browserFlags: options.browserFlags,
+                excludeBrowserFlags: options.excludeBrowserFlags,
+                profile: options.profile,
+                preferences: options.preferences,
+                startingUrl: options.startingUrl,
+                port: options.port,
+                mode,
+                ...extras || {}
+            };
+        }
+        function toExtensionLoadList(extension) {
+            return Array.isArray(extension) ? [
+                ...extension
+            ] : [
+                extension
+            ];
+        }
+        function publishUserExtensionRoot(extension, setExtensionRoot) {
+            try {
+                const root = [
+                    ...toExtensionLoadList(extension)
+                ].reverse().find((entry)=>'string' == typeof entry);
+                if (root && setExtensionRoot) setExtensionRoot(String(root));
+            } catch  {}
+        }
+    },
     "./webpack/plugin-browsers/browsers-lib/shared-utils.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -129524,6 +129319,7 @@ var __webpack_modules__ = {
         var output_binaries_resolver = __webpack_require__("./webpack/plugin-browsers/browsers-lib/output-binaries-resolver.ts");
         var shared_utils = __webpack_require__("./webpack/plugin-browsers/browsers-lib/shared-utils.ts");
         var banner = __webpack_require__("./webpack/plugin-browsers/browsers-lib/banner.ts");
+        var runtime_options = __webpack_require__("./webpack/plugin-browsers/browsers-lib/runtime-options.ts");
         var dev_server_messages = __webpack_require__("./webpack/dev-server/messages.ts");
         var external_path_ = __webpack_require__("path");
         const masterPreferences = {
@@ -129672,9 +129468,7 @@ var __webpack_modules__ = {
             external_fs_.writeFileSync(preferencesPath, JSON.stringify(mergedPreferences), 'utf8');
         }
         function browserConfig(compilation, configOptions) {
-            const extensionsToLoad = Array.isArray(configOptions.extension) ? configOptions.extension : [
-                configOptions.extension
-            ];
+            const extensionsToLoad = (0, runtime_options.fT)(configOptions.extension);
             const sourceEnabled = !!(configOptions.source || configOptions.watchSource);
             const devWantsCDP = compilation?.options?.mode === 'development';
             const rawProfile = configOptions.profile;
@@ -129916,7 +129710,7 @@ var __webpack_modules__ = {
             const loadExtensionFlag = args.chromiumConfig.find((flag)=>flag.startsWith('--load-extension='));
             const extensionOutputPath = (0, extension_output_path.W)(args.compilation, loadExtensionFlag);
             if (!extensionOutputPath) return;
-            const ready = await (0, manifest_readiness.f)(extensionOutputPath, {
+            const ready = await (0, manifest_readiness.fR)(extensionOutputPath, {
                 timeoutMs: 10000
             });
             if (!ready) return;
@@ -129971,14 +129765,34 @@ var __webpack_modules__ = {
                     const normalized = normalizeBinaryPathForWsl(p);
                     return normalized || null;
                 };
-                try {
-                    const resolved = output_binaries_resolver.kI(compilation, 'chromium' === browser || 'chromium-based' === browser ? 'chromium' : 'edge' === browser ? 'edge' : 'chrome');
-                    const normalized = normalizePath(resolved || null);
-                    if (normalized && external_fs_.existsSync(normalized)) browserBinaryLocation = normalized;
-                } catch  {}
+                const isUsableBinary = (p)=>Boolean(p && external_fs_.existsSync(p));
+                const resolveManagedBinary = ()=>{
+                    try {
+                        const resolved = output_binaries_resolver.kI(compilation, 'chromium' === browser || 'chromium-based' === browser ? 'chromium' : 'edge' === browser ? 'edge' : 'chrome');
+                        const normalized = normalizePath(resolved || null);
+                        return isUsableBinary(normalized) ? normalized : null;
+                    } catch  {
+                        return null;
+                    }
+                };
+                const resolveWslFallback = ()=>resolveWslWindowsBinary(browser);
+                const getInstallGuidanceText = (target)=>{
+                    try {
+                        if ('edge' === target) return (0, external_edge_location_.getInstallGuidance)();
+                        if ('chromium' === target) return (0, external_chromium_location_.getInstallGuidance)();
+                        return (0, external_chrome_location2_.getInstallGuidance)();
+                    } catch  {
+                        return `npx extension install ${target}`;
+                    }
+                };
+                const printInstallGuidance = (raw, browserName)=>{
+                    this.printEnhancedPuppeteerInstallHint(compilation, raw, browserName);
+                    printedGuidance = true;
+                };
+                browserBinaryLocation = resolveManagedBinary();
                 let skipDetection = Boolean(browserBinaryLocation);
                 if (!browserBinaryLocation && isWslEnv()) {
-                    const wslFallback = resolveWslWindowsBinary(browser);
+                    const wslFallback = resolveWslFallback();
                     if (wslFallback) {
                         browserBinaryLocation = wslFallback;
                         skipDetection = true;
@@ -130002,58 +129816,55 @@ var __webpack_modules__ = {
                     if (/\/google-chrome(?:-stable)?$/i.test(p)) return true;
                     return false;
                 };
-                const getInstallGuidanceText = ()=>{
-                    try {
-                        return (0, external_chrome_location2_.getInstallGuidance)();
-                    } catch  {
-                        return 'npx extension install chrome';
-                    }
-                };
                 const managedCacheRoot = output_binaries_resolver.LB(compilation);
                 const managedEnvFor = (b)=>({
                         ...process.env,
                         ...output_binaries_resolver.$4(String(managedCacheRoot), b)
                     });
                 const isAuthorMode = 'true' === process.env.EXTENSION_AUTHOR_MODE;
-                switch(browser){
-                    case 'chrome':
-                        if (isAuthorMode) console.log(messages.GqE(browser));
-                        if (!skipDetection) try {
-                            try {
-                                const env = managedEnvFor('chrome');
-                                const located = external_chrome_location2_default()(true, {
-                                    env
-                                }) || null;
-                                if (!located) throw new Error(getInstallGuidanceText());
-                                const normalized = normalizePath(located || null);
-                                if (normalized && external_fs_.existsSync(normalized)) if (looksOfficialChromeBinaryPath(normalized) && !isWslEnv()) {
-                                    this.printEnhancedPuppeteerInstallHint(compilation, getInstallGuidanceText(), browser);
-                                    printedGuidance = true;
-                                    browserBinaryLocation = null;
-                                } else browserBinaryLocation = normalized;
-                                else browserBinaryLocation = null;
-                            } catch (err) {
-                                const env = managedEnvFor('chrome');
-                                let candidate = external_chrome_location2_default()(true, {
-                                    env
-                                }) || null;
-                                const normalized = normalizePath(candidate || null);
-                                if (normalized) {
-                                    if (looksOfficialChromeBinaryPath(normalized) && !isWslEnv()) {
-                                        this.printEnhancedPuppeteerInstallHint(compilation, getInstallGuidanceText(), browser);
-                                        printedGuidance = true;
-                                        candidate = null;
-                                    }
+                const resolveChromeLikeBinary = ()=>{
+                    try {
+                        try {
+                            const env = managedEnvFor('chrome');
+                            const located = external_chrome_location2_default()(true, {
+                                env
+                            }) || null;
+                            if (!located) throw new Error(getInstallGuidanceText('chrome'));
+                            const normalized = normalizePath(located || null);
+                            if (isUsableBinary(normalized)) {
+                                if (looksOfficialChromeBinaryPath(normalized) && !isWslEnv()) {
+                                    printInstallGuidance(getInstallGuidanceText('chrome'), browser);
+                                    return null;
                                 }
-                                browserBinaryLocation = normalized;
-                                if (!browserBinaryLocation) browserBinaryLocation = resolveWslWindowsBinary(browser);
-                                if (!browserBinaryLocation) throw err;
+                                return normalized;
                             }
-                        } catch (e) {
-                            this.printEnhancedPuppeteerInstallHint(compilation, String(e), browser);
-                            printedGuidance = true;
-                            browserBinaryLocation = null;
+                            return null;
+                        } catch (err) {
+                            const env = managedEnvFor('chrome');
+                            let candidate = external_chrome_location2_default()(true, {
+                                env
+                            }) || null;
+                            const normalized = normalizePath(candidate || null);
+                            if (normalized) {
+                                if (looksOfficialChromeBinaryPath(normalized) && !isWslEnv()) {
+                                    printInstallGuidance(getInstallGuidanceText('chrome'), browser);
+                                    candidate = null;
+                                }
+                            }
+                            const resolved = normalizePath(candidate || null);
+                            const fallback = resolved || resolveWslFallback();
+                            if (!fallback) throw err;
+                            return fallback;
                         }
+                    } catch (error) {
+                        printInstallGuidance(String(error), browser);
+                        return null;
+                    }
+                };
+                switch(browser){
+                    case 'chrome':
+                        if (isAuthorMode) console.log(messages.GqE(browser));
+                        if (!skipDetection) browserBinaryLocation = resolveChromeLikeBinary();
                         break;
                     case 'chromium':
                         if (isAuthorMode) console.log(messages.GqE(browser));
@@ -130076,7 +129887,7 @@ var __webpack_modules__ = {
                                 if (external_fs_.existsSync(normalized)) browserBinaryLocation = normalized;
                             }
                         } catch  {}
-                        if (!browserBinaryLocation) browserBinaryLocation = resolveWslWindowsBinary(browser);
+                        if (!browserBinaryLocation) browserBinaryLocation = resolveWslFallback();
                         break;
                     case 'edge':
                         if (isAuthorMode) console.log(messages.GqE(browser));
@@ -130099,33 +129910,19 @@ var __webpack_modules__ = {
                                         browserBinaryLocation = fallback;
                                         break;
                                     }
-                                    const guidance = (()=>{
-                                        try {
-                                            return (0, external_edge_location_.getInstallGuidance)();
-                                        } catch  {
-                                            return 'npx extension install edge';
-                                        }
-                                    })();
-                                    this.printEnhancedPuppeteerInstallHint(compilation, guidance, 'edge');
-                                    printedGuidance = true;
+                                    const guidance = getInstallGuidanceText('edge');
+                                    printInstallGuidance(guidance, 'edge');
                                     browserBinaryLocation = null;
                                     if (process.env.VITEST || process.env.VITEST_WORKER_ID) throw new Error('Chromium launch failed');
                                     process.exit(1);
                                 }
                             }
                         } catch  {
-                            const guidance = (()=>{
-                                try {
-                                    return (0, external_edge_location_.getInstallGuidance)();
-                                } catch  {
-                                    return 'npx extension install edge';
-                                }
-                            })();
-                            const fallback = resolveWslWindowsBinary(browser);
+                            const guidance = getInstallGuidanceText('edge');
+                            const fallback = resolveWslFallback();
                             if (fallback) browserBinaryLocation = fallback;
                             else {
-                                this.printEnhancedPuppeteerInstallHint(compilation, guidance, 'edge');
-                                printedGuidance = true;
+                                printInstallGuidance(guidance, 'edge');
                                 browserBinaryLocation = null;
                             }
                             if (!browserBinaryLocation) if (process.env.VITEST || process.env.VITEST_WORKER_ID) throw new Error('Chromium launch failed');
@@ -130155,85 +129952,24 @@ var __webpack_modules__ = {
                                 if (external_fs_.existsSync(normalized)) browserBinaryLocation = normalized;
                             }
                         } catch  {}
-                        if (!browserBinaryLocation) browserBinaryLocation = resolveWslWindowsBinary(browser);
+                        if (!browserBinaryLocation) browserBinaryLocation = resolveWslFallback();
                         break;
                     default:
-                        try {
-                            try {
-                                const env = managedEnvFor('chrome');
-                                const located = external_chrome_location2_default()(true, {
-                                    env
-                                }) || null;
-                                if (!located) throw new Error(getInstallGuidanceText());
-                                const normalized = normalizePath(located || null);
-                                if (normalized && external_fs_.existsSync(normalized)) if (looksOfficialChromeBinaryPath(normalized) && !isWslEnv()) {
-                                    this.printEnhancedPuppeteerInstallHint(compilation, getInstallGuidanceText(), browser);
-                                    printedGuidance = true;
-                                    browserBinaryLocation = null;
-                                } else browserBinaryLocation = normalized;
-                                else browserBinaryLocation = null;
-                            } catch (err) {
-                                const env = managedEnvFor('chrome');
-                                let candidate = external_chrome_location2_default()(true, {
-                                    env
-                                }) || null;
-                                const normalized = normalizePath(candidate || null);
-                                if (normalized) {
-                                    if (looksOfficialChromeBinaryPath(normalized) && !isWslEnv()) {
-                                        this.printEnhancedPuppeteerInstallHint(compilation, getInstallGuidanceText(), browser);
-                                        printedGuidance = true;
-                                        candidate = null;
-                                    }
-                                }
-                                browserBinaryLocation = normalized;
-                                if (!browserBinaryLocation) browserBinaryLocation = resolveWslWindowsBinary(browser);
-                                if (!browserBinaryLocation) throw err;
-                            }
-                        } catch (e) {
-                            this.printEnhancedPuppeteerInstallHint(compilation, String(e), browser);
-                            printedGuidance = true;
-                            browserBinaryLocation = null;
-                        }
+                        browserBinaryLocation = resolveChromeLikeBinary();
                         break;
                 }
                 if (!browserBinaryLocation || !external_fs_.existsSync(browserBinaryLocation)) {
-                    try {
-                        const resolved = output_binaries_resolver.kI(compilation, 'chromium' === browser || 'chromium-based' === browser ? 'chromium' : 'edge' === browser ? 'edge' : 'chrome');
-                        const normalized = normalizePath(resolved || null);
-                        if (normalized && external_fs_.existsSync(normalized)) browserBinaryLocation = normalized;
-                    } catch  {}
-                    if (!browserBinaryLocation) browserBinaryLocation = resolveWslWindowsBinary(browser);
+                    browserBinaryLocation = browserBinaryLocation || resolveManagedBinary();
+                    if (!browserBinaryLocation) browserBinaryLocation = resolveWslFallback();
                     if (!browserBinaryLocation || !external_fs_.existsSync(browserBinaryLocation)) {
-                        if ('chromium' === browser || 'chromium-based' === browser) {
-                            const chromiumGuidance = (()=>{
-                                try {
-                                    return (0, external_chromium_location_.getInstallGuidance)();
-                                } catch  {
-                                    return 'npx extension install chromium';
-                                }
-                            })();
-                            this.printEnhancedPuppeteerInstallHint(compilation, chromiumGuidance, 'chromium');
-                            printedGuidance = true;
-                        }
+                        if ('chromium' === browser || 'chromium-based' === browser) printInstallGuidance(getInstallGuidanceText('chromium'), 'chromium');
                         if (!printedGuidance && 'chromium' !== browser && 'chromium-based' !== browser) this.logger.error(messages.IhA(browser, browserBinaryLocation || ''));
                         if (process.env.VITEST || process.env.VITEST_WORKER_ID) throw new Error('Browser not installed or binary path not found');
                         process.exit(1);
                     }
                 }
-                const extensionsToLoad = Array.isArray(this.options.extension) ? [
-                    ...this.options.extension
-                ] : [
-                    this.options.extension
-                ];
-                try {
-                    const last = [
-                        ...extensionsToLoad
-                    ].reverse().find((e)=>'string' == typeof e);
-                    if (last) {
-                        const root = String(last);
-                        this.ctx.setExtensionRoot(root);
-                    }
-                } catch  {}
+                const extensionsToLoad = (0, runtime_options.fT)(this.options.extension);
+                (0, runtime_options.sl)(extensionsToLoad, this.ctx.setExtensionRoot);
                 let chromiumConfig = browserConfig(compilation, {
                     ...this.options,
                     profile: this.options.profile,
@@ -130287,31 +130023,13 @@ var __webpack_modules__ = {
                         }
                     } catch  {}
                     const cdpConfig = {
-                        extension: Array.isArray(this.options.extension) ? this.options.extension : [
-                            this.options.extension
-                        ],
-                        browser: this.options.browser,
-                        port: this.options.port,
-                        instanceId: this.options.instanceId,
+                        ...(0, runtime_options.pA)({
+                            ...this.options,
+                            extension: extensionsToLoad
+                        }),
+                        chromiumBinary: this.options.chromiumBinary,
                         bannerPrintedOnce: false,
-                        logLevel: this.options.logLevel,
-                        logContexts: this.options.logContexts,
-                        logUrl: this.options.logUrl,
-                        logTab: this.options.logTab,
-                        logFormat: this.options.logFormat,
-                        logTimestamps: this.options.logTimestamps,
-                        logColor: this.options.logColor,
                         cdpController: void 0,
-                        noOpen: this.options.noOpen,
-                        browserFlags: this.options.browserFlags,
-                        excludeBrowserFlags: this.options.excludeBrowserFlags,
-                        profile: this.options.profile,
-                        preferences: this.options.preferences,
-                        startingUrl: this.options.startingUrl,
-                        chromiumBinary: this.options.chromiumBinary,
-                        source: this.options.source,
-                        watchSource: this.options.watchSource,
-                        dryRun: this.options.dryRun,
                         browserVersionLine
                     };
                     if (enableCdp) {
@@ -130387,7 +130105,8 @@ var __webpack_modules__ = {
     "./webpack/plugin-browsers/run-chromium/manifest-readiness.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
-            f: ()=>waitForStableManifest
+            aI: ()=>waitForStableExtensionOutput,
+            fR: ()=>waitForStableManifest
         });
         var fs__rspack_import_0 = __webpack_require__("fs");
         var path__rspack_import_1 = __webpack_require__("path");
@@ -130412,6 +130131,15 @@ var __webpack_modules__ = {
             if (/[*?[\]{}]/.test(normalized)) return;
             return normalized;
         }
+        function readStableFileSignature(filePath) {
+            try {
+                const stats = fs__rspack_import_0.statSync(filePath);
+                if (!stats.isFile()) return;
+                return `${stats.size}:${stats.mtimeMs}`;
+            } catch  {
+                return;
+            }
+        }
         function getManifestRequiredFiles(content) {
             try {
                 const manifest = JSON.parse(content);
@@ -130465,6 +130193,52 @@ var __webpack_modules__ = {
             }
             return false;
         }
+        async function waitForStableFiles(outPath, relativeFiles, options) {
+            const files = Array.from(new Set(relativeFiles.map(normalizeManifestFile).filter(Boolean)));
+            if (0 === files.length) return true;
+            const timeoutMs = options?.timeoutMs ?? 8000;
+            const pollIntervalMs = options?.pollIntervalMs ?? 150;
+            const stableReadsRequired = options?.stableReadsRequired ?? 2;
+            const start = Date.now();
+            let lastSignature = '';
+            let stableReads = 0;
+            while(Date.now() - start < timeoutMs){
+                const currentSignatureParts = [];
+                let allFilesReady = true;
+                for (const relativeFile of files){
+                    const absoluteFilePath = path__rspack_import_1.join(outPath, relativeFile);
+                    const fileSignature = readStableFileSignature(absoluteFilePath);
+                    if (!fileSignature) {
+                        allFilesReady = false;
+                        break;
+                    }
+                    currentSignatureParts.push(`${relativeFile}:${fileSignature}`);
+                }
+                if (allFilesReady) {
+                    const currentSignature = currentSignatureParts.sort().join('|');
+                    if (currentSignature === lastSignature) stableReads += 1;
+                    else {
+                        lastSignature = currentSignature;
+                        stableReads = 1;
+                    }
+                    if (stableReads >= stableReadsRequired) return true;
+                } else {
+                    lastSignature = '';
+                    stableReads = 0;
+                }
+                await sleep(pollIntervalMs);
+            }
+            return false;
+        }
+        async function waitForStableExtensionOutput(outPath, options) {
+            const manifestPath = path__rspack_import_1.join(outPath, 'manifest.json');
+            const manifestReady = await waitForStableManifest(outPath, options);
+            if (!manifestReady) return false;
+            const manifestContent = readValidManifest(manifestPath);
+            if (!manifestContent) return false;
+            const requiredFiles = getManifestRequiredFiles(manifestContent);
+            return waitForStableFiles(outPath, requiredFiles, options);
+        }
     },
     "./webpack/plugin-browsers/run-firefox/firefox-context/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
@@ -130531,6 +130305,7 @@ var __webpack_modules__ = {
         var shared_utils = __webpack_require__("./webpack/plugin-browsers/browsers-lib/shared-utils.ts");
         var instance_registry = __webpack_require__("./webpack/plugin-browsers/browsers-lib/instance-registry.ts");
         var dev_server_messages = __webpack_require__("./webpack/dev-server/messages.ts");
+        var runtime_options = __webpack_require__("./webpack/plugin-browsers/browsers-lib/runtime-options.ts");
         var external_child_process_ = __webpack_require__("child_process");
         function setupFirefoxProcessHandlers(browser, childRef, cleanupInstance) {
             let isCleaningUp = false;
@@ -130589,6 +130364,8 @@ var __webpack_modules__ = {
                 process.exit(1);
             });
         }
+        var external_path_ = __webpack_require__("path");
+        var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_);
         var messaging_client = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/messaging-client.ts");
         function requestErrorToMessage(error) {
             if (error instanceof Error) return String(error);
@@ -130607,7 +130384,6 @@ var __webpack_modules__ = {
             return code === codeWanted;
         }
         var firefox_utils = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/firefox-utils.ts");
-        var external_path_ = __webpack_require__("path");
         function resolveAddonDirectory(baseDir, inputPath) {
             let candidate = inputPath.replace(/\"/g, '');
             if (!external_path_.isAbsolute(candidate)) candidate = external_path_.resolve(baseDir, candidate);
@@ -130689,6 +130465,8 @@ var __webpack_modules__ = {
         }
         var logging = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/logging.ts");
         var source_inspect = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/source-inspect.ts");
+        var content_script_targets = __webpack_require__("./webpack/plugin-browsers/browsers-lib/content-script-targets.ts");
+        var manifest_readiness = __webpack_require__("./webpack/plugin-browsers/run-chromium/manifest-readiness.ts");
         function _define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
                 value: value,
@@ -130699,9 +130477,48 @@ var __webpack_modules__ = {
             else obj[key] = value;
             return obj;
         }
+        function emitFirefoxAgentDebugLog(payload) {
+            const line = JSON.stringify({
+                sessionId: 'a87efc',
+                timestamp: Date.now(),
+                ...payload
+            });
+            fetch('http://127.0.0.1:7795/ingest/9eb8f923-a325-4455-a46c-a6e706558307', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Debug-Session-Id': 'a87efc'
+                },
+                body: line
+            }).catch(()=>{});
+            try {
+                let dir = external_path_default().resolve(process.cwd());
+                for(let depth = 0; depth < 24; depth++){
+                    if ((0, external_fs_.existsSync)(external_path_default().join(dir, 'programs', 'develop', 'package.json'))) {
+                        const filePath = external_path_default().join(dir, '.cursor', 'debug-a87efc.log');
+                        (0, external_fs_.mkdirSync)(external_path_default().dirname(filePath), {
+                            recursive: true
+                        });
+                        (0, external_fs_.appendFileSync)(filePath, `${line}\n`);
+                        return;
+                    }
+                    const parent = external_path_default().dirname(dir);
+                    if (parent === dir) break;
+                    dir = parent;
+                }
+            } catch  {}
+        }
         const MAX_RETRIES = 150;
         const RETRY_INTERVAL = 1000;
         class RemoteFirefox {
+            selectPrimaryAddonPath(compilation, candidateAddonPaths) {
+                const normalizedOutputPath = String(compilation?.options?.output?.path || '').replace(/\\/g, '/');
+                if (normalizedOutputPath) {
+                    const matchingAddonPath = candidateAddonPaths.find((candidateAddonPath)=>String(candidateAddonPath || '').replace(/\\/g, '/') === normalizedOutputPath);
+                    if (matchingAddonPath) return matchingAddonPath;
+                }
+                return candidateAddonPaths[candidateAddonPaths.length - 1];
+            }
             resolveRdpPort(compilation) {
                 const instanceId = this.options?.instanceId;
                 const devPort = compilation?.options?.devServer?.port;
@@ -130736,9 +130553,7 @@ var __webpack_modules__ = {
             }
             async installAddons(compilation) {
                 const { devtools } = this.options;
-                const rawExtensions = (Array.isArray(this.options.extensionsToLoad) && this.options.extensionsToLoad.length ? this.options.extensionsToLoad : void 0) || (Array.isArray(this.options.extension) ? this.options.extension : [
-                    this.options.extension
-                ]);
+                const rawExtensions = (0, runtime_options.fT)(this.options.extension);
                 const unique = Array.from(new Set(rawExtensions.filter((p)=>'string' == typeof p && p.length > 0)));
                 const userFirst = unique.sort((a, b)=>{
                     const isAManager = /extensions\/[a-z-]+-manager/.test(a);
@@ -130753,31 +130568,71 @@ var __webpack_modules__ = {
                 let addonsActor = await getAddonsActorWithRetry(client, this.cachedAddonsActor);
                 if (addonsActor) this.cachedAddonsActor = addonsActor;
                 const candidateAddonPaths = computeCandidateAddonPaths(compilation, extensionsToLoad);
+                const primaryAddonPath = this.selectPrimaryAddonPath(compilation, candidateAddonPaths);
+                try {
+                    const outPath = String(compilation?.options?.output?.path || '').replace(/\\/g, '/');
+                    emitFirefoxAgentDebugLog({
+                        runId: process.env.EXTENSION_INSTANCE_ID || 'firefox-install',
+                        hypothesisId: 'H-COMP-3',
+                        location: 'remote-firefox/index.ts:installAddons:paths',
+                        message: 'Firefox candidate add-on paths and primary selection',
+                        data: {
+                            normalizedOutputPath: outPath,
+                            primaryAddonPath: primaryAddonPath ? String(primaryAddonPath).replace(/\\/g, '/') : null,
+                            candidateAddonPaths: candidateAddonPaths.map((p)=>String(p).replace(/\\/g, '/')),
+                            devtools: Boolean(devtools)
+                        }
+                    });
+                } catch  {}
+                for (const addonPath of candidateAddonPaths)try {
+                    const ready = await (0, manifest_readiness.aI)(addonPath, {
+                        timeoutMs: 10000,
+                        pollIntervalMs: 150,
+                        stableReadsRequired: 2
+                    });
+                    if (!ready && 'true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(`[plugin-browsers] Firefox add-on output did not fully settle before install: ${addonPath}`);
+                } catch  {}
                 if ('true' === process.env.EXTENSION_AUTHOR_MODE) try {
                     console.log('[plugin-browsers] Firefox add-on paths:', candidateAddonPaths);
                 } catch  {}
+                let primaryUserAddonId;
                 for (const [index, addonPath] of candidateAddonPaths.entries()){
                     const isManager = /extensions\/[a-z-]+-manager/.test(String(addonPath));
                     const isDevtoolsEnabled = 0 === index && Boolean(devtools);
                     try {
                         const installResponse = await installTemporaryAddon(client, String(addonsActor || ''), addonPath, isDevtoolsEnabled);
-                        if (!this.derivedExtensionId) {
-                            const maybeId = installResponse?.addon?.id;
-                            if ('string' == typeof maybeId && maybeId.length > 0) this.derivedExtensionId = maybeId;
-                        }
+                        const maybeIdRaw = installResponse?.addon?.id;
+                        const maybeId = 'string' == typeof maybeIdRaw && maybeIdRaw.length > 0 ? maybeIdRaw : null;
+                        if (primaryAddonPath && String(addonPath) === String(primaryAddonPath) && maybeId) primaryUserAddonId = maybeId;
+                        emitFirefoxAgentDebugLog({
+                            runId: process.env.EXTENSION_INSTANCE_ID || 'firefox-install',
+                            hypothesisId: 'H-COMP-1',
+                            location: 'remote-firefox/index.ts:installAddons:each',
+                            message: 'Firefox temporary add-on installed',
+                            data: {
+                                index,
+                                addonPath: String(addonPath).replace(/\\/g, '/'),
+                                isManager,
+                                isDevtoolsEnabled,
+                                addonId: maybeId,
+                                setDerivedExtensionIdFromThisInstall: Boolean(primaryAddonPath && String(addonPath) === String(primaryAddonPath) && maybeId),
+                                matchesPrimary: Boolean(primaryAddonPath) && String(addonPath) === String(primaryAddonPath)
+                            }
+                        });
                         if (isManager) await waitForManagerWelcome(client);
                     } catch (err) {
                         const message = requestErrorToMessage(err);
                         throw new Error(messages.WVu(this.options.browser, message));
                     }
                 }
+                if (primaryUserAddonId) this.derivedExtensionId = primaryUserAddonId;
                 try {
-                    if (this.needsReinstall && candidateAddonPaths[0]) {
+                    if (this.needsReinstall && primaryAddonPath) {
                         const toActor = addonsActor;
                         if (toActor) await client.request({
                             to: toActor,
                             type: 'installTemporaryAddon',
-                            addonPath: candidateAddonPaths[0],
+                            addonPath: primaryAddonPath,
                             openDevTools: false
                         });
                         this.needsReinstall = false;
@@ -130786,7 +130641,17 @@ var __webpack_modules__ = {
                 try {
                     if (!this.derivedExtensionId) this.derivedExtensionId = await deriveMozExtensionId(client);
                 } catch  {}
-                this.lastInstalledAddonPath = candidateAddonPaths[0];
+                emitFirefoxAgentDebugLog({
+                    runId: process.env.EXTENSION_INSTANCE_ID || 'firefox-install',
+                    hypothesisId: 'H-COMP-2',
+                    location: 'remote-firefox/index.ts:installAddons:derived-id',
+                    message: 'Firefox derivedExtensionId after installs + deriveMozExtensionId',
+                    data: {
+                        derivedExtensionId: this.derivedExtensionId || null,
+                        lastInstalledAddonPath: primaryAddonPath ? String(primaryAddonPath).replace(/\\/g, '/') : null
+                    }
+                });
+                this.lastInstalledAddonPath = primaryAddonPath;
                 const bannerPrinted = await (0, firefox_utils.Rv)(candidateAddonPaths, 'firefox', this.derivedExtensionId, this.options.browserVersionLine);
                 if (!bannerPrinted) throw new Error(messages.WVu(this.options.browser, 'Failed to print runningInDevelopment banner; add-on may not be installed.'));
             }
@@ -130804,7 +130669,7 @@ var __webpack_modules__ = {
                     });
                     const types = Array.isArray(desc?.types) ? desc.types : [];
                     this.cachedSupportsReload = types.includes('reloadAddon') || types.includes('reloadTemporaryAddon');
-                    try {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) try {
                         console.log(messages.lID(this.cachedSupportsReload ? 'native' : 'reinstall'));
                     } catch  {}
                 } catch  {
@@ -130845,7 +130710,7 @@ var __webpack_modules__ = {
                     const normalized = (changedAssets || []).map((n)=>String(n || '')).map((n)=>n.replace(/\\/g, '/'));
                     const isManifestChanged = normalized.includes('manifest.json');
                     const isLocalesChanged = normalized.some((n)=>/(^|\/)__?locales\/.+\.json$/i.test(n));
-                    const isContentScriptChanged = normalized.some((n)=>/(^|\/)content_scripts\/content-\d+\.(js|css)$/i.test(n));
+                    const isContentScriptChanged = normalized.some((n)=>/(^|\/)content_scripts\/content-\d+(?:\.[a-f0-9]+)?\.(js|css)$/i.test(n));
                     let isServiceWorkerChanged = false;
                     try {
                         const manifestAsset = compilation.getAsset?.('manifest.json');
@@ -130864,6 +130729,48 @@ var __webpack_modules__ = {
                     await this.reloadAddonOrReinstall(client);
                 } catch  {}
             }
+            async reloadMatchingTabsForContentScripts(rules) {
+                if (0 === rules.length) return 0;
+                try {
+                    const rdpPort = this.resolveRdpPort();
+                    const client = this.client || await this.connectClient(rdpPort);
+                    await this.reloadAddonOrReinstall(client);
+                    await new Promise((resolve)=>setTimeout(resolve, 300));
+                    const tabs = await client.getTargets();
+                    let reloadedTabs = 0;
+                    for (const tab of tabs || []){
+                        const descriptorActor = String(tab?.actor || '');
+                        const descriptorConsoleActor = String(tab?.consoleActor || tab?.webConsoleActor || '');
+                        const url = String(tab?.url || '');
+                        if (!descriptorActor || !url) continue;
+                        if (!(0, content_script_targets.lM)(url, rules)) continue;
+                        let targetActor = descriptorActor;
+                        let consoleActor = descriptorConsoleActor;
+                        try {
+                            const detail = await client.getTargetFromDescriptor(descriptorActor);
+                            if (detail.targetActor) targetActor = detail.targetActor;
+                            if (detail.consoleActor) consoleActor = detail.consoleActor;
+                        } catch  {}
+                        try {
+                            try {
+                                await client.attach(targetActor);
+                            } catch  {}
+                            await client.navigate(targetActor, url);
+                            await client.waitForLoadEvent(targetActor);
+                            reloadedTabs += 1;
+                        } catch  {
+                            if (!consoleActor) continue;
+                            try {
+                                await client.navigateViaScript(consoleActor, url);
+                                reloadedTabs += 1;
+                            } catch  {}
+                        }
+                    }
+                    return reloadedTabs;
+                } catch  {
+                    return 0;
+                }
+            }
             async inspectSource(compilation, opts) {
                 try {
                     const rdpPort = this.resolveRdpPort(compilation);
@@ -130939,6 +130846,9 @@ var __webpack_modules__ = {
                 if ('function' == typeof rf.hardReloadIfNeeded) await rf.hardReloadIfNeeded(compilation, changedAssets);
                 else await this.remote.installAddons(compilation);
             }
+            async reloadMatchingTabsForContentScripts(rules) {
+                return this.remote.reloadMatchingTabsForContentScripts(rules);
+            }
             async enableUnifiedLogging(opts) {
                 await this.remote.enableUnifiedLogging(opts);
             }
@@ -130947,7 +130857,6 @@ var __webpack_modules__ = {
                 rdp_extension_controller_define_property(this, "debugPort", void 0);
                 this.remote = new RemoteFirefox({
                     extension: plugin.extension,
-                    extensionsToLoad: plugin.extensionsToLoad,
                     browser: plugin.browser,
                     browserFlags: plugin.browserFlags,
                     profile: plugin.profile,
@@ -131075,7 +130984,7 @@ var __webpack_modules__ = {
             const excludeFlags = configOptions.excludeBrowserFlags || [];
             const filteredFlags = (browserFlags || []).filter((flag)=>excludeFlags.every((ex)=>!String(flag).startsWith(ex)));
             if (filteredFlags.length > 0) binaryArgs.push(...filteredFlags);
-            if (configOptions.startingUrl && !configOptions.noOpen) binaryArgs.push(String(configOptions.startingUrl));
+            if (configOptions.startingUrl && !configOptions.noOpen) binaryArgs.push('--url', String(configOptions.startingUrl));
             const outPath = compilation.options.output?.path || external_path_.resolve(process.cwd(), 'dist/firefox');
             const distRoot = external_path_.dirname(outPath);
             const useSystemProfile = 'true' === String(process.env.EXTENSION_USE_SYSTEM_PROFILE || process.env.EXTJS_USE_SYSTEM_PROFILE || '').toLowerCase().trim();
@@ -131297,15 +131206,7 @@ var __webpack_modules__ = {
                             return;
                         }
                         if (this.ctx.didLaunch) return void done();
-                        await this.launch(stats.compilation, {
-                            browser: this.host.browser,
-                            browserFlags: this.host.browserFlags,
-                            profile: this.host.profile,
-                            preferences: this.host.preferences,
-                            startingUrl: this.host.startingUrl,
-                            mode: stats.compilation.options.mode,
-                            port: this.host.port
-                        });
+                        await this.launch(stats.compilation, (0, runtime_options.zU)(this.host, stats.compilation.options.mode));
                         this.ctx.logger?.info?.(messages.ACl(this.host.browser, stats.compilation.options.mode));
                         this.ctx.logger?.info?.(dev_server_messages.Gc(stats.compilation.options.mode, this.host.browser));
                         this.ctx.didLaunch = true;
@@ -131321,21 +131222,40 @@ var __webpack_modules__ = {
                 const compilationErrors = compilation?.errors || [];
                 if (compilationErrors.length > 0) return void this.ctx.logger?.info?.(messages.y7j());
                 if ('true' === process.env.EXTENSION_AUTHOR_MODE) this.ctx.logger?.info?.(messages.A9Y());
+                const normalizePath = (value)=>{
+                    const normalized = value ? normalizeBinaryPathForWsl(value) : null;
+                    return normalized && external_fs_.existsSync(normalized) ? normalized : null;
+                };
+                const resolveManagedBinary = ()=>normalizePath((0, output_binaries_resolver.kI)(compilation, 'firefox') || null);
+                const resolveWslFallback = ()=>resolveWslWindowsBinary();
+                const getInstallGuidanceText = ()=>{
+                    try {
+                        return (0, external_firefox_location2_.getInstallGuidance)();
+                    } catch  {
+                        return 'npx extension install firefox';
+                    }
+                };
+                const exitForLaunchFailure = (message)=>{
+                    if (message) console.error(message);
+                    process.exit(1);
+                };
+                const getGeckoBinaryErrorMessage = ()=>this.host.geckoBinary ? messages.DhR(this.host.geckoBinary) : messages.jk4();
+                const failGeckoBinaryRequirement = ()=>exitForLaunchFailure(getGeckoBinaryErrorMessage());
+                const throwOrExitNotInstalled = ()=>{
+                    if (process.env.VITEST || process.env.VITEST_WORKER_ID) throw new Error('Firefox not installed or binary path not found');
+                    process.exit(1);
+                };
                 if (this.host.dryRun || process.env.VITEST || process.env.VITEST_WORKER_ID) {
                     try {
                         logFirefoxDryRun('firefox-mock-binary', '--binary-args=""');
                     } catch  {}
                     return;
                 }
-                let browserBinaryLocation = (0, output_binaries_resolver.kI)(compilation, 'firefox') || null;
-                if (browserBinaryLocation) {
-                    const normalized = normalizeBinaryPathForWsl(browserBinaryLocation);
-                    browserBinaryLocation = normalized && external_fs_.existsSync(normalized) ? normalized : null;
-                }
+                let browserBinaryLocation = resolveManagedBinary();
                 let skipDetection = Boolean(browserBinaryLocation);
                 const engineBased = 'gecko-based' === this.host.browser || 'firefox-based' === this.host.browser;
                 if (!browserBinaryLocation && !engineBased && isWslEnv()) {
-                    const wslFallback = resolveWslWindowsBinary();
+                    const wslFallback = resolveWslFallback();
                     if (wslFallback) {
                         browserBinaryLocation = wslFallback;
                         skipDetection = true;
@@ -131343,16 +131263,11 @@ var __webpack_modules__ = {
                 }
                 try {
                     if (this.host.geckoBinary && 'string' == typeof this.host.geckoBinary) {
-                        const normalized = normalizeBinaryPathForWsl(this.host.geckoBinary);
-                        if (normalized && external_fs_.existsSync(normalized)) browserBinaryLocation = normalized;
-                        else {
-                            console.error(messages.DhR(this.host.geckoBinary));
-                            process.exit(1);
-                        }
-                    } else if (!skipDetection) if (engineBased) {
-                        console.error(messages.jk4());
-                        process.exit(1);
-                    } else {
+                        const normalized = normalizePath(this.host.geckoBinary);
+                        if (normalized) browserBinaryLocation = normalized;
+                        else failGeckoBinaryRequirement();
+                    } else if (!skipDetection) if (engineBased) failGeckoBinaryRequirement();
+                    else {
                         const cacheRoot = (0, output_binaries_resolver.LB)(compilation);
                         const env = {
                             ...process.env,
@@ -131361,39 +131276,27 @@ var __webpack_modules__ = {
                         const located = external_firefox_location2_default()(true, {
                             env
                         });
-                        const normalized = located ? normalizeBinaryPathForWsl(located) : null;
-                        if (normalized && external_fs_.existsSync(normalized)) browserBinaryLocation = normalized;
+                        const normalized = normalizePath(located);
+                        if (normalized) browserBinaryLocation = normalized;
                     }
                 } catch (_error) {
-                    console.error(this.host.geckoBinary ? messages.DhR(this.host.geckoBinary) : messages.jk4());
-                    process.exit(1);
+                    failGeckoBinaryRequirement();
                 }
                 if (!browserBinaryLocation || !browserBinaryLocation.trim() || !external_fs_.existsSync(browserBinaryLocation)) {
-                    const fallback = (0, output_binaries_resolver.kI)(compilation, 'firefox');
-                    const normalizedFallback = fallback ? normalizeBinaryPathForWsl(fallback) : null;
-                    if (normalizedFallback && external_fs_.existsSync(normalizedFallback)) browserBinaryLocation = normalizedFallback;
-                    else if (engineBased || this.host.geckoBinary) {
-                        console.error(this.host.geckoBinary ? messages.DhR(this.host.geckoBinary) : messages.jk4());
-                        process.exit(1);
-                    } else {
-                        const wslFallback = resolveWslWindowsBinary();
+                    const normalizedFallback = resolveManagedBinary();
+                    if (normalizedFallback) browserBinaryLocation = normalizedFallback;
+                    else if (engineBased || this.host.geckoBinary) failGeckoBinaryRequirement();
+                    else {
+                        const wslFallback = resolveWslFallback();
                         if (wslFallback) browserBinaryLocation = wslFallback;
                         else {
-                            const guidance = (()=>{
-                                try {
-                                    return (0, external_firefox_location2_.getInstallGuidance)();
-                                } catch  {
-                                    return 'npx extension install firefox';
-                                }
-                            })();
-                            this.printInstallHint(compilation, guidance);
-                            if (process.env.VITEST || process.env.VITEST_WORKER_ID) throw new Error('Firefox not installed or binary path not found');
-                            process.exit(1);
+                            this.printInstallHint(compilation, getInstallGuidanceText());
+                            throwOrExitNotInstalled();
                         }
                     }
                 }
                 const binaryPath = browserBinaryLocation;
-                const wslFallbackBinary = isWslEnv() && !engineBased ? resolveWslWindowsBinary() : null;
+                const wslFallbackBinary = isWslEnv() && !engineBased ? resolveWslFallback() : null;
                 try {
                     this.host.browserVersionLine = (0, external_firefox_location2_.getFirefoxVersion)(binaryPath, {
                         allowExec: true
@@ -131402,17 +131305,8 @@ var __webpack_modules__ = {
                 try {
                     await FirefoxBinaryDetector.validateFirefoxBinary(binaryPath);
                 } catch  {}
-                const extensionsToLoad = Array.isArray(this.host.extension) ? [
-                    ...this.host.extension
-                ] : [
-                    this.host.extension
-                ];
-                try {
-                    const last = [
-                        ...extensionsToLoad
-                    ].reverse().find((e)=>'string' == typeof e);
-                    if (last && 'function' == typeof this.ctx.setExtensionRoot) this.ctx.setExtensionRoot(String(last));
-                } catch  {}
+                const extensionsToLoad = (0, runtime_options.fT)(this.host.extension);
+                (0, runtime_options.sl)(extensionsToLoad, 'function' == typeof this.ctx.setExtensionRoot ? this.ctx.setExtensionRoot : void 0);
                 const desiredDebugPort = (0, shared_utils.jl)(this.host.port, this.host.instanceId);
                 const debugPort = await (0, shared_utils.aY)(desiredDebugPort);
                 (0, instance_registry.UF)(this.host.instanceId, {
@@ -131438,32 +131332,9 @@ var __webpack_modules__ = {
                 if (profileMatch) {
                     const profilePath = profileMatch[1];
                     const { binary, args } = FirefoxBinaryDetector.generateFirefoxArgs(binaryPath, profilePath, debugPort, firefoxArgs);
-                    const isWin = 'win32' === process.platform;
-                    const stdio = isWin ? 'true' === process.env.EXTENSION_AUTHOR_MODE ? [
-                        'pipe',
-                        'pipe',
-                        'pipe'
-                    ] : [
-                        'ignore',
-                        'ignore',
-                        'ignore'
-                    ] : [
-                        'pipe',
-                        'pipe',
-                        'pipe'
-                    ];
-                    this.child = await spawnFirefoxProcess({
-                        binary,
-                        args,
-                        stdio,
-                        fallbackBinary: wslFallbackBinary,
-                        logger: this.ctx.logger
-                    });
-                    this.wireChildLifecycle(compilation, debugPort, desiredDebugPort);
-                    const ctrl = await setupRdpAfterLaunch({
-                        ...this.host,
-                        extensionsToLoad
-                    }, compilation, debugPort);
+                    this.child = await this.spawnFirefoxChild(binary, args, wslFallbackBinary);
+                    this.wireChildLifecycle();
+                    const ctrl = await setupRdpAfterLaunch(this.host, compilation, debugPort);
                     this.host.rdpController = ctrl;
                     this.ctx.setController(ctrl, debugPort);
                     this.scheduleWatchTimeout();
@@ -131489,32 +131360,42 @@ var __webpack_modules__ = {
                         '--disable-renderer-backgrounding',
                         ...firefoxArgs
                     ];
-                    const isWin = 'win32' === process.platform;
-                    const stdio = isWin ? 'true' === process.env.EXTENSION_AUTHOR_MODE ? [
-                        'pipe',
-                        'pipe',
-                        'pipe'
-                    ] : [
-                        'ignore',
-                        'ignore',
-                        'ignore'
-                    ] : [
-                        'pipe',
-                        'pipe',
-                        'pipe'
-                    ];
-                    this.child = await spawnFirefoxProcess({
-                        binary: binaryPath,
-                        args,
-                        stdio,
-                        fallbackBinary: wslFallbackBinary,
-                        logger: this.ctx.logger
-                    });
-                    this.wireChildLifecycle(compilation, debugPort, desiredDebugPort);
+                    this.child = await this.spawnFirefoxChild(binaryPath, args, wslFallbackBinary);
+                    this.wireChildLifecycle();
                     this.scheduleWatchTimeout();
                 }
             }
-            wireChildLifecycle(compilation, debugPort, desiredDebugPort) {
+            resolveSpawnStdio() {
+                if ('win32' !== process.platform) return [
+                    'pipe',
+                    'pipe',
+                    'pipe'
+                ];
+                return 'true' === process.env.EXTENSION_AUTHOR_MODE ? [
+                    'pipe',
+                    'pipe',
+                    'pipe'
+                ] : [
+                    'ignore',
+                    'ignore',
+                    'ignore'
+                ];
+            }
+            async spawnFirefoxChild(binary, args, fallbackBinary) {
+                return await spawnFirefoxProcess({
+                    binary,
+                    args,
+                    stdio: this.resolveSpawnStdio(),
+                    fallbackBinary,
+                    logger: this.ctx.logger
+                });
+            }
+            pipeChildOutput(child) {
+                if ('true' !== process.env.EXTENSION_AUTHOR_MODE) return;
+                child.stdout?.pipe(process.stdout);
+                child.stderr?.pipe(process.stderr);
+            }
+            wireChildLifecycle() {
                 const child = this.child;
                 if (!child) return;
                 child.on('error', (error)=>{
@@ -131530,10 +131411,7 @@ var __webpack_modules__ = {
                     if ('true' === process.env.EXTENSION_AUTHOR_MODE) this.ctx.logger?.info?.(messages.Tho(this.host.browser));
                     this.cleanupInstance().catch(()=>{});
                 });
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE && child) {
-                    child.stdout?.pipe(process.stdout);
-                    child.stderr?.pipe(process.stderr);
-                }
+                this.pipeChildOutput(child);
                 setupFirefoxProcessHandlers(this.host.browser, ()=>this.child, ()=>this.cleanupInstance());
             }
             async cleanupInstance() {
@@ -131585,6 +131463,277 @@ var __webpack_modules__ = {
             }
         }
     },
+    "./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/evaluate.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            QX: ()=>mergeShadowIntoMain,
+            XT: ()=>resolveActorForEvaluation,
+            _3: ()=>evaluate,
+            _e: ()=>evaluateRaw,
+            jU: ()=>extractShadowContent,
+            vA: ()=>coerceResponseToString,
+            wt: ()=>serializeDocument
+        });
+        __webpack_require__("./webpack/plugin-browsers/browsers-lib/messages.ts");
+        const EVALUATION_TIMEOUT_MS = 8000;
+        const EVALUATION_TYPES = [
+            'evaluateJSAsync',
+            'evalWithOptions',
+            'evaluateJS',
+            'eval'
+        ];
+        function buildEvaluationPayload(tabId, expression, type) {
+            const payload = {
+                to: tabId,
+                type,
+                text: expression
+            };
+            if ('evalWithOptions' === type) payload.options = {
+                url: '',
+                selectedNodeActor: void 0,
+                frameActor: void 0
+            };
+            return payload;
+        }
+        function getMessageUnsubscriber(client, listener) {
+            if ('function' != typeof client.on) return;
+            client.on('message', listener);
+            return ()=>{
+                if ('function' == typeof client.off) return void client.off('message', listener);
+                if ('function' == typeof client.removeListener) client.removeListener('message', listener);
+            };
+        }
+        async function requestEvaluation(client, tabId, expression, type) {
+            if ('evaluateJSAsync' !== type) return await client.request(buildEvaluationPayload(tabId, expression, type));
+            let expectedResultId = '';
+            let cleanup = ()=>{};
+            let pendingMessage;
+            const asyncResult = new Promise((resolve)=>{
+                const unsubscribe = getMessageUnsubscriber(client, onMessage);
+                if (!unsubscribe) return void resolve({
+                    ok: false,
+                    error: new Error('RDP client does not support async evaluation events')
+                });
+                const timeout = setTimeout(()=>{
+                    unsubscribe();
+                    resolve({
+                        ok: false,
+                        error: new Error('Timed out waiting for Firefox async evaluation result')
+                    });
+                }, EVALUATION_TIMEOUT_MS);
+                cleanup = ()=>{
+                    clearTimeout(timeout);
+                    unsubscribe();
+                };
+                function onMessage(message) {
+                    const payload = message || {};
+                    if ('evaluationResult' !== payload.type) return;
+                    if (!expectedResultId) {
+                        pendingMessage = payload;
+                        return;
+                    }
+                    if (String(payload.resultID || '') !== expectedResultId) return;
+                    cleanup();
+                    payload.error ? resolve({
+                        ok: false,
+                        error: payload
+                    }) : resolve({
+                        ok: true,
+                        value: message
+                    });
+                }
+            });
+            try {
+                const response = await client.request(buildEvaluationPayload(tabId, expression, type));
+                if (response?.type === 'evaluationResult') {
+                    cleanup();
+                    return response;
+                }
+                expectedResultId = String(response?.resultID || '');
+                if (!expectedResultId) {
+                    cleanup();
+                    return response;
+                }
+                if (pendingMessage && String(pendingMessage.resultID || '') === expectedResultId) {
+                    cleanup();
+                    return pendingMessage;
+                }
+                const outcome = await asyncResult;
+                if (!outcome.ok) throw outcome.error;
+                return outcome.value;
+            } catch (error) {
+                cleanup();
+                throw error;
+            }
+        }
+        async function evaluate(client, tabId, expression) {
+            let lastError = null;
+            for (const type of EVALUATION_TYPES)try {
+                const response = await requestEvaluation(client, tabId, expression, type);
+                const r = response ?? {};
+                if (void 0 !== r.result) return r.result;
+                if (void 0 !== r.value) return r.value;
+                return r;
+            } catch (err) {
+                lastError = err;
+            }
+            throw lastError || new Error('Failed to evaluate expression');
+        }
+        async function evaluateRaw(client, tabId, expression) {
+            let lastError = null;
+            for (const type of EVALUATION_TYPES)try {
+                return await requestEvaluation(client, tabId, expression, type);
+            } catch (err) {
+                lastError = err;
+            }
+            throw lastError || new Error('Failed to evaluate expression (raw)');
+        }
+        async function coerceResponseToString(client, tabId, response, opts = {
+            fallbackToFullDocument: true
+        }) {
+            const r = response ?? {};
+            const value = r.result ?? r.value ?? r;
+            if ('string' == typeof value) return value;
+            if (value && 'string' == typeof value.value) return value.value;
+            if (value && 'string' == typeof value.text) return value.text;
+            if (value && value.preview && 'string' == typeof value.preview.text) return value.preview.text;
+            if (value && 'longString' === value.type) {
+                const initial = value.initial || '';
+                const length = 'number' == typeof value.length ? value.length : initial.length;
+                const actor = value.actor;
+                if (actor && 'number' == typeof length) try {
+                    const full = await client.request({
+                        to: actor,
+                        type: 'substring',
+                        start: 0,
+                        end: length
+                    });
+                    if (full && 'string' == typeof full.substring) return full.substring;
+                } catch  {}
+                return String(initial);
+            }
+            if (opts.fallbackToFullDocument) try {
+                const serialized = await evaluateRaw(client, tabId, 'new XMLSerializer().serializeToString(document)');
+                const asString = await coerceResponseToString(client, tabId, serialized, {
+                    fallbackToFullDocument: false
+                });
+                if ('string' == typeof asString && asString.length > 0) return asString;
+            } catch  {}
+            return String(value);
+        }
+        async function resolveActorForEvaluation(client, descriptorActor, consoleActorHint) {
+            let actor = consoleActorHint || descriptorActor;
+            try {
+                const detail = await client.getTargetFromDescriptor?.(descriptorActor) || void 0;
+                const best = detail?.webExtensionInspectedWindowActor || detail?.consoleActor;
+                if (best) actor = best;
+            } catch  {}
+            return actor;
+        }
+        async function serializeDocument(client, actorToUse) {
+            try {
+                const response = await evaluateRaw(client, actorToUse, '(()=>{try{return String(new XMLSerializer().serializeToString(document));}catch(e){return String(document.documentElement.outerHTML)}})()');
+                return await coerceResponseToString(client, actorToUse, response);
+            } catch  {}
+            try {
+                const response = await evaluateRaw(client, actorToUse, '(()=>String(document.documentElement.outerHTML))()');
+                return await coerceResponseToString(client, actorToUse, response, {
+                    fallbackToFullDocument: false
+                });
+            } catch  {}
+            return '';
+        }
+        async function extractShadowContent(client, actorToUse) {
+            const expr = `(() => { try {
+    const selector = '#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])';
+    const preferHost = function(root) {
+      const nodes = Array.from(root.querySelectorAll(selector));
+      return nodes.find(function(node) {
+        try {
+          const rootKind = String(node.getAttribute('data-extension-root') || '');
+          return (
+            String(node.id || '') === 'extension-root' ||
+            rootKind === 'true' ||
+            (rootKind.length > 0 && rootKind !== 'extension-js-devtools')
+          );
+        } catch (e) {
+          return false;
+        }
+      }) || nodes[0] || null;
+    };
+    const host = preferHost(document);
+    if (!host || !host.shadowRoot) return '';
+    const shadowRoot = host.shadowRoot;
+    const s = new XMLSerializer();
+    const stylesheetCss = Array.from(shadowRoot.styleSheets || [])
+      .map(function(sheet) {
+        try {
+          return Array.from(sheet.cssRules || []).map(function(rule) {
+            return String(rule.cssText || '');
+          }).join('\\n');
+        } catch (e) {
+          return '';
+        }
+      })
+      .filter(Boolean)
+      .join('\\n');
+    const adoptedCss = Array.from(shadowRoot.adoptedStyleSheets || [])
+      .map(function(sheet) {
+        try {
+          return Array.from(sheet.cssRules || []).map(function(rule) {
+            return String(rule.cssText || '');
+          }).join('\\n');
+        } catch (e) {
+          return '';
+        }
+      })
+      .filter(Boolean)
+      .join('\\n');
+    const stylesheetMarkup = stylesheetCss ? '<style>' + stylesheetCss + '</style>' : '';
+    const adoptedMarkup = adoptedCss ? '<style>' + adoptedCss + '</style>' : '';
+    const childMarkup = Array.from(shadowRoot.childNodes).map(function(node) {
+      try {
+        if (node && node.nodeType === 1 && String(node.nodeName || '').toLowerCase() === 'style') {
+          return '<style>' + String(node.textContent || '') + '</style>';
+        }
+        return s.serializeToString(node);
+      } catch (e) {
+        return '';
+      }
+    }).join('');
+    return stylesheetMarkup + adoptedMarkup + childMarkup;
+  } catch { return ''; } })()`;
+            const looksIncomplete = (html)=>!html || html.length < 100 || !/content_script/.test(html);
+            let attempts = 0;
+            let html = '';
+            while(attempts < 6){
+                try {
+                    const response = await evaluateRaw(client, actorToUse, expr);
+                    html = await coerceResponseToString(client, actorToUse, response, {
+                        fallbackToFullDocument: false
+                    });
+                    if (!looksIncomplete(html)) break;
+                } catch  {}
+                attempts += 1;
+                await new Promise((r)=>setTimeout(r, 150));
+            }
+            if (html && /<html[\s>]/i.test(html)) html = '';
+            return html;
+        }
+        function mergeShadowIntoMain(mainHTML, shadowContent) {
+            if (!shadowContent) return mainHTML;
+            let merged = mainHTML;
+            try {
+                const hasRoot = /<div id=(["'])extension-root\1/i.test(merged);
+                if (hasRoot) {
+                    const replacedEmpty = merged.replace(/<div id=(["'])extension-root\1[^>]*><\/div>/i, `<div id="extension-root">${shadowContent}</div>`);
+                    if (replacedEmpty !== merged) return replacedEmpty;
+                    merged = merged.replace(/<div id=(["'])extension-root\1[^>]*>[\s\S]*?<\/div>/i, `<div id="extension-root">${shadowContent}</div>`);
+                } else merged = /<\/body>/i.test(merged) ? merged.replace(/<\/body>/i, `<div id="extension-root">${shadowContent}</div></body>`) : `${merged}\n<div id=\"extension-root\">${shadowContent}</div>`;
+            } catch  {}
+            return merged;
+        }
+    },
     "./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/firefox-utils.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -131941,6 +132090,93 @@ var __webpack_modules__ = {
                 super(...args), _define_property(this, "conn", void 0), _define_property(this, "incoming", Buffer.alloc(0)), _define_property(this, "active", new Map()), _define_property(this, "pending", []);
             }
         }
+        const ASYNC_EVALUATION_TIMEOUT_MS = 8000;
+        const EVALUATION_TYPES = [
+            'evaluateJSAsync',
+            'evalWithOptions',
+            'evaluateJS',
+            'eval'
+        ];
+        function buildEvaluationPayload(to, text, type) {
+            const payload = {
+                to,
+                type,
+                text
+            };
+            if ('evalWithOptions' === type) payload.options = {
+                url: '',
+                selectedNodeActor: void 0,
+                frameActor: void 0
+            };
+            return payload;
+        }
+        async function requestEvaluationWithType(transport, payload) {
+            if ('evaluateJSAsync' !== payload.type) return await transport.request(payload);
+            let expectedResultId = '';
+            let cleanup = ()=>{};
+            let pendingMessage;
+            const asyncResult = new Promise((resolve)=>{
+                const listener = (message)=>{
+                    if ('evaluationResult' !== message.type) return;
+                    if (!expectedResultId) {
+                        pendingMessage = message;
+                        return;
+                    }
+                    if (String(message.resultID || '') !== expectedResultId) return;
+                    cleanup();
+                    message.error ? resolve({
+                        ok: false,
+                        error: message
+                    }) : resolve({
+                        ok: true,
+                        value: message
+                    });
+                };
+                const timeout = setTimeout(()=>{
+                    transport.removeListener('message', listener);
+                    resolve({
+                        ok: false,
+                        error: new Error('Timed out waiting for Firefox async evaluation result')
+                    });
+                }, ASYNC_EVALUATION_TIMEOUT_MS);
+                cleanup = ()=>{
+                    clearTimeout(timeout);
+                    transport.removeListener('message', listener);
+                };
+                transport.on('message', listener);
+            });
+            try {
+                const response = await transport.request(payload);
+                if (response?.type === 'evaluationResult') {
+                    cleanup();
+                    return response;
+                }
+                expectedResultId = String(response?.resultID || '');
+                if (!expectedResultId) {
+                    cleanup();
+                    return response;
+                }
+                if (pendingMessage && String(pendingMessage.resultID || '') === expectedResultId) {
+                    cleanup();
+                    return pendingMessage;
+                }
+                const outcome = await asyncResult;
+                if (!outcome.ok) throw outcome.error;
+                return outcome.value;
+            } catch (error) {
+                cleanup();
+                throw error;
+            }
+        }
+        async function requestEvaluation(transport, to, text) {
+            let lastError = null;
+            for (const type of EVALUATION_TYPES)try {
+                return await requestEvaluationWithType(transport, buildEvaluationPayload(to, text, type));
+            } catch (error) {
+                lastError = error;
+            }
+            throw lastError || new Error('Failed to evaluate Firefox RDP expression');
+        }
         async function listTabs(transport) {
             const response = await transport.request({
                 to: 'root',
@@ -131975,22 +132211,16 @@ var __webpack_modules__ = {
             });
         }
         async function navigateViaScript(transport, consoleActor, url) {
-            await transport.request({
-                to: consoleActor,
-                type: 'evaluateJS',
-                text: `window.location.assign(${JSON.stringify(url)})`
-            });
+            await requestEvaluation(transport, consoleActor, `(() => { window.location.assign(${JSON.stringify(url)}); return true; })()`);
         }
         async function waitForPageReady(transport, consoleActor, url, timeoutMs = 8000) {
             const start = Date.now();
             while(Date.now() - start < timeoutMs){
                 try {
-                    const response = await transport.request({
-                        to: consoleActor,
-                        type: 'evaluateJS',
-                        text: "({href: location.href, ready: document.readyState})"
-                    });
-                    const value = response?.result || {};
+                    const response = await requestEvaluation(transport, consoleActor, "JSON.stringify({href: String(location.href), ready: String(document.readyState)})");
+                    const raw = response?.result ?? response?.value ?? response;
+                    const serialized = 'string' == typeof raw ? raw : 'string' == typeof raw?.value ? raw.value : 'string' == typeof raw?.text ? raw.text : '';
+                    const value = serialized ? JSON.parse(serialized) : {};
                     if ('string' == typeof value?.href && value.href.startsWith(url) && ('interactive' === value.ready || 'complete' === value.ready)) return;
                 } catch  {}
                 await new Promise((resolve)=>setTimeout(resolve, 200));
@@ -132012,159 +132242,7 @@ var __webpack_modules__ = {
                 }, 10000);
             });
         }
-        async function evaluate(client, tabId, expression) {
-            const tryTypes = [
-                'evaluateJS',
-                'evaluateJSAsync',
-                'eval',
-                'evalWithOptions'
-            ];
-            let lastError = null;
-            for (const type of tryTypes)try {
-                const payload = {
-                    to: tabId,
-                    type,
-                    text: expression
-                };
-                if ('evalWithOptions' === type) payload.options = {
-                    url: '',
-                    selectedNodeActor: void 0,
-                    frameActor: void 0
-                };
-                const response = await client.request(payload);
-                const r = response ?? {};
-                if (void 0 !== r.result) return r.result;
-                if (void 0 !== r.value) return r.value;
-                return r;
-            } catch (err) {
-                lastError = err;
-            }
-            throw lastError || new Error('Failed to evaluate expression');
-        }
-        async function evaluateRaw(client, tabId, expression) {
-            const tryTypes = [
-                'evaluateJS',
-                'evaluateJSAsync',
-                'eval',
-                'evalWithOptions'
-            ];
-            let lastError = null;
-            for (const type of tryTypes)try {
-                const payload = {
-                    to: tabId,
-                    type,
-                    text: expression
-                };
-                if ('evalWithOptions' === type) payload.options = {
-                    url: '',
-                    selectedNodeActor: void 0,
-                    frameActor: void 0
-                };
-                return await client.request(payload);
-            } catch (err) {
-                lastError = err;
-            }
-            throw lastError || new Error('Failed to evaluate expression (raw)');
-        }
-        async function coerceResponseToString(client, tabId, response, opts = {
-            fallbackToFullDocument: true
-        }) {
-            const r = response ?? {};
-            const value = r.result ?? r.value ?? r;
-            if ('string' == typeof value) return value;
-            if (value && 'string' == typeof value.value) return value.value;
-            if (value && 'string' == typeof value.text) return value.text;
-            if (value && value.preview && 'string' == typeof value.preview.text) return value.preview.text;
-            if (value && 'longString' === value.type) {
-                const initial = value.initial || '';
-                const length = 'number' == typeof value.length ? value.length : initial.length;
-                const actor = value.actor;
-                if (actor && 'number' == typeof length) try {
-                    const full = await client.request({
-                        to: actor,
-                        type: 'substring',
-                        start: 0,
-                        end: length
-                    });
-                    if (full && 'string' == typeof full.substring) return full.substring;
-                } catch  {}
-                return String(initial);
-            }
-            if (opts.fallbackToFullDocument) try {
-                const serialized = await evaluateRaw(client, tabId, 'new XMLSerializer().serializeToString(document)');
-                const asString = await coerceResponseToString(client, tabId, serialized, {
-                    fallbackToFullDocument: false
-                });
-                if ('string' == typeof asString && asString.length > 0) return asString;
-            } catch  {}
-            return String(value);
-        }
-        async function resolveActorForEvaluation(client, descriptorActor, consoleActorHint) {
-            let actor = consoleActorHint || descriptorActor;
-            try {
-                const detail = await client.getTargetFromDescriptor?.(descriptorActor) || void 0;
-                const best = detail?.webExtensionInspectedWindowActor || detail?.consoleActor;
-                if (best) actor = best;
-            } catch  {}
-            return actor;
-        }
-        async function serializeDocument(client, actorToUse) {
-            try {
-                const response = await client.request({
-                    to: actorToUse,
-                    type: 'evaluateJS',
-                    text: '(()=>{try{return String(new XMLSerializer().serializeToString(document));}catch(e){return String(document.documentElement.outerHTML)}})()'
-                });
-                return await coerceResponseToString(client, actorToUse, response);
-            } catch  {}
-            try {
-                const response = await client.request({
-                    to: actorToUse,
-                    type: 'evaluateJS',
-                    text: '(()=>String(document.documentElement.outerHTML))()'
-                });
-                return await coerceResponseToString(client, actorToUse, response, {
-                    fallbackToFullDocument: false
-                });
-            } catch  {}
-            return '';
-        }
-        async function extractShadowContent(client, actorToUse) {
-            const expr = "(() => { try { const host = document.getElementById('extension-root'); if (!host || !host.shadowRoot) return ''; const s = new XMLSerializer(); return Array.from(host.shadowRoot.childNodes).map(n => { try { return s.serializeToString(n) } catch (e) { return '' } }).join(''); } catch { return ''; } })()";
-            const looksIncomplete = (html)=>!html || html.length < 100 || !/content_script/.test(html);
-            let attempts = 0;
-            let html = '';
-            while(attempts < 6){
-                try {
-                    const response = await client.request({
-                        to: actorToUse,
-                        type: 'evaluateJS',
-                        text: expr
-                    });
-                    html = await coerceResponseToString(client, actorToUse, response, {
-                        fallbackToFullDocument: false
-                    });
-                    if (!looksIncomplete(html)) break;
-                } catch  {}
-                attempts += 1;
-                await new Promise((r)=>setTimeout(r, 150));
-            }
-            if (html && /<html[\s>]/i.test(html)) html = '';
-            return html;
-        }
-        function mergeShadowIntoMain(mainHTML, shadowContent) {
-            if (!shadowContent) return mainHTML;
-            let merged = mainHTML;
-            try {
-                const hasRoot = /<div id=(["'])extension-root\1/i.test(merged);
-                if (hasRoot) {
-                    const replacedEmpty = merged.replace(/<div id=(["'])extension-root\1[^>]*><\/div>/i, `<div id="extension-root">${shadowContent}</div>`);
-                    if (replacedEmpty !== merged) return replacedEmpty;
-                    merged = merged.replace(/<div id=(["'])extension-root\1[^>]*>[\s\S]*?<\/div>/i, `<div id="extension-root">${shadowContent}</div>`);
-                } else merged = /<\/body>/i.test(merged) ? merged.replace(/<\/body>/i, `<div id="extension-root">${shadowContent}</div></body>`) : `${merged}\n<div id=\"extension-root\">${shadowContent}</div>`;
-            } catch  {}
-            return merged;
-        }
+        var evaluate = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/evaluate.ts");
         function messaging_client_define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
                 value: value,
@@ -132246,27 +132324,27 @@ var __webpack_modules__ = {
                 await waitForLoadEvent(this.transport, tabId);
             }
             async evaluate(tabId, expression) {
-                return evaluate(this, tabId, expression);
+                return (0, evaluate._3)(this, tabId, expression);
             }
             async evaluateRaw(tabId, expression) {
-                return evaluateRaw(this, tabId, expression);
+                return (0, evaluate._e)(this, tabId, expression);
             }
             async coerceResponseToString(tabId, response, opts = {
                 fallbackToFullDocument: true
             }) {
-                return coerceResponseToString(this, tabId, response, opts);
+                return (0, evaluate.vA)(this, tabId, response, opts);
             }
             async resolveActorForEvaluation(descriptorActor, consoleActorHint) {
-                return resolveActorForEvaluation(this, descriptorActor, consoleActorHint);
+                return (0, evaluate.XT)(this, descriptorActor, consoleActorHint);
             }
             async serializeDocument(actorToUse) {
-                return serializeDocument(this, actorToUse);
+                return (0, evaluate.wt)(this, actorToUse);
             }
             async extractShadowContent(actorToUse) {
-                return extractShadowContent(this, actorToUse);
+                return (0, evaluate.jU)(this, actorToUse);
             }
             mergeShadowIntoMain(mainHTML, shadowContent) {
-                return mergeShadowIntoMain(mainHTML, shadowContent);
+                return (0, evaluate.QX)(mainHTML, shadowContent);
             }
             async getPageHTML(descriptorActor, consoleActorHint) {
                 console.log(messages.XOv());
@@ -132289,7 +132367,7 @@ var __webpack_modules__ = {
                 const shadowContent = await this.extractShadowContent(actorToUse);
                 if (!shadowContent) return mainHTML;
                 try {
-                    const mergedResp = await this.evaluateRaw(actorToUse, "(() => { try { var cloned = document.documentElement.cloneNode(true); var host = cloned.querySelector('#extension-root'); if (!host) { var body = cloned.querySelector('body') || cloned; var newRoot = document.createElement('div'); newRoot.id='extension-root'; body.appendChild(newRoot); host = newRoot; } var s = new XMLSerializer(); var shadow = ''; try { var live = document.getElementById('extension-root'); if (live && live.shadowRoot) { shadow = Array.from(live.shadowRoot.childNodes).map(function(n){ try { return s.serializeToString(n) } catch(e){ return '' } }).join(''); } } catch(e) {} try { host.innerHTML = shadow; } catch(e) {} return String('<!DOCTYPE html>' + (cloned.outerHTML || document.documentElement.outerHTML)); } catch(e) { try { return String(document.documentElement.outerHTML); } catch(_) { return '' } } })()");
+                    const mergedResp = await this.evaluateRaw(actorToUse, "(() => { try { var selector = '#extension-root,[data-extension-root]:not([data-extension-root=\"extension-js-devtools\"])'; var serializeShadowRoot = function(shadowRoot, serializer) { if (!shadowRoot) return ''; var stylesheetCss = Array.from(shadowRoot.styleSheets || []).map(function(sheet) { try { return Array.from(sheet.cssRules || []).map(function(rule) { return String(rule.cssText || ''); }).join('\\n'); } catch (e) { return ''; } }).filter(Boolean).join('\\n'); var adoptedCss = Array.from(shadowRoot.adoptedStyleSheets || []).map(function(sheet) { try { return Array.from(sheet.cssRules || []).map(function(rule) { return String(rule.cssText || ''); }).join('\\n'); } catch (e) { return ''; } }).filter(Boolean).join('\\n'); var stylesheetMarkup = stylesheetCss ? '<style>' + stylesheetCss + '</style>' : ''; var adoptedMarkup = adoptedCss ? '<style>' + adoptedCss + '</style>' : ''; var childMarkup = Array.from(shadowRoot.childNodes || []).map(function(node) { try { if (node && node.nodeType === 1 && String(node.nodeName || '').toLowerCase() === 'style') { return '<style>' + String(node.textContent || '') + '</style>'; } return serializer.serializeToString(node); } catch (e) { return ''; } }).join(''); return stylesheetMarkup + adoptedMarkup + childMarkup; }; var cloned = document.documentElement.cloneNode(true); var clonedHosts = Array.from(cloned.querySelectorAll(selector)); var liveHosts = Array.from(document.querySelectorAll(selector)); if (!clonedHosts.length) { var body = cloned.querySelector('body') || cloned; var newRoot = document.createElement('div'); newRoot.id='extension-root'; body.appendChild(newRoot); clonedHosts = [newRoot]; } var s = new XMLSerializer(); for (var i = 0; i < clonedHosts.length; i++) { var host = clonedHosts[i]; var live = liveHosts[i]; var shadow = ''; try { if (live && live.shadowRoot) { shadow = serializeShadowRoot(live.shadowRoot, s); } } catch (e) {} try { host.innerHTML = shadow; } catch (e) {} } return String('<!DOCTYPE html>' + (cloned.outerHTML || document.documentElement.outerHTML)); } catch(e) { try { return String(document.documentElement.outerHTML); } catch(_) { return '' } } })()");
                     const mergedHtml = await this.coerceResponseToString(actorToUse, mergedResp, {
                         fallbackToFullDocument: false
                     });
@@ -132317,9 +132395,20 @@ var __webpack_modules__ = {
             VJ: ()=>navigateTo,
             oc: ()=>ensureTabForUrl
         });
+        function normalizeInspectableUrl(rawUrl) {
+            try {
+                const parsed = new URL(String(rawUrl || ''));
+                if (('http:' === parsed.protocol || 'https:' === parsed.protocol) && '/' === parsed.pathname) parsed.pathname = '';
+                parsed.hash = '';
+                return parsed.toString();
+            } catch  {
+                return String(rawUrl || '').trim().replace(/\/$/, '');
+            }
+        }
         async function ensureTabForUrl(client, urlToInspect) {
             const targets = await client.getTargets();
-            let tab = (targets || []).find((t)=>t && t.url === urlToInspect && t.actor);
+            const normalizedUrlToInspect = normalizeInspectableUrl(urlToInspect);
+            let tab = (targets || []).find((t)=>t && normalizeInspectableUrl(t.url) === normalizedUrlToInspect && t.actor);
             if (!tab) tab = (targets || []).find((t)=>t && (t.actor || t.outerWindowID)) || (targets || [])[0];
             if (!tab || !tab.actor) return null;
             return {
@@ -132331,6 +132420,18 @@ var __webpack_modules__ = {
             try {
                 const detail = await client.getTargetFromDescriptor(tabActor);
                 const consoleActor = detail.consoleActor || consoleActorHint || tabActor;
+                const currentUrl = await client.evaluate(consoleActor, 'String(location.href || "")');
+                const sameDocumentTarget = 'string' == typeof currentUrl && normalizeInspectableUrl(currentUrl) === normalizeInspectableUrl(url);
+                if (sameDocumentTarget) {
+                    let targetActor = tabActor;
+                    if (detail.targetActor) targetActor = String(detail.targetActor || targetActor);
+                    try {
+                        await client.attach(targetActor);
+                    } catch  {}
+                    await client.navigate(targetActor, url);
+                    await client.waitForLoadEvent(targetActor);
+                    return;
+                }
                 await client.navigateViaScript(consoleActor, url);
                 await client.waitForPageReady(consoleActor, url, 8000);
                 return;
@@ -132347,6 +132448,7 @@ var __webpack_modules__ = {
             await client.waitForLoadEvent(targetActor);
         }
         async function getPageHTML(client, descriptorActor, consoleActorHint) {
+            if ('function' == typeof client.getPageHTML) return await client.getPageHTML(descriptorActor, consoleActorHint);
             try {
                 const titleResp = await client.evaluateRaw(descriptorActor, 'String(document.title)');
                 await client.coerceResponseToString?.(descriptorActor, titleResp);
@@ -132362,9 +132464,32 @@ var __webpack_modules__ = {
                 if (!mainHTML) return '';
             }
             const shadowContent = await client.extractShadowContent?.(descriptorActor);
+            fetch('http://127.0.0.1:7795/ingest/9eb8f923-a325-4455-a46c-a6e706558307', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Debug-Session-Id': 'a87efc'
+                },
+                body: JSON.stringify({
+                    sessionId: 'a87efc',
+                    runId: process.env.EXTENSION_INSTANCE_ID || 'firefox-source-inspection',
+                    hypothesisId: 'H3',
+                    location: 'remote-firefox/source-inspect.ts:getPageHTML',
+                    message: 'Firefox page HTML extraction snapshot',
+                    data: {
+                        descriptorActor,
+                        consoleActorHint,
+                        mainHtmlLength: 'string' == typeof mainHTML ? mainHTML.length : 0,
+                        shadowContentLength: 'string' == typeof shadowContent ? shadowContent.length : 0,
+                        mainHasRoot: 'string' == typeof mainHTML && /#extension-root|data-extension-root/i.test(mainHTML),
+                        shadowHasContentMarkers: 'string' == typeof shadowContent && /content_script|content_title|js-probe|iskilar_box/i.test(shadowContent)
+                    },
+                    timestamp: Date.now()
+                })
+            }).catch(()=>{});
             if (!shadowContent) return mainHTML;
             try {
-                const mergedResp = await client.evaluateRaw(descriptorActor, "(() => { try { var cloned = document.documentElement.cloneNode(true); var host = cloned.querySelector('#extension-root'); if (!host) { var body = cloned.querySelector('body') || cloned; var newRoot = document.createElement('div'); newRoot.id='extension-root'; body.appendChild(newRoot); host = newRoot; } var s = new XMLSerializer(); var shadow = ''; try { var live = document.getElementById('extension-root'); if (live && live.shadowRoot) { shadow = Array.from(live.shadowRoot.childNodes).map(function(n){ try { return s.serializeToString(n) } catch(e){ return '' } }).join(''); } } catch(e) {} try { host.innerHTML = shadow; } catch(e) {} return String('<!DOCTYPE html>' + (cloned.outerHTML || document.documentElement.outerHTML)); } catch(e) { try { return String(document.documentElement.outerHTML); } catch(_) { return '' } } })()");
+                const mergedResp = await client.evaluateRaw(descriptorActor, "(() => { try { var selector = '#extension-root,[data-extension-root]:not([data-extension-root=\"extension-js-devtools\"])'; var serializeShadowRoot = function(shadowRoot, serializer) { if (!shadowRoot) return ''; var stylesheetCss = Array.from(shadowRoot.styleSheets || []).map(function(sheet) { try { return Array.from(sheet.cssRules || []).map(function(rule) { return String(rule.cssText || ''); }).join('\\n'); } catch (e) { return ''; } }).filter(Boolean).join('\\n'); var adoptedCss = Array.from(shadowRoot.adoptedStyleSheets || []).map(function(sheet) { try { return Array.from(sheet.cssRules || []).map(function(rule) { return String(rule.cssText || ''); }).join('\\n'); } catch (e) { return ''; } }).filter(Boolean).join('\\n'); var stylesheetMarkup = stylesheetCss ? '<style>' + stylesheetCss + '</style>' : ''; var adoptedMarkup = adoptedCss ? '<style>' + adoptedCss + '</style>' : ''; var childMarkup = Array.from(shadowRoot.childNodes || []).map(function(node) { try { if (node && node.nodeType === 1 && String(node.nodeName || '').toLowerCase() === 'style') { return '<style>' + String(node.textContent || '') + '</style>'; } return serializer.serializeToString(node); } catch (e) { return ''; } }).join(''); return stylesheetMarkup + adoptedMarkup + childMarkup; }; var cloned = document.documentElement.cloneNode(true); var clonedHosts = Array.from(cloned.querySelectorAll(selector)); var liveHosts = Array.from(document.querySelectorAll(selector)); if (!clonedHosts.length) { var body = cloned.querySelector('body') || cloned; var newRoot = document.createElement('div'); newRoot.id='extension-root'; body.appendChild(newRoot); clonedHosts = [newRoot]; } var s = new XMLSerializer(); for (var i = 0; i < clonedHosts.length; i++) { var host = clonedHosts[i]; var live = liveHosts[i]; var shadow = ''; try { if (live && live.shadowRoot) { shadow = serializeShadowRoot(live.shadowRoot, s); } } catch (e) {} try { host.innerHTML = shadow; } catch (e) {} } return String('<!DOCTYPE html>' + (cloned.outerHTML || document.documentElement.outerHTML)); } catch(e) { try { return String(document.documentElement.outerHTML); } catch(_) { return '' } } })()");
                 const mergedHtml = await client.coerceResponseToString?.(descriptorActor, mergedResp, {
                     fallbackToFullDocument: false
                 });
@@ -132379,7 +132504,8 @@ var __webpack_modules__ = {
                 try {
                     const targets = await client.getTargets();
                     const byActor = targets.find((t)=>t && t.actor === tabActor);
-                    const byUrl = targets.find((t)=>t && t.url === urlToInspect);
+                    const normalizedUrlToInspect = normalizeInspectableUrl(urlToInspect);
+                    const byUrl = targets.find((t)=>t && normalizeInspectableUrl(t.url) === normalizedUrlToInspect);
                     const match = byActor || byUrl;
                     const consoleActor = match?.consoleActor || match?.webConsoleActor;
                     if ('string' == typeof consoleActor && consoleActor.length > 0) return consoleActor;
@@ -132394,19 +132520,169 @@ var __webpack_modules__ = {
             return tabActor;
         }
         async function waitForContentScriptInjectionMethod(client, consoleActor) {
-            const deadline = Date.now() + 8000;
+            const deadline = Date.now() + 12000;
             while(Date.now() < deadline){
                 try {
                     const injected = await client.evaluate(consoleActor, `(() => {
-            const root = document.getElementById('extension-root');
+            const root = document.querySelector('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])');
             if (!root || !root.shadowRoot) return false;
+            const meaningfulChild = Array.from(root.shadowRoot.childNodes || []).some((node) => {
+              if (!node) return false;
+              if (node.nodeType === Node.TEXT_NODE) {
+                return String(node.textContent || '').trim().length > 0;
+              }
+              if (node.nodeType !== Node.ELEMENT_NODE) return false;
+              const element = node;
+              const tagName = String(element.nodeName || '').toLowerCase();
+              if (tagName === 'style') return false;
+              const text = String(element.textContent || '').trim();
+              return text.length > 0 || element.childElementCount > 0;
+            });
+            if (meaningfulChild) return true;
             const html = root.shadowRoot.innerHTML || '';
-            return html.length > 0;
+            return /<(?!style\\b)[a-z][^>]*>/i.test(html);
           })()`);
-                    if (injected) return;
+                    if (injected) {
+                        try {
+                            const snapshot = await client.evaluate(consoleActor, `(() => {
+              try {
+                const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+                return JSON.stringify({
+                  readyState: document.readyState,
+                  hostCount: hosts.length,
+                  hosts: hosts.slice(0, 6).map((host, index) => {
+                    const shadow = host && host.shadowRoot;
+                    const html = shadow ? String(shadow.innerHTML || '') : '';
+                    const meaningfulChild = shadow ? Array.from(shadow.childNodes || []).some((node) => {
+                      try {
+                        if (!node) return false;
+                        if (node.nodeType === Node.TEXT_NODE) {
+                          return String(node.textContent || '').trim().length > 0;
+                        }
+                        if (node.nodeType !== Node.ELEMENT_NODE) return false;
+                        const element = node;
+                        const tagName = String(element.nodeName || '').toLowerCase();
+                        if (tagName === 'style') return false;
+                        const text = String(element.textContent || '').trim();
+                        return text.length > 0 || element.childElementCount > 0;
+                      } catch {
+                        return false;
+                      }
+                    }) : false;
+                    return {
+                      index,
+                      id: host && host.id ? String(host.id) : '',
+                      rootAttr: host && host.getAttribute ? String(host.getAttribute('data-extension-root') || '') : '',
+                      hasShadow: !!shadow,
+                      shadowChildCount: shadow ? shadow.childNodes.length : 0,
+                      shadowElementCount: shadow ? shadow.querySelectorAll('*').length : 0,
+                      meaningfulChild,
+                      shadowHtmlSnippet: html.slice(0, 200)
+                    };
+                  })
+                });
+              } catch (error) {
+                return JSON.stringify({error: String(error && error.message || error)});
+              }
+            })()`);
+                            fetch('http://127.0.0.1:7795/ingest/9eb8f923-a325-4455-a46c-a6e706558307', {
+                                method: 'POST',
+                                headers: {
+                                    'Content-Type': 'application/json',
+                                    'X-Debug-Session-Id': 'a87efc'
+                                },
+                                body: JSON.stringify({
+                                    sessionId: 'a87efc',
+                                    runId: process.env.EXTENSION_INSTANCE_ID || 'firefox-source-inspection',
+                                    hypothesisId: 'H2',
+                                    location: 'remote-firefox/source-inspect.ts:waitForContentScriptInjectionMethod:success',
+                                    message: 'Firefox injection waiter succeeded',
+                                    data: {
+                                        consoleActor,
+                                        snapshot
+                                    },
+                                    timestamp: Date.now()
+                                })
+                            }).catch(()=>{});
+                        } catch  {}
+                        return true;
+                    }
                 } catch  {}
                 await new Promise((r)=>setTimeout(r, 200));
             }
+            try {
+                const snapshot = await client.evaluate(consoleActor, `(() => {
+        try {
+          const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+          const selected = document.querySelector('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])');
+          const selectedShadow = selected && selected.shadowRoot;
+          return JSON.stringify({
+            readyState: document.readyState,
+            href: String(location.href || ''),
+            title: String(document.title || ''),
+            hostCount: hosts.length,
+            selectedHost: selected ? {
+              id: selected.id ? String(selected.id) : '',
+              rootAttr: selected.getAttribute ? String(selected.getAttribute('data-extension-root') || '') : '',
+              hasShadow: !!selectedShadow,
+              shadowHtmlSnippet: selectedShadow ? String(selectedShadow.innerHTML || '').slice(0, 200) : ''
+            } : null,
+            hosts: hosts.slice(0, 6).map((host, index) => {
+              const shadow = host && host.shadowRoot;
+              const html = shadow ? String(shadow.innerHTML || '') : '';
+              const meaningfulChild = shadow ? Array.from(shadow.childNodes || []).some((node) => {
+                try {
+                  if (!node) return false;
+                  if (node.nodeType === Node.TEXT_NODE) {
+                    return String(node.textContent || '').trim().length > 0;
+                  }
+                  if (node.nodeType !== Node.ELEMENT_NODE) return false;
+                  const element = node;
+                  const tagName = String(element.nodeName || '').toLowerCase();
+                  if (tagName === 'style') return false;
+                  const text = String(element.textContent || '').trim();
+                  return text.length > 0 || element.childElementCount > 0;
+                } catch {
+                  return false;
+                }
+              }) : false;
+              return {
+                index,
+                id: host && host.id ? String(host.id) : '',
+                rootAttr: host && host.getAttribute ? String(host.getAttribute('data-extension-root') || '') : '',
+                hasShadow: !!shadow,
+                shadowChildCount: shadow ? shadow.childNodes.length : 0,
+                shadowElementCount: shadow ? shadow.querySelectorAll('*').length : 0,
+                meaningfulChild,
+                shadowHtmlSnippet: html.slice(0, 200)
+              };
+            })
+          });
+        } catch (error) {
+          return JSON.stringify({error: String(error && error.message || error)});
+        }
+      })()`);
+                fetch('http://127.0.0.1:7795/ingest/9eb8f923-a325-4455-a46c-a6e706558307', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-Debug-Session-Id': 'a87efc'
+                    },
+                    body: JSON.stringify({
+                        sessionId: 'a87efc',
+                        runId: process.env.EXTENSION_INSTANCE_ID || 'firefox-source-inspection',
+                        hypothesisId: 'H2',
+                        location: 'remote-firefox/source-inspect.ts:waitForContentScriptInjectionMethod:timeout',
+                        message: 'Firefox injection waiter timed out',
+                        data: {
+                            consoleActor,
+                            snapshot
+                        },
+                        timestamp: Date.now()
+                    })
+                }).catch(()=>{});
+            } catch  {}
+            return false;
         }
     },
     "./webpack/plugin-compilation/compilation-lib/shared-state.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
@@ -132464,14 +132740,9 @@ var __webpack_modules__ = {
     "./webpack/plugin-css/css-lib/messages.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
-            DX: ()=>optionalInstallFailed,
             Se: ()=>missingSassDependency,
-            Vo: ()=>optionalInstallManagerMissing,
-            _j: ()=>optionalToolingSetup,
-            cr: ()=>optionalToolingRootInstall,
             fD: ()=>cssConfigsDetected,
             uo: ()=>cssIntegrationsEnabled,
-            ys: ()=>optionalToolingReady,
             zA: ()=>isUsingIntegration
         });
         var pintor__rspack_import_0 = __webpack_require__("pintor");
@@ -132487,36 +132758,6 @@ var __webpack_modules__ = {
         function isUsingIntegration(name) {
             return `${pintor__rspack_import_0_default().gray('►►►')} Using ${pintor__rspack_import_0_default().brightBlue(name)}...`;
         }
-        function optionalToolingSetup(integrations, fallback, isAuthor) {
-            const list = integrations && integrations.length > 0 ? integrations : [
-                fallback
-            ];
-            const prefix = isAuthor ? pintor__rspack_import_0_default().brightMagenta('►►► Author says') : pintor__rspack_import_0_default().gray('►►►');
-            const suffix = 'true' === process.env.EXTENSION_ONE_TIME_INSTALL_HINT ? ' (this is a one time operation)' : '';
-            return list.map((integration)=>`${prefix} Installing specialized dependencies for ${integration}...${suffix}`);
-        }
-        function optionalToolingRootInstall(integration) {
-            return `${pintor__rspack_import_0_default().brightMagenta('►►► Author says')} [${integration}] Installing root dependencies for dev...`;
-        }
-        function optionalToolingReady(integration) {
-            return `${pintor__rspack_import_0_default().brightMagenta('►►► Author says')} ${integration} tooling ready.`;
-        }
-        function optionalInstallFailed(integration, error, isAuthor) {
-            const prefix = isAuthor ? pintor__rspack_import_0_default().brightMagenta('ERROR Author says') : pintor__rspack_import_0_default().red('ERROR');
-            return `${prefix} [${integration}] Failed to install dependencies.\n${pintor__rspack_import_0_default().red(String(error?.message || error))}`;
-        }
-        function optionalInstallManagerMissing(integration) {
-            const prefix = pintor__rspack_import_0_default().red('ERROR');
-            return [
-                `${prefix} [${integration}] No supported package manager found in PATH.`,
-                'Install pnpm, npm, or yarn and retry.',
-                'If you use pnpm, ensure it is available in your environment (e.g. corepack or PATH).',
-                'Override detection with:',
-                `  ${pintor__rspack_import_0_default().gray('EXTENSION_JS_PACKAGE_MANAGER=pnpm|npm|yarn|bun')}`,
-                `  ${pintor__rspack_import_0_default().gray('EXTENSION_JS_PM_EXEC_PATH=/path/to/npm-cli.js')}`,
-                'If you are on WSL, run the CLI inside a WSL shell so PATH is consistent.'
-            ].join('\n');
-        }
         function missingSassDependency() {
             const prefix = pintor__rspack_import_0_default().red('►►►');
             return [
@@ -132545,12 +132786,12 @@ var __webpack_modules__ = {
         var pintor__rspack_import_1 = __webpack_require__("pintor");
         var pintor__rspack_import_1_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_1);
         var _css_lib_messages__rspack_import_2 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
-        var _optional_deps_lib__rspack_import_3 = __webpack_require__("./webpack/optional-deps-lib/index.ts");
+        var optional_deps_lib__rspack_import_3 = __webpack_require__("optional-deps-lib");
         var _css_lib_is_content_script__rspack_import_4 = __webpack_require__("./webpack/plugin-css/css-lib/is-content-script.ts");
         var _webpack_lib_optional_deps_resolver__rspack_import_5 = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
         let userMessageDelivered = false;
         function isUsingLess(projectPath) {
-            if ((0, _optional_deps_lib__rspack_import_3.ws)(projectPath, 'less')) {
+            if ((0, optional_deps_lib__rspack_import_3.hasDependency)(projectPath, 'less')) {
                 if (!userMessageDelivered) {
                     if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_1_default().brightMagenta('►►► Author says')} ${_css_lib_messages__rspack_import_2.zA('LESS')}`);
                     userMessageDelivered = true;
@@ -132615,7 +132856,7 @@ var __webpack_modules__ = {
         var pintor__rspack_import_3 = __webpack_require__("pintor");
         var pintor__rspack_import_3_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_3);
         var _css_lib_messages__rspack_import_4 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
-        var _optional_deps_lib__rspack_import_5 = __webpack_require__("./webpack/optional-deps-lib/index.ts");
+        var optional_deps_lib__rspack_import_5 = __webpack_require__("optional-deps-lib");
         var _tailwind__rspack_import_6 = __webpack_require__("./webpack/plugin-css/css-tools/tailwind.ts");
         var _webpack_lib_optional_deps_resolver__rspack_import_7 = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
         let userMessageDelivered = false;
@@ -132764,7 +133005,7 @@ var __webpack_modules__ = {
             }
         }
         function isUsingPostCss(projectPath) {
-            if ((0, _optional_deps_lib__rspack_import_5.ws)(projectPath, 'postcss')) {
+            if ((0, optional_deps_lib__rspack_import_5.hasDependency)(projectPath, 'postcss')) {
                 if (!userMessageDelivered) {
                     if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_3_default().brightMagenta('►►► Author says')} ${_css_lib_messages__rspack_import_4.zA('PostCSS')}`);
                     userMessageDelivered = true;
@@ -132898,7 +133139,7 @@ var __webpack_modules__ = {
             } catch  {}
             const bypassUserConfigForTailwindCompat = !!pluginsFromOptions && !!userPostCssConfig && userConfigMentionsTailwind && userConfigUsesDirectTailwindReference;
             if (userConfigIsCjsInEsm || bypassUserConfigForTailwindCompat) try {
-                if ((0, _optional_deps_lib__rspack_import_5.ws)(projectPath, 'autoprefixer')) {
+                if ((0, optional_deps_lib__rspack_import_5.hasDependency)(projectPath, 'autoprefixer')) {
                     const req = (0, module__rspack_import_2.createRequire)(path__rspack_import_0.join(projectPath, 'package.json'));
                     const autoprefixerMod = req('autoprefixer');
                     const autoprefixerPlugin = 'function' == typeof autoprefixerMod ? autoprefixerMod() : autoprefixerMod?.default && 'function' == typeof autoprefixerMod.default ? autoprefixerMod.default() : void 0;
@@ -132942,11 +133183,12 @@ var __webpack_modules__ = {
         var pintor__rspack_import_2 = __webpack_require__("pintor");
         var pintor__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_2);
         var _css_lib_messages__rspack_import_3 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
-        var _optional_deps_lib__rspack_import_4 = __webpack_require__("./webpack/optional-deps-lib/index.ts");
-        var _webpack_lib_optional_deps_resolver__rspack_import_5 = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
+        var optional_deps_lib__rspack_import_4 = __webpack_require__("optional-deps-lib");
+        var _webpack_lib_develop_context__rspack_import_5 = __webpack_require__("./webpack/webpack-lib/develop-context.ts");
+        var _webpack_lib_optional_deps_resolver__rspack_import_6 = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
         let userMessageDelivered = false;
         function isUsingSass(projectPath) {
-            if ((0, _optional_deps_lib__rspack_import_4.ws)(projectPath, 'sass')) {
+            if ((0, optional_deps_lib__rspack_import_4.hasDependency)(projectPath, 'sass')) {
                 if (!userMessageDelivered) {
                     if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_2_default().brightMagenta('►►► Author says')} ${_css_lib_messages__rspack_import_3.zA('SASS')}`);
                     userMessageDelivered = true;
@@ -132956,7 +133198,7 @@ var __webpack_modules__ = {
             return false;
         }
         function resolveSassImplementation(projectPath) {
-            const extensionRoot = (0, _optional_deps_lib__rspack_import_4.He)();
+            const extensionRoot = (0, _webpack_lib_develop_context__rspack_import_5.H)();
             const bases = [
                 projectPath,
                 extensionRoot || void 0,
@@ -132969,7 +133211,7 @@ var __webpack_modules__ = {
                 return mod;
             } catch  {}
             try {
-                let mod = __webpack_require__("../../node_modules/.pnpm/sass@1.97.2/node_modules/sass/sass.node.js");
+                let mod = __webpack_require__("../../node_modules/sass/sass.node.js");
                 if (mod && 'object' == typeof mod && 'default' in mod) mod = mod.default;
                 return mod;
             } catch  {
@@ -132991,7 +133233,7 @@ var __webpack_modules__ = {
         }
         async function maybeUseSass(projectPath) {
             if (!isUsingSass(projectPath)) return [];
-            const sassLoaderPath = await (0, _webpack_lib_optional_deps_resolver__rspack_import_5.xr)({
+            const sassLoaderPath = await (0, _webpack_lib_optional_deps_resolver__rspack_import_6.xr)({
                 contractId: 'sass',
                 projectPath,
                 dependencyId: 'sass-loader'
@@ -133030,10 +133272,10 @@ var __webpack_modules__ = {
         var pintor__rspack_import_2 = __webpack_require__("pintor");
         var pintor__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(pintor__rspack_import_2);
         var _css_lib_messages__rspack_import_3 = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
-        var _optional_deps_lib__rspack_import_4 = __webpack_require__("./webpack/optional-deps-lib/index.ts");
+        var optional_deps_lib__rspack_import_4 = __webpack_require__("optional-deps-lib");
         let userMessageDelivered = false;
         function isUsingTailwind(projectPath) {
-            const isUsingTailwind = (0, _optional_deps_lib__rspack_import_4.ws)(projectPath, 'tailwindcss') || (0, _optional_deps_lib__rspack_import_4.ws)(projectPath, '@tailwindcss/postcss');
+            const isUsingTailwind = (0, optional_deps_lib__rspack_import_4.hasDependency)(projectPath, 'tailwindcss') || (0, optional_deps_lib__rspack_import_4.hasDependency)(projectPath, '@tailwindcss/postcss');
             if (isUsingTailwind) {
                 if (!userMessageDelivered) {
                     if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor__rspack_import_2_default().brightMagenta('►►► Author says')} ${_css_lib_messages__rspack_import_3.zA('Tailwind')}`);
@@ -133054,11 +133296,12 @@ var __webpack_modules__ = {
     "./webpack/plugin-js-frameworks/frameworks-lib/integrations.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
-            Dy: ()=>_optional_deps_lib__rspack_import_0.Dy,
+            Dy: ()=>optional_deps_lib__rspack_import_0.installOptionalDependenciesBatch,
             qQ: ()=>isUsingJSFramework,
-            ws: ()=>_optional_deps_lib__rspack_import_0.ws
+            ws: ()=>optional_deps_lib__rspack_import_0.hasDependency
         });
-        var _optional_deps_lib__rspack_import_0 = __webpack_require__("./webpack/optional-deps-lib/index.ts");
+        var optional_deps_lib__rspack_import_0 = __webpack_require__("optional-deps-lib");
+        __webpack_require__("./webpack/webpack-lib/develop-context.ts");
         function isUsingJSFramework(projectPath) {
             const frameworks = [
                 'react',
@@ -133068,7 +133311,7 @@ var __webpack_modules__ = {
                 'solid-js',
                 'preact'
             ];
-            return frameworks.some((fw)=>__webpack_require__("./webpack/optional-deps-lib/index.ts").ws(projectPath, fw));
+            return frameworks.some((fw)=>(0, optional_deps_lib__rspack_import_0.hasDependency)(projectPath, fw));
         }
     },
     "./webpack/plugin-js-frameworks/js-frameworks-lib/load-loader-options.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
@@ -133245,7 +133488,7 @@ var __webpack_modules__ = {
             }
             return false;
         }
-        async function maybeUseReact(projectPath) {
+        async function maybeUseReact(projectPath, options = {}) {
             if (!isUsingReact(projectPath)) return;
             const requireFromProject = (0, module__rspack_import_1.createRequire)(path__rspack_import_0.join(projectPath, 'package.json'));
             let reactPath;
@@ -133274,6 +133517,11 @@ var __webpack_modules__ = {
             if (reactDomClientPath) alias['react-dom/client'] = reactDomClientPath;
             if (jsxRuntimePath) alias['react/jsx-runtime'] = jsxRuntimePath;
             if (jsxDevRuntimePath) alias['react/jsx-dev-runtime'] = jsxDevRuntimePath;
+            if (true === options.disableRefresh) return {
+                plugins: [],
+                loaders: void 0,
+                alias
+            };
             (0, _webpack_lib_optional_deps_resolver__rspack_import_5.Eh)({
                 contractId: 'react-refresh',
                 projectPath,
@@ -133287,7 +133535,10 @@ var __webpack_modules__ = {
             });
             const reactPlugins = [
                 new ReactRefreshPlugin({
-                    overlay: false
+                    overlay: false,
+                    ...void 0 === options.refreshExclude ? {} : {
+                        exclude: options.refreshExclude
+                    }
                 })
             ];
             return {
@@ -133821,6 +134072,52 @@ var __webpack_modules__ = {
         }
         _define_property(PlaywrightPlugin, "name", 'plugin-playwright');
     },
+    "./webpack/plugin-web-extension/feature-scripts/contracts.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            $t: ()=>EXTENSIONJS_CONTENT_SCRIPT_LAYER,
+            HE: ()=>isCanonicalContentScriptAsset,
+            J4: ()=>getCanonicalContentScriptCssAssetName,
+            Mj: ()=>isCanonicalContentScriptEntryName,
+            WG: ()=>parseCanonicalContentScriptEntryIndex,
+            Y0: ()=>getCanonicalContentScriptEntryName,
+            es: ()=>parseCanonicalContentScriptAsset,
+            f6: ()=>getCanonicalContentScriptJsAssetName
+        });
+        const EXTENSIONJS_CONTENT_SCRIPT_LAYER = "extensionjs-content-script";
+        const CANONICAL_CONTENT_SCRIPT_ENTRY_PREFIX = "content_scripts/content-";
+        function getCanonicalContentScriptEntryName(index) {
+            return `${CANONICAL_CONTENT_SCRIPT_ENTRY_PREFIX}${index}`;
+        }
+        function getCanonicalContentScriptJsAssetName(index) {
+            return `${getCanonicalContentScriptEntryName(index)}.js`;
+        }
+        function getCanonicalContentScriptCssAssetName(index) {
+            return `${getCanonicalContentScriptEntryName(index)}.css`;
+        }
+        function parseCanonicalContentScriptEntryIndex(entryName) {
+            const match = /^content_scripts\/content-(\d+)$/.exec(String(entryName || ''));
+            if (!match) return;
+            const index = Number(match[1]);
+            return Number.isInteger(index) ? index : void 0;
+        }
+        function isCanonicalContentScriptEntryName(entryName) {
+            return void 0 !== parseCanonicalContentScriptEntryIndex(entryName);
+        }
+        function parseCanonicalContentScriptAsset(assetName) {
+            const match = /^content_scripts\/content-(\d+)(?:\.[a-f0-9]+)?\.(js|css)$/i.exec(String(assetName || ''));
+            if (!match) return;
+            const index = Number(match[1]);
+            if (!Number.isInteger(index)) return;
+            return {
+                index,
+                extension: match[2]
+            };
+        }
+        function isCanonicalContentScriptAsset(assetName) {
+            return void 0 !== parseCanonicalContentScriptAsset(assetName);
+        }
+    },
     "./webpack/webpack-lib/check-build-dependencies.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -134185,6 +134482,82 @@ var __webpack_modules__ = {
             };
         }
     },
+    "./webpack/webpack-lib/develop-context.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            G: ()=>resolveDevelopDistFile,
+            H: ()=>resolveDevelopInstallRoot
+        });
+        var path__rspack_import_0 = __webpack_require__("path");
+        var fs__rspack_import_1 = __webpack_require__("fs");
+        var _check_build_dependencies__rspack_import_2 = __webpack_require__("./webpack/webpack-lib/check-build-dependencies.ts");
+        var _package_json__rspack_import_3 = __webpack_require__("./package.json");
+        if (!process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION) process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION = _package_json__rspack_import_3.rE;
+        function parseJsonSafe(text) {
+            const raw = 'string' == typeof text ? text : String(text || '');
+            const s = raw && 0xfeff === raw.charCodeAt(0) ? raw.slice(1) : raw;
+            return JSON.parse(s || '{}');
+        }
+        function resolveDevelopRootFromDir(dir) {
+            try {
+                const packageJsonPath = path__rspack_import_0.join(dir, 'package.json');
+                if (!fs__rspack_import_1.existsSync(packageJsonPath)) return;
+                const pkg = parseJsonSafe(fs__rspack_import_1.readFileSync(packageJsonPath, 'utf8'));
+                if (pkg?.name === 'extension-develop') return dir;
+            } catch  {}
+        }
+        function findDevelopRootFrom(startDir) {
+            let currentDir = startDir;
+            const maxDepth = 6;
+            for(let i = 0; i < maxDepth; i++){
+                const root = resolveDevelopRootFromDir(currentDir);
+                if (root) return root;
+                const parent = path__rspack_import_0.dirname(currentDir);
+                if (parent === currentDir) break;
+                currentDir = parent;
+            }
+        }
+        function resolveDevelopInstallRoot() {
+            const envRoot = process.env.EXTENSION_DEVELOP_ROOT;
+            if (envRoot) {
+                const resolvedEnvRoot = resolveDevelopRootFromDir(path__rspack_import_0.resolve(envRoot));
+                if (resolvedEnvRoot) return resolvedEnvRoot;
+            }
+            const directRoot = (0, _check_build_dependencies__rspack_import_2.w1)();
+            if (directRoot) return directRoot;
+            try {
+                const candidateRoot = findDevelopRootFrom(__dirname);
+                if (candidateRoot) return candidateRoot;
+            } catch  {}
+            try {
+                const pkgPath = require.resolve('extension-develop/package.json', {
+                    paths: [
+                        __dirname
+                    ]
+                });
+                return resolveDevelopRootFromDir(path__rspack_import_0.dirname(pkgPath));
+            } catch  {
+                return;
+            }
+        }
+        function resolveDevelopDistFile(stem) {
+            const installRoot = resolveDevelopInstallRoot();
+            const distRoot = installRoot ? path__rspack_import_0.join(installRoot, 'dist') : path__rspack_import_0.resolve(__dirname, '..');
+            const base = path__rspack_import_0.join(distRoot, stem);
+            const candidates = [
+                `${base}.js`,
+                `${base}.cjs`,
+                `${base}.mjs`,
+                base
+            ];
+            for (const candidate of candidates)if (fs__rspack_import_1.existsSync(candidate)) {
+                if ('1' === process.env.EXTENSION_DEBUG_DEVELOP_ROOT) console.log(`[extjs:develop-root] ${stem} -> ${candidate} (installRoot=${installRoot || '<none>'})`);
+                return candidate;
+            }
+            if ('1' === process.env.EXTENSION_DEBUG_DEVELOP_ROOT) console.log(`[extjs:develop-root] ${stem} -> ${base} (fallback, installRoot=${installRoot || '<none>'})`);
+            return base;
+        }
+    },
     "./webpack/webpack-lib/extensions-to-load.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -134253,7 +134626,7 @@ var __webpack_modules__ = {
         var fs__rspack_import_1 = __webpack_require__("fs");
         var crypto__rspack_import_2 = __webpack_require__("crypto");
         var _package_json__rspack_import_3 = __webpack_require__("./package.json");
-        var _optional_deps_lib__rspack_import_4 = __webpack_require__("./webpack/optional-deps-lib/index.ts");
+        var _develop_context__rspack_import_4 = __webpack_require__("./webpack/webpack-lib/develop-context.ts");
         function getInstallCacheDir(packageRoot) {
             return path__rspack_import_0.join(packageRoot, '.cache', 'extensionjs', 'install');
         }
@@ -134312,7 +134685,7 @@ var __webpack_modules__ = {
             }
         }
         function getInstallMarkerPath(projectPath) {
-            const packageRoot = (0, _optional_deps_lib__rspack_import_4.He)();
+            const packageRoot = (0, _develop_context__rspack_import_4.H)();
             if (!packageRoot) return;
             const cacheDir = getInstallCacheDir(packageRoot);
             return path__rspack_import_0.join(cacheDir, `${getProjectKey(projectPath)}.json`);
@@ -134781,54 +135154,11 @@ var __webpack_modules__ = {
             return `${getLoggingPrefix('error')} Your project declares dependencies that are managed by ${pintor__rspack_import_2_default().blue('Extension.js')} and referenced in ${pintor__rspack_import_2_default().underline('extension.config.js')}\n${pintor__rspack_import_2_default().red('This can cause version conflicts and break the development/build process.')}\n\n${pintor__rspack_import_2_default().gray('Managed dependencies (remove these from your package.json):')}\n${list}\n\n${pintor__rspack_import_2_default().gray('PATH')} ${pintor__rspack_import_2_default().underline(userPackageJsonPath)}\nIf you need a different version, open an issue so we can consider bundling it safely.\nOperation aborted.`;
         }
     },
-    "./webpack/webpack-lib/optional-dependencies.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        "use strict";
-        __webpack_require__.d(__webpack_exports__, {
-            ad: ()=>resolveOptionalDependencySpecs,
-            oR: ()=>getOptionalDependenciesSignature
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        var crypto__rspack_import_2 = __webpack_require__("crypto");
-        function getOptionalDependenciesPath() {
-            const candidates = [
-                path__rspack_import_1.join(__dirname, 'optional-dependencies.json'),
-                path__rspack_import_1.resolve(__dirname, '..', 'webpack', 'webpack-lib', 'optional-dependencies.json')
-            ];
-            for (const candidate of candidates)if (fs__rspack_import_0.existsSync(candidate)) return candidate;
-            return candidates[0];
-        }
-        function loadOptionalDependencies() {
-            const metadataPath = getOptionalDependenciesPath();
-            if (!fs__rspack_import_0.existsSync(metadataPath)) throw new Error(`optional-dependencies.json not found at ${metadataPath}. This indicates a corrupted installation.`);
-            try {
-                const content = fs__rspack_import_0.readFileSync(metadataPath, 'utf8');
-                const parsed = JSON.parse(content);
-                if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) throw new Error('optional-dependencies.json must contain an object');
-                return parsed;
-            } catch (error) {
-                throw new Error(`Failed to load optional-dependencies.json: ${error.message}`);
-            }
-        }
-        function resolveOptionalDependencySpecs(dependencies) {
-            const metadata = loadOptionalDependencies();
-            const missingFromMetadata = dependencies.filter((dep)=>!(dep in metadata));
-            if (missingFromMetadata.length > 0) throw new Error(`Dependencies not found in optional-dependencies.json: ${missingFromMetadata.join(', ')}`);
-            return dependencies.map((dep)=>`${dep}@${metadata[dep]}`);
-        }
-        function getOptionalDependenciesSignature() {
-            const metadata = loadOptionalDependencies();
-            const stable = JSON.stringify(Object.keys(metadata).sort().reduce((acc, key)=>{
-                acc[key] = metadata[key];
-                return acc;
-            }, {}));
-            return (0, crypto__rspack_import_2.createHash)('sha1').update(stable).digest('hex');
-        }
-    },
     "./webpack/webpack-lib/optional-deps-contracts.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
-            u: ()=>getOptionalDependencyContract
+            I7: ()=>getContractsSignature,
+            uw: ()=>getOptionalDependencyContract
         });
         function installRootRules(packageIds) {
             return packageIds.map((packageId)=>({
@@ -134844,7 +135174,7 @@ var __webpack_modules__ = {
                 id: "typescript",
                 integration: 'TypeScript',
                 installPackages: [
-                    "typescript"
+                    "typescript@5.9.3"
                 ],
                 verificationRules: installRootRules([
                     "typescript"
@@ -134854,8 +135184,8 @@ var __webpack_modules__ = {
                 id: 'react-refresh',
                 integration: 'React',
                 installPackages: [
-                    'react-refresh',
-                    '@rspack/plugin-react-refresh'
+                    'react-refresh@0.18.0',
+                    '@rspack/plugin-react-refresh@1.6.0'
                 ],
                 verificationRules: [
                     ...installRootRules([
@@ -134873,10 +135203,10 @@ var __webpack_modules__ = {
                 id: 'preact-refresh',
                 integration: 'Preact',
                 installPackages: [
-                    '@prefresh/core',
-                    '@prefresh/utils',
-                    '@rspack/plugin-preact-refresh',
-                    'preact'
+                    '@prefresh/core@1.5.9',
+                    '@prefresh/utils@1.2.1',
+                    '@rspack/plugin-preact-refresh@1.1.4',
+                    'preact@10.27.2'
                 ],
                 verificationRules: [
                     ...installRootRules([
@@ -134906,9 +135236,9 @@ var __webpack_modules__ = {
                 id: 'vue',
                 integration: 'Vue',
                 installPackages: [
-                    'vue-loader',
-                    '@vue/compiler-sfc',
-                    'vue'
+                    'vue-loader@17.4.2',
+                    '@vue/compiler-sfc@3.5.26',
+                    'vue@3.5.26'
                 ],
                 verificationRules: [
                     ...installRootRules([
@@ -134927,8 +135257,8 @@ var __webpack_modules__ = {
                 id: 'svelte',
                 integration: 'Svelte',
                 installPackages: [
-                    "typescript",
-                    'svelte-loader'
+                    "typescript@5.9.3",
+                    'svelte-loader@3.2.4'
                 ],
                 verificationRules: installRootRules([
                     "typescript",
@@ -134939,8 +135269,8 @@ var __webpack_modules__ = {
                 id: 'less',
                 integration: 'LESS',
                 installPackages: [
-                    'less',
-                    'less-loader'
+                    'less@4.5.1',
+                    'less-loader@12.3.0'
                 ],
                 verificationRules: installRootRules([
                     'less',
@@ -134951,8 +135281,8 @@ var __webpack_modules__ = {
                 id: 'postcss',
                 integration: 'PostCSS',
                 installPackages: [
-                    'postcss',
-                    'postcss-loader'
+                    'postcss@8.5.6',
+                    'postcss-loader@8.2.0'
                 ],
                 verificationRules: installRootRules([
                     'postcss',
@@ -134963,10 +135293,10 @@ var __webpack_modules__ = {
                 id: 'sass',
                 integration: 'SASS',
                 installPackages: [
-                    'postcss-loader',
-                    'postcss-scss',
-                    'postcss-preset-env',
-                    'sass-loader'
+                    'postcss-loader@8.2.0',
+                    'postcss-scss@4.0.9',
+                    'postcss-preset-env@11.1.1',
+                    'sass-loader@16.0.6'
                 ],
                 verificationRules: installRootRules([
                     'postcss-loader',
@@ -134981,6 +135311,10 @@ var __webpack_modules__ = {
             if (!contract) throw new Error(`Unknown optional dependency contract: ${contractId}`);
             return contract;
         }
+        function getContractsSignature() {
+            const allSpecs = Object.values(OPTIONAL_DEPENDENCY_CONTRACTS).flatMap((c)=>c.installPackages).sort();
+            return allSpecs.join('::');
+        }
     },
     "./webpack/webpack-lib/optional-deps-resolver.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
@@ -134996,8 +135330,8 @@ var __webpack_modules__ = {
         var fs__rspack_import_0 = __webpack_require__("fs");
         var path__rspack_import_1 = __webpack_require__("path");
         var module__rspack_import_2 = __webpack_require__("module");
-        var _optional_deps_lib__rspack_import_3 = __webpack_require__("./webpack/optional-deps-lib/index.ts");
-        var _optional_deps_lib_install_root_packages__rspack_import_4 = __webpack_require__("./webpack/optional-deps-lib/install-root-packages.ts");
+        var optional_deps_lib__rspack_import_3 = __webpack_require__("optional-deps-lib");
+        var _develop_context__rspack_import_4 = __webpack_require__("./webpack/webpack-lib/develop-context.ts");
         var _optional_deps_contracts__rspack_import_5 = __webpack_require__("./webpack/webpack-lib/optional-deps-contracts.ts");
         const installSingleFlight = new Map();
         function toInstallRootContract(integration, contractId, installDependencies, verifyPackageIds) {
@@ -135020,8 +135354,8 @@ var __webpack_modules__ = {
             return toInstallRootContract(input.integration, input.integration, installDependencies, verifyPackageIds);
         }
         function getResolutionBases(projectPath) {
-            const optionalInstallRoot = (0, _optional_deps_lib__rspack_import_3.Iy)();
-            const extensionRoot = (0, _optional_deps_lib__rspack_import_3.He)();
+            const optionalInstallRoot = (0, optional_deps_lib__rspack_import_3.resolveOptionalInstallRoot)();
+            const extensionRoot = (0, _develop_context__rspack_import_4.H)();
             const bases = [
                 projectPath,
                 optionalInstallRoot && fs__rspack_import_0.existsSync(optionalInstallRoot) ? optionalInstallRoot : void 0,
@@ -135073,7 +135407,7 @@ var __webpack_modules__ = {
             if (installRoot.includes('.pnpm')) return resolveFromInstallRootPackageDir(dependencyId, path__rspack_import_1.join(installRoot, '..', '..'));
         }
         function resolveFromInstallRootPackageDir(dependencyId, installRoot) {
-            return (0, _optional_deps_lib_install_root_packages__rspack_import_4.G)(dependencyId, installRoot);
+            return (0, optional_deps_lib__rspack_import_3.resolvePackageFromInstallRoot)(dependencyId, installRoot);
         }
         function verifyPackageInInstallRoot(packageId, installRoot) {
             if (resolveFromInstallRootPackageDir(packageId, installRoot)) return true;
@@ -135120,7 +135454,7 @@ var __webpack_modules__ = {
                 return rule.packageId;
             }
         }
-        function getContractVerificationFailuresFromKnownLocations(contract, projectPath, installRoot = (0, _optional_deps_lib__rspack_import_3.Iy)()) {
+        function getContractVerificationFailuresFromKnownLocations(contract, projectPath, installRoot = (0, optional_deps_lib__rspack_import_3.resolveOptionalInstallRoot)()) {
             const resolvedByPackage = new Map();
             const resolvePackage = (packageId)=>{
                 if (!resolvedByPackage.has(packageId)) resolvedByPackage.set(packageId, resolveFromKnownLocations(packageId, projectPath, installRoot));
@@ -135142,7 +135476,7 @@ var __webpack_modules__ = {
             }
             return dedupeFailures(failures);
         }
-        function getContractVerificationFailuresAtInstallRoot(contract, installRoot = (0, _optional_deps_lib__rspack_import_3.Iy)()) {
+        function getContractVerificationFailuresAtInstallRoot(contract, installRoot = (0, optional_deps_lib__rspack_import_3.resolveOptionalInstallRoot)()) {
             const resolvedByPackage = new Map();
             const resolvePackage = (packageId)=>{
                 if (!resolvedByPackage.has(packageId)) resolvedByPackage.set(packageId, installRoot ? resolveFromInstallRootPackageDir(packageId, installRoot) : void 0);
@@ -135191,7 +135525,7 @@ var __webpack_modules__ = {
             };
         }
         async function runInstallAndVerify(input) {
-            const didInstall = await (0, _optional_deps_lib__rspack_import_3.tm)(input.integration, input.installDependencies);
+            const didInstall = await (0, optional_deps_lib__rspack_import_3.installOptionalDependencies)(input.integration, input.installDependencies);
             if (!didInstall) {
                 const diagnostics = buildDiagnostics({
                     integration: input.integration,
@@ -135218,15 +135552,21 @@ var __webpack_modules__ = {
             }
             const missingAfterInstall = getContractVerificationFailuresAtInstallRoot(input.contract, input.installRoot);
             if (missingAfterInstall.length > 0) {
-                await (0, _optional_deps_lib__rspack_import_3.tm)(input.integration, input.installDependencies);
+                await (0, optional_deps_lib__rspack_import_3.installOptionalDependencies)(input.integration, input.installDependencies);
                 const missingAfterRetry = getContractVerificationFailuresAtInstallRoot(input.contract, input.installRoot);
                 if (0 === missingAfterRetry.length) return;
-                const didInstallMissingOnly = await (0, _optional_deps_lib__rspack_import_3.tm)(input.integration, missingAfterRetry);
+                const missingIdSet = new Set(missingAfterRetry);
+                const missingSpecs = input.contract.installPackages.filter((spec)=>{
+                    const atIdx = spec.lastIndexOf('@');
+                    const id = atIdx > 0 ? spec.slice(0, atIdx) : spec;
+                    return missingIdSet.has(id);
+                });
+                const didInstallMissingOnly = await (0, optional_deps_lib__rspack_import_3.installOptionalDependencies)(input.integration, missingSpecs.length > 0 ? missingSpecs : missingAfterRetry);
                 if (didInstallMissingOnly) {
                     const missingAfterTargetedTopUp = getContractVerificationFailuresAtInstallRoot(input.contract, input.installRoot);
                     if (0 === missingAfterTargetedTopUp.length) return;
                 }
-                const didRecoverWithCleanInstall = await (0, _optional_deps_lib__rspack_import_3.tm)(input.integration, input.contract.installPackages, {
+                const didRecoverWithCleanInstall = await (0, optional_deps_lib__rspack_import_3.installOptionalDependencies)(input.integration, input.contract.installPackages, {
                     forceRecreateInstallRoot: true
                 });
                 if (didRecoverWithCleanInstall) {
@@ -135246,7 +135586,7 @@ var __webpack_modules__ = {
             }
         }
         async function ensureInstalledAndVerified(input) {
-            const installRoot = (0, _optional_deps_lib__rspack_import_3.Iy)();
+            const installRoot = (0, optional_deps_lib__rspack_import_3.resolveOptionalInstallRoot)();
             const key = [
                 installRoot || 'missing-install-root',
                 ...input.installDependencies.slice().sort()
@@ -135270,7 +135610,7 @@ var __webpack_modules__ = {
             }
         }
         function resolveOptionalDependencySync(dependencyId, projectPath) {
-            const installRoot = (0, _optional_deps_lib__rspack_import_3.Iy)();
+            const installRoot = (0, optional_deps_lib__rspack_import_3.resolveOptionalInstallRoot)();
             const resolved = resolveFromKnownLocations(dependencyId, projectPath, installRoot);
             if (resolved) return resolved;
             const bases = getResolutionBases(projectPath);
@@ -135280,7 +135620,7 @@ var __webpack_modules__ = {
             const contract = getVerificationContract(input);
             const installDependencies = contract.installPackages;
             const verifyPackageIds = contract.installPackages;
-            const installRoot = (0, _optional_deps_lib__rspack_import_3.Iy)();
+            const installRoot = (0, optional_deps_lib__rspack_import_3.resolveOptionalInstallRoot)();
             const resolvedBeforeInstall = resolveFromKnownLocations(input.dependencyId, input.projectPath, installRoot);
             const missingBeforeInstall = getContractVerificationFailuresFromKnownLocations(contract, input.projectPath, installRoot);
             if (resolvedBeforeInstall && 0 === missingBeforeInstall.length) return resolvedBeforeInstall;
@@ -135325,7 +135665,7 @@ var __webpack_modules__ = {
             const contract = getVerificationContract(input);
             const installDependencies = contract.installPackages;
             const verifyPackageIds = contract.installPackages;
-            const installRoot = (0, _optional_deps_lib__rspack_import_3.Iy)();
+            const installRoot = (0, optional_deps_lib__rspack_import_3.resolveOptionalInstallRoot)();
             const resolvedFromInstallRoot = installRoot ? resolveFromInstallRootPackageDir(input.dependencyId, installRoot) : void 0;
             const missingFromInstallRoot = getContractVerificationFailuresAtInstallRoot(contract, installRoot);
             if (resolvedFromInstallRoot && 0 === missingFromInstallRoot.length) return resolvedFromInstallRoot;
@@ -135380,7 +135720,7 @@ var __webpack_modules__ = {
                         integration: input.integration,
                         dependencyId: input.dependencyId,
                         projectPath: input.projectPath,
-                        installRoot: (0, _optional_deps_lib__rspack_import_3.Iy)(),
+                        installRoot: (0, optional_deps_lib__rspack_import_3.resolveOptionalInstallRoot)(),
                         installDependencies: input.installDependencies || [
                             input.dependencyId
                         ],
@@ -135429,7 +135769,7 @@ var __webpack_modules__ = {
             return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
         }
         async function ensureOptionalContractPackageResolved(input) {
-            const contract = (0, _optional_deps_contracts__rspack_import_5.u)(input.contractId);
+            const contract = (0, _optional_deps_contracts__rspack_import_5.uw)(input.contractId);
             return ensureOptionalPackageResolved({
                 integration: contract.integration,
                 projectPath: input.projectPath,
@@ -135438,7 +135778,7 @@ var __webpack_modules__ = {
             });
         }
         async function ensureOptionalContractModuleLoaded(input) {
-            const contract = (0, _optional_deps_contracts__rspack_import_5.u)(input.contractId);
+            const contract = (0, _optional_deps_contracts__rspack_import_5.uw)(input.contractId);
             return ensureOptionalModuleLoaded({
                 integration: contract.integration,
                 projectPath: input.projectPath,
@@ -135448,7 +135788,7 @@ var __webpack_modules__ = {
             });
         }
         function resolveOptionalContractPackageWithoutInstall(input) {
-            const contract = (0, _optional_deps_contracts__rspack_import_5.u)(input.contractId);
+            const contract = (0, _optional_deps_contracts__rspack_import_5.uw)(input.contractId);
             return resolveOptionalPackageWithoutInstall({
                 integration: contract.integration,
                 projectPath: input.projectPath,
@@ -135457,7 +135797,7 @@ var __webpack_modules__ = {
             });
         }
         function loadOptionalContractModuleWithoutInstall(input) {
-            const contract = (0, _optional_deps_contracts__rspack_import_5.u)(input.contractId);
+            const contract = (0, _optional_deps_contracts__rspack_import_5.uw)(input.contractId);
             return loadOptionalModuleWithoutInstall({
                 integration: contract.integration,
                 projectPath: input.projectPath,
@@ -135467,391 +135807,6 @@ var __webpack_modules__ = {
             });
         }
     },
-    "./webpack/webpack-lib/package-json.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        "use strict";
-        __webpack_require__.d(__webpack_exports__, {
-            Pb: ()=>findNearestPackageJsonSync,
-            cy: ()=>findNearestPackageJson,
-            t7: ()=>validatePackageJson
-        });
-        var path__rspack_import_0 = __webpack_require__("path");
-        var fs__rspack_import_1 = __webpack_require__("fs");
-        async function findUpLocal(filename, options) {
-            const root = path__rspack_import_0.parse(options.cwd).root;
-            let currentDir = options.cwd;
-            while(true){
-                const candidate = path__rspack_import_0.join(currentDir, filename);
-                try {
-                    const stat = await fs__rspack_import_1.promises.stat(candidate);
-                    if (stat.isFile()) return candidate;
-                } catch  {}
-                if (currentDir === root) return;
-                currentDir = path__rspack_import_0.dirname(currentDir);
-            }
-        }
-        function findUpLocalSync(filename, options) {
-            const root = path__rspack_import_0.parse(options.cwd).root;
-            let currentDir = options.cwd;
-            while(true){
-                const candidate = path__rspack_import_0.join(currentDir, filename);
-                try {
-                    const stat = fs__rspack_import_1.statSync(candidate);
-                    if (stat.isFile()) return candidate;
-                } catch  {}
-                if (currentDir === root) return;
-                currentDir = path__rspack_import_0.dirname(currentDir);
-            }
-        }
-        async function findNearestPackageJson(manifestPath) {
-            try {
-                const manifestDir = path__rspack_import_0.dirname(manifestPath);
-                const packageJsonPath = await findUpLocal('package.json', {
-                    cwd: manifestDir
-                });
-                return packageJsonPath || null;
-            } catch (error) {
-                console.warn('Failed to find package.json:', error);
-                return null;
-            }
-        }
-        function findNearestPackageJsonSync(manifestPath) {
-            try {
-                const manifestDir = path__rspack_import_0.dirname(manifestPath);
-                const packageJsonPath = findUpLocalSync('package.json', {
-                    cwd: manifestDir
-                });
-                return packageJsonPath || null;
-            } catch (error) {
-                console.warn('Failed to find package.json:', error);
-                return null;
-            }
-        }
-        function validatePackageJson(packageJsonPath) {
-            try {
-                if (!fs__rspack_import_1.existsSync(packageJsonPath)) return false;
-                const content = fs__rspack_import_1.readFileSync(packageJsonPath, 'utf-8');
-                JSON.parse(content);
-                return true;
-            } catch (error) {
-                console.warn('Invalid package.json at:', packageJsonPath, error);
-                return false;
-            }
-        }
-    },
-    "./webpack/webpack-lib/package-manager.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        "use strict";
-        __webpack_require__.d(__webpack_exports__, {
-            Qt: ()=>execInstallCommand,
-            _c: ()=>resolvePackageManager,
-            sX: ()=>buildNpmCliFallback,
-            tj: ()=>buildInstallCommand
-        });
-        var fs__rspack_import_0 = __webpack_require__("fs");
-        var path__rspack_import_1 = __webpack_require__("path");
-        var child_process__rspack_import_2 = __webpack_require__("child_process");
-        var module__rspack_import_3 = __webpack_require__("module");
-        const require1 = (0, module__rspack_import_3.createRequire)(__rslib_import_meta_url__);
-        function normalizePackageManager(value) {
-            if (!value) return;
-            const lower = value.toLowerCase().trim();
-            if ('pnpm' === lower) return 'pnpm';
-            if ('yarn' === lower) return 'yarn';
-            if ('bun' === lower) return 'bun';
-            if ('npm' === lower) return 'npm';
-        }
-        function inferPackageManagerFromPath(value) {
-            if (!value) return;
-            const lower = value.toLowerCase();
-            if (lower.includes('pnpm')) return 'pnpm';
-            if (lower.includes('yarn')) return 'yarn';
-            if (lower.includes('bun')) return 'bun';
-            if (lower.includes('npm')) return 'npm';
-        }
-        function getPackageManagerOverride() {
-            const name = normalizePackageManager(process.env.EXTENSION_JS_PACKAGE_MANAGER);
-            const execPath = process.env.EXTENSION_JS_PM_EXEC_PATH || process.env.npm_execpath || process.env.NPM_EXEC_PATH;
-            if (!name && !execPath) return;
-            const inferredName = name || inferPackageManagerFromPath(execPath) || 'npm';
-            return {
-                name: inferredName,
-                execPath
-            };
-        }
-        function detectPackageManagerFromEnv() {
-            const userAgent = process.env.npm_config_user_agent || '';
-            const execPath = process.env.npm_execpath || process.env.NPM_EXEC_PATH || '';
-            if (userAgent.includes('pnpm')) return {
-                name: 'pnpm',
-                execPath: execPath || void 0
-            };
-            if (userAgent.includes('yarn')) return {
-                name: 'yarn',
-                execPath: execPath || void 0
-            };
-            if (userAgent.includes('bun')) return {
-                name: 'bun',
-                execPath: execPath || void 0
-            };
-            if (userAgent.includes('npm')) return {
-                name: 'npm',
-                execPath: execPath || void 0
-            };
-            if (execPath) {
-                const inferred = inferPackageManagerFromPath(execPath) || 'npm';
-                return {
-                    name: inferred,
-                    execPath
-                };
-            }
-        }
-        function resolveNpmCliFromNode(execPath) {
-            const execDir = path__rspack_import_1.dirname(execPath);
-            const candidates = [
-                path__rspack_import_1.join(execDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-                path__rspack_import_1.join(execDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-                path__rspack_import_1.join(execDir, '..', 'node_modules', 'npm', 'bin', 'npm-cli.js')
-            ];
-            for (const candidate of candidates)if (fs__rspack_import_0.existsSync(candidate)) return candidate;
-        }
-        function resolveBundledNpmCliPath() {
-            if (process.env.EXTENSION_JS_PM_EXEC_PATH) {
-                const overridePath = process.env.EXTENSION_JS_PM_EXEC_PATH;
-                if (overridePath && fs__rspack_import_0.existsSync(overridePath)) return overridePath;
-            }
-            try {
-                const resolved = require1.resolve('npm/bin/npm-cli.js', {
-                    paths: [
-                        process.cwd(),
-                        __dirname
-                    ]
-                });
-                if (resolved && fs__rspack_import_0.existsSync(resolved)) return resolved;
-            } catch  {}
-            return resolveNpmCliFromNode(process.execPath);
-        }
-        function isWindowsExecutablePath(value) {
-            if (!value || 'win32' !== process.platform) return false;
-            return /\.(cmd|bat|exe)$/i.test(value);
-        }
-        function isNodeScriptPath(value) {
-            if (!value) return false;
-            return /\.(mjs|cjs|js)$/i.test(value);
-        }
-        function resolveWindowsCommandPath(command) {
-            if ('win32' !== process.platform) return;
-            try {
-                const systemRoot = process.env.SystemRoot || 'C:\\Windows';
-                const whereExe = path__rspack_import_1.join(systemRoot, 'System32', 'where.exe');
-                const whereCommand = fs__rspack_import_0.existsSync(whereExe) ? whereExe : 'where';
-                const output = (0, child_process__rspack_import_2.execFileSync)(whereCommand, [
-                    command
-                ], {
-                    encoding: 'utf8',
-                    stdio: [
-                        'ignore',
-                        'pipe',
-                        'ignore'
-                    ],
-                    windowsHide: true
-                });
-                const candidates = String(output).split(/\r?\n/).map((line)=>line.trim()).filter(Boolean);
-                const cmdMatch = candidates.find((line)=>/\.cmd$/i.test(line));
-                return cmdMatch || candidates[0];
-            } catch  {
-                return;
-            }
-        }
-        function resolveUnixCommandPath(command) {
-            if ('win32' === process.platform) return;
-            try {
-                const output = (0, child_process__rspack_import_2.execFileSync)('which', [
-                    command
-                ], {
-                    encoding: 'utf8',
-                    stdio: [
-                        'ignore',
-                        'pipe',
-                        'ignore'
-                    ]
-                });
-                const candidate = String(output).trim();
-                return candidate || void 0;
-            } catch  {
-                return;
-            }
-        }
-        function resolveCommandOnPath(command) {
-            return resolveWindowsCommandPath(command) || resolveUnixCommandPath(command) || void 0;
-        }
-        function canRunCorepack() {
-            try {
-                const fallback = require1('child_process');
-                const spawnSync = child_process__rspack_import_2.spawnSync?.mock !== void 0 ? child_process__rspack_import_2.spawnSync : fallback.spawnSync || child_process__rspack_import_2.spawnSync;
-                const result = spawnSync('corepack', [
-                    '--version'
-                ], {
-                    stdio: 'ignore',
-                    windowsHide: true
-                });
-                return result?.status === 0;
-            } catch  {
-                return false;
-            }
-        }
-        function detectByLockfile(cwd) {
-            if (!cwd) return;
-            const hasPnpmLock = fs__rspack_import_0.existsSync(path__rspack_import_1.join(cwd, 'pnpm-lock.yaml'));
-            const hasYarnLock = fs__rspack_import_0.existsSync(path__rspack_import_1.join(cwd, 'yarn.lock'));
-            const hasNpmLock = fs__rspack_import_0.existsSync(path__rspack_import_1.join(cwd, 'package-lock.json'));
-            if (hasPnpmLock) return 'pnpm';
-            if (hasYarnLock) return 'yarn';
-            if (hasNpmLock) return 'npm';
-        }
-        function hydrateResolvedPackageManager(name) {
-            const resolvedCommand = resolveCommandOnPath(name);
-            if (resolvedCommand) return {
-                name,
-                execPath: resolvedCommand
-            };
-            if ('npm' === name) {
-                const bundledNpmCli = resolveBundledNpmCliPath();
-                if (bundledNpmCli) return {
-                    name: 'npm',
-                    execPath: bundledNpmCli,
-                    runnerCommand: process.execPath,
-                    runnerArgs: [
-                        bundledNpmCli
-                    ]
-                };
-            }
-        }
-        function resolvePackageManager(opts) {
-            const lockPm = detectByLockfile(opts?.cwd);
-            if (lockPm) {
-                const hydrated = hydrateResolvedPackageManager(lockPm);
-                if (hydrated) return hydrated;
-                return {
-                    name: lockPm
-                };
-            }
-            const override = getPackageManagerOverride();
-            if (override) return override;
-            const envPm = detectPackageManagerFromEnv();
-            if (envPm) return envPm;
-            const candidates = [
-                'pnpm',
-                'yarn',
-                'bun'
-            ];
-            for (const candidate of candidates){
-                const resolved = resolveCommandOnPath(candidate);
-                if (resolved) return {
-                    name: candidate,
-                    execPath: resolved
-                };
-            }
-            const corepackPath = resolveCommandOnPath('corepack');
-            if (corepackPath || canRunCorepack()) return {
-                name: 'pnpm',
-                runnerCommand: corepackPath || 'corepack',
-                runnerArgs: [
-                    'pnpm'
-                ]
-            };
-            const bundledNpmCli = resolveBundledNpmCliPath();
-            if (bundledNpmCli) return {
-                name: 'npm',
-                execPath: bundledNpmCli,
-                runnerCommand: process.execPath,
-                runnerArgs: [
-                    bundledNpmCli
-                ]
-            };
-            return {
-                name: 'npm'
-            };
-        }
-        function buildExecEnv() {
-            if ('win32' !== process.platform) return;
-            const nodeDir = path__rspack_import_1.dirname(process.execPath);
-            const pathSep = path__rspack_import_1.delimiter;
-            const existing = process.env.PATH || process.env.Path || '';
-            if (existing.includes(nodeDir)) return;
-            return {
-                ...process.env,
-                PATH: `${nodeDir}${pathSep}${existing}`.trim(),
-                Path: `${nodeDir}${pathSep}${existing}`.trim()
-            };
-        }
-        function buildInstallCommand(pm, args) {
-            if (pm.runnerCommand) return {
-                command: pm.runnerCommand,
-                args: [
-                    ...pm.runnerArgs || [],
-                    ...args
-                ]
-            };
-            if (pm.execPath) {
-                if (isWindowsExecutablePath(pm.execPath)) return {
-                    command: pm.execPath,
-                    args
-                };
-                if (isNodeScriptPath(pm.execPath)) return {
-                    command: process.execPath,
-                    args: [
-                        pm.execPath,
-                        ...args
-                    ]
-                };
-                return {
-                    command: pm.execPath,
-                    args
-                };
-            }
-            return {
-                command: pm.name,
-                args
-            };
-        }
-        function buildNpmCliFallback(args) {
-            const npmCli = resolveBundledNpmCliPath();
-            if (!npmCli) return;
-            return {
-                command: process.execPath,
-                args: [
-                    npmCli,
-                    ...args
-                ]
-            };
-        }
-        function buildSpawnInvocation(command, args) {
-            return {
-                command,
-                args
-            };
-        }
-        function execInstallCommand(command, args, options) {
-            const invocation = buildSpawnInvocation(command, args);
-            const env = buildExecEnv();
-            const stdio = options?.stdio ?? 'ignore';
-            const useShell = 'win32' === process.platform && /\.(cmd|bat)$/i.test(invocation.command);
-            return new Promise((resolve, reject)=>{
-                const child = (0, child_process__rspack_import_2.spawn)(invocation.command, invocation.args, {
-                    cwd: options?.cwd,
-                    stdio,
-                    env: env || process.env,
-                    ...useShell ? {
-                        shell: true
-                    } : {}
-                });
-                child.on('close', (code)=>{
-                    if (0 !== code) reject(new Error(`Install failed with exit code ${code}`));
-                    else resolve();
-                });
-                child.on('error', (error)=>reject(error));
-            });
-        }
-    },
     "./webpack/webpack-lib/paths.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
         __webpack_require__.d(__webpack_exports__, {
@@ -136057,6 +136012,10 @@ var __webpack_modules__ = {
         "use strict";
         module.exports = require("node:module");
     },
+    "optional-deps-lib" (module) {
+        "use strict";
+        module.exports = require("optional-deps-lib");
+    },
     os (module) {
         "use strict";
         module.exports = require("os");
@@ -136103,7 +136062,7 @@ var __webpack_modules__ = {
     },
     "./package.json" (module) {
         "use strict";
-        module.exports = JSON.parse('{"rE":"3.10.3","El":{"@rspack/core":"^1.7.5","@rspack/dev-server":"^1.2.1","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.1","case-sensitive-paths-webpack-plugin":"^2.4.0","chrome-location2":"4.0.0","chromium-location":"2.0.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","edge-location":"2.2.0","extension-from-store":"^0.1.1","firefox-location2":"3.0.0","go-git-it":"^5.1.1","ignore":"^7.0.5","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5":"^8.0.0","parse5-utilities":"^1.0.0","pintor":"0.3.0","schema-utils":"^4.3.3","tiny-glob":"^0.2.9","unique-names-generator":"^4.7.1","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3","ws":"^8.19.0"}}');
+        module.exports = JSON.parse('{"rE":"3.10.4-canary.1","El":{"@rspack/core":"^1.7.5","@rspack/dev-server":"^1.2.1","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.1","case-sensitive-paths-webpack-plugin":"^2.4.0","chrome-location2":"4.0.0","chromium-location":"2.0.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","edge-location":"2.2.0","extension-from-store":"^0.1.1","firefox-location2":"3.0.0","go-git-it":"^5.1.1","ignore":"^7.0.5","loader-utils":"^3.3.1","magic-string":"^0.30.21","optional-deps-lib":"0.1.1","parse5":"^8.0.0","parse5-utilities":"^1.0.0","pintor":"0.3.0","schema-utils":"^4.3.3","tiny-glob":"^0.2.9","unique-names-generator":"^4.7.1","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3","ws":"^8.19.0"}}');
     }
 };
 var __webpack_module_cache__ = {};
@@ -136198,7 +136157,42 @@ var __webpack_exports__ = {};
     var external_path_ = __webpack_require__("path");
     var external_fs_ = __webpack_require__("fs");
     var messages = __webpack_require__("./webpack/webpack-lib/messages.ts");
-    var package_json = __webpack_require__("./webpack/webpack-lib/package-json.ts");
+    async function findUpLocal(filename, options) {
+        const root = external_path_.parse(options.cwd).root;
+        let currentDir = options.cwd;
+        while(true){
+            const candidate = external_path_.join(currentDir, filename);
+            try {
+                const stat = await external_fs_.promises.stat(candidate);
+                if (stat.isFile()) return candidate;
+            } catch  {}
+            if (currentDir === root) return;
+            currentDir = external_path_.dirname(currentDir);
+        }
+    }
+    async function findNearestPackageJson(manifestPath) {
+        try {
+            const manifestDir = external_path_.dirname(manifestPath);
+            const packageJsonPath = await findUpLocal('package.json', {
+                cwd: manifestDir
+            });
+            return packageJsonPath || null;
+        } catch (error) {
+            console.warn('Failed to find package.json:', error);
+            return null;
+        }
+    }
+    function validatePackageJson(packageJsonPath) {
+        try {
+            if (!external_fs_.existsSync(packageJsonPath)) return false;
+            const content = external_fs_.readFileSync(packageJsonPath, 'utf-8');
+            JSON.parse(content);
+            return true;
+        } catch (error) {
+            console.warn('Invalid package.json at:', packageJsonPath, error);
+            return false;
+        }
+    }
     const isUrl = (url)=>{
         try {
             new URL(url);
@@ -136326,7 +136320,7 @@ var __webpack_exports__ = {};
             const rel = external_path_.relative(baseDir, candidatePath);
             return Boolean(rel && !rel.startsWith('..') && !external_path_.isAbsolute(rel));
         };
-        const packageJsonPathFromProject = await (0, package_json.cy)(external_path_.join(projectPath, 'manifest.json'));
+        const 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');
@@ -136350,7 +136344,7 @@ var __webpack_exports__ = {};
             if (foundManifest) manifestPath = foundManifest;
             else throw new Error(messages.dx(manifestPath));
         }
-        const packageJsonPath = await (0, package_json.cy)(manifestPath);
+        const packageJsonPath = await findNearestPackageJson(manifestPath);
         const packageJsonDir = packageJsonPath ? external_path_.dirname(packageJsonPath) : void 0;
         if (packageJsonDir) {
             const publicRoot = external_path_.join(packageJsonDir, 'public');
@@ -136362,7 +136356,7 @@ var __webpack_exports__ = {};
                 else throw new Error(messages.dx(fallbackRoot));
             }
         }
-        if (!packageJsonPath || !(0, package_json.t7)(packageJsonPath)) return {
+        if (!packageJsonPath || !validatePackageJson(packageJsonPath)) return {
             manifestPath
         };
         return {
@@ -136404,7 +136398,297 @@ var __webpack_exports__ = {};
     }
     var paths = __webpack_require__("./webpack/webpack-lib/paths.ts");
     var check_build_dependencies = __webpack_require__("./webpack/webpack-lib/check-build-dependencies.ts");
-    var package_manager = __webpack_require__("./webpack/webpack-lib/package-manager.ts");
+    var external_child_process_ = __webpack_require__("child_process");
+    const package_manager_require = (0, external_module_.createRequire)(__rslib_import_meta_url__);
+    function normalizePackageManager(value) {
+        if (!value) return;
+        const lower = value.toLowerCase().trim();
+        if ('pnpm' === lower) return 'pnpm';
+        if ('yarn' === lower) return 'yarn';
+        if ('bun' === lower) return 'bun';
+        if ('npm' === lower) return 'npm';
+    }
+    function inferPackageManagerFromPath(value) {
+        if (!value) return;
+        const lower = value.toLowerCase();
+        if (lower.includes('pnpm')) return 'pnpm';
+        if (lower.includes('yarn')) return 'yarn';
+        if (lower.includes('bun')) return 'bun';
+        if (lower.includes('npm')) return 'npm';
+    }
+    function getPackageManagerOverride() {
+        const name = normalizePackageManager(process.env.EXTENSION_JS_PACKAGE_MANAGER);
+        const execPath = process.env.EXTENSION_JS_PM_EXEC_PATH || process.env.npm_execpath || process.env.NPM_EXEC_PATH;
+        if (!name && !execPath) return;
+        const inferredName = name || inferPackageManagerFromPath(execPath) || 'npm';
+        return {
+            name: inferredName,
+            execPath
+        };
+    }
+    function detectPackageManagerFromEnv() {
+        const userAgent = process.env.npm_config_user_agent || '';
+        const execPath = process.env.npm_execpath || process.env.NPM_EXEC_PATH || '';
+        if (userAgent.includes('pnpm')) return {
+            name: 'pnpm',
+            execPath: execPath || void 0
+        };
+        if (userAgent.includes('yarn')) return {
+            name: 'yarn',
+            execPath: execPath || void 0
+        };
+        if (userAgent.includes('bun')) return {
+            name: 'bun',
+            execPath: execPath || void 0
+        };
+        if (userAgent.includes('npm')) return {
+            name: 'npm',
+            execPath: execPath || void 0
+        };
+        if (execPath) {
+            const inferred = inferPackageManagerFromPath(execPath) || 'npm';
+            return {
+                name: inferred,
+                execPath
+            };
+        }
+    }
+    function resolveNpmCliFromNode(execPath) {
+        const execDir = external_path_.dirname(execPath);
+        const candidates = [
+            external_path_.join(execDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+            external_path_.join(execDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+            external_path_.join(execDir, '..', 'node_modules', 'npm', 'bin', 'npm-cli.js')
+        ];
+        for (const candidate of candidates)if (external_fs_.existsSync(candidate)) return candidate;
+    }
+    function resolveBundledNpmCliPath() {
+        if (process.env.EXTENSION_JS_PM_EXEC_PATH) {
+            const overridePath = process.env.EXTENSION_JS_PM_EXEC_PATH;
+            if (overridePath && external_fs_.existsSync(overridePath)) return overridePath;
+        }
+        try {
+            const resolved = package_manager_require.resolve('npm/bin/npm-cli.js', {
+                paths: [
+                    process.cwd(),
+                    __dirname
+                ]
+            });
+            if (resolved && external_fs_.existsSync(resolved)) return resolved;
+        } catch  {}
+        return resolveNpmCliFromNode(process.execPath);
+    }
+    function isWindowsExecutablePath(value) {
+        if (!value || 'win32' !== process.platform) return false;
+        return /\.(cmd|bat|exe)$/i.test(value);
+    }
+    function isNodeScriptPath(value) {
+        if (!value) return false;
+        return /\.(mjs|cjs|js)$/i.test(value);
+    }
+    function resolveWindowsCommandPath(command) {
+        if ('win32' !== process.platform) return;
+        try {
+            const systemRoot = process.env.SystemRoot || 'C:\\Windows';
+            const whereExe = external_path_.join(systemRoot, 'System32', 'where.exe');
+            const whereCommand = external_fs_.existsSync(whereExe) ? whereExe : 'where';
+            const output = (0, external_child_process_.execFileSync)(whereCommand, [
+                command
+            ], {
+                encoding: 'utf8',
+                stdio: [
+                    'ignore',
+                    'pipe',
+                    'ignore'
+                ],
+                windowsHide: true
+            });
+            const candidates = String(output).split(/\r?\n/).map((line)=>line.trim()).filter(Boolean);
+            const cmdMatch = candidates.find((line)=>/\.cmd$/i.test(line));
+            return cmdMatch || candidates[0];
+        } catch  {
+            return;
+        }
+    }
+    function resolveUnixCommandPath(command) {
+        if ('win32' === process.platform) return;
+        try {
+            const output = (0, external_child_process_.execFileSync)('which', [
+                command
+            ], {
+                encoding: 'utf8',
+                stdio: [
+                    'ignore',
+                    'pipe',
+                    'ignore'
+                ]
+            });
+            const candidate = String(output).trim();
+            return candidate || void 0;
+        } catch  {
+            return;
+        }
+    }
+    function resolveCommandOnPath(command) {
+        return resolveWindowsCommandPath(command) || resolveUnixCommandPath(command) || void 0;
+    }
+    function canRunCorepack() {
+        try {
+            const fallback = package_manager_require('child_process');
+            const spawnSync = external_child_process_.spawnSync?.mock !== void 0 ? external_child_process_.spawnSync : fallback.spawnSync || external_child_process_.spawnSync;
+            const result = spawnSync('corepack', [
+                '--version'
+            ], {
+                stdio: 'ignore',
+                windowsHide: true
+            });
+            return result?.status === 0;
+        } catch  {
+            return false;
+        }
+    }
+    function detectByLockfile(cwd) {
+        if (!cwd) return;
+        const hasPnpmLock = external_fs_.existsSync(external_path_.join(cwd, 'pnpm-lock.yaml'));
+        const hasYarnLock = external_fs_.existsSync(external_path_.join(cwd, 'yarn.lock'));
+        const hasNpmLock = external_fs_.existsSync(external_path_.join(cwd, 'package-lock.json'));
+        if (hasPnpmLock) return 'pnpm';
+        if (hasYarnLock) return 'yarn';
+        if (hasNpmLock) return 'npm';
+    }
+    function hydrateResolvedPackageManager(name) {
+        const resolvedCommand = resolveCommandOnPath(name);
+        if (resolvedCommand) return {
+            name,
+            execPath: resolvedCommand
+        };
+        if ('npm' === name) {
+            const bundledNpmCli = resolveBundledNpmCliPath();
+            if (bundledNpmCli) return {
+                name: 'npm',
+                execPath: bundledNpmCli,
+                runnerCommand: process.execPath,
+                runnerArgs: [
+                    bundledNpmCli
+                ]
+            };
+        }
+    }
+    function package_manager_resolvePackageManager(opts) {
+        const lockPm = detectByLockfile(opts?.cwd);
+        if (lockPm) {
+            const hydrated = hydrateResolvedPackageManager(lockPm);
+            if (hydrated) return hydrated;
+            return {
+                name: lockPm
+            };
+        }
+        const override = getPackageManagerOverride();
+        if (override) return override;
+        const envPm = detectPackageManagerFromEnv();
+        if (envPm) return envPm;
+        const candidates = [
+            'pnpm',
+            'yarn',
+            'bun'
+        ];
+        for (const candidate of candidates){
+            const resolved = resolveCommandOnPath(candidate);
+            if (resolved) return {
+                name: candidate,
+                execPath: resolved
+            };
+        }
+        const corepackPath = resolveCommandOnPath('corepack');
+        if (corepackPath || canRunCorepack()) return {
+            name: 'pnpm',
+            runnerCommand: corepackPath || 'corepack',
+            runnerArgs: [
+                'pnpm'
+            ]
+        };
+        const bundledNpmCli = resolveBundledNpmCliPath();
+        if (bundledNpmCli) return {
+            name: 'npm',
+            execPath: bundledNpmCli,
+            runnerCommand: process.execPath,
+            runnerArgs: [
+                bundledNpmCli
+            ]
+        };
+        return {
+            name: 'npm'
+        };
+    }
+    function buildExecEnv() {
+        if ('win32' !== process.platform) return;
+        const nodeDir = external_path_.dirname(process.execPath);
+        const pathSep = external_path_.delimiter;
+        const existing = process.env.PATH || process.env.Path || '';
+        if (existing.includes(nodeDir)) return;
+        return {
+            ...process.env,
+            PATH: `${nodeDir}${pathSep}${existing}`.trim(),
+            Path: `${nodeDir}${pathSep}${existing}`.trim()
+        };
+    }
+    function buildInstallCommand(pm, args) {
+        if (pm.runnerCommand) return {
+            command: pm.runnerCommand,
+            args: [
+                ...pm.runnerArgs || [],
+                ...args
+            ]
+        };
+        if (pm.execPath) {
+            if (isWindowsExecutablePath(pm.execPath)) return {
+                command: pm.execPath,
+                args
+            };
+            if (isNodeScriptPath(pm.execPath)) return {
+                command: process.execPath,
+                args: [
+                    pm.execPath,
+                    ...args
+                ]
+            };
+            return {
+                command: pm.execPath,
+                args
+            };
+        }
+        return {
+            command: pm.name,
+            args
+        };
+    }
+    function buildSpawnInvocation(command, args) {
+        return {
+            command,
+            args
+        };
+    }
+    function execInstallCommand(command, args, options) {
+        const invocation = buildSpawnInvocation(command, args);
+        const env = buildExecEnv();
+        const stdio = options?.stdio ?? 'ignore';
+        const useShell = 'win32' === process.platform && /\.(cmd|bat)$/i.test(invocation.command);
+        return new Promise((resolve, reject)=>{
+            const child = (0, external_child_process_.spawn)(invocation.command, invocation.args, {
+                cwd: options?.cwd,
+                stdio,
+                env: env || process.env,
+                ...useShell ? {
+                    shell: true
+                } : {}
+            });
+            child.on('close', (code)=>{
+                if (0 !== code) reject(new Error(`Install failed with exit code ${code}`));
+                else resolve();
+            });
+            child.on('error', (error)=>reject(error));
+        });
+    }
     function clearLine() {
         if (!process.stdout.isTTY) return;
         process.stdout.write('\r');
@@ -136477,7 +136761,7 @@ var __webpack_exports__ = {};
         const originalDirectory = process.cwd();
         try {
             process.chdir(packageRoot);
-            const pm = (0, package_manager._c)({
+            const pm = package_manager_resolvePackageManager({
                 cwd: packageRoot
             });
             const installArgs = getInstallArgs(pm.name, dependencies, dependenciesMap);
@@ -136492,9 +136776,9 @@ var __webpack_exports__ = {};
             });
             if (!progressEnabled) console.log(progressLabel);
             if (isAuthor) console.warn(messages.TL('build dependencies'));
-            const command = (0, package_manager.tj)(pm, installArgs);
+            const command = buildInstallCommand(pm, installArgs);
             try {
-                await (0, package_manager.Qt)(command.command, command.args, {
+                await execInstallCommand(command.command, command.args, {
                     cwd: packageRoot,
                     stdio
                 });
@@ -136605,7 +136889,7 @@ var __webpack_exports__ = {};
         const progressLabel = messages.Vy();
         try {
             process.chdir(projectPath);
-            const pm = (0, package_manager._c)({
+            const pm = package_manager_resolvePackageManager({
                 cwd: process.cwd()
             });
             let dependenciesArgs = install_dependencies_getInstallArgs();
@@ -136625,8 +136909,8 @@ var __webpack_exports__ = {};
             const stdio = isAuthor ? 'inherit' : 'ignore';
             console.log(progressLabel);
             if (isAuthor) console.warn(messages.TL('project dependencies'));
-            const command = (0, package_manager.tj)(pm, dependenciesArgs);
-            await (0, package_manager.Qt)(command.command, command.args, {
+            const command = buildInstallCommand(pm, dependenciesArgs);
+            await execInstallCommand(command.command, command.args, {
                 cwd: projectPath,
                 stdio
             });
@@ -136663,8 +136947,8 @@ var __webpack_exports__ = {};
     var external_pintor_ = __webpack_require__("pintor");
     var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_);
     var external_crypto_ = __webpack_require__("crypto");
-    var optional_deps_lib = __webpack_require__("./webpack/optional-deps-lib/index.ts");
-    var optional_dependencies = __webpack_require__("./webpack/webpack-lib/optional-dependencies.ts");
+    var develop_context = __webpack_require__("./webpack/webpack-lib/develop-context.ts");
+    var optional_deps_contracts = __webpack_require__("./webpack/webpack-lib/optional-deps-contracts.ts");
     function getPreflightCacheDir(packageRoot) {
         return external_path_.join(packageRoot, '.cache', 'extensionjs', 'preflight');
     }
@@ -136675,7 +136959,7 @@ var __webpack_exports__ = {};
         return external_path_.join(cacheDir, 'version.json');
     }
     function getProjectDepsHash(projectPath) {
-        const optionalDepsSignature = (0, optional_dependencies.oR)();
+        const optionalDepsSignature = (0, optional_deps_contracts.I7)();
         try {
             const packageJsonPath = external_path_.join(projectPath, 'package.json');
             if (!external_fs_.existsSync(packageJsonPath)) return (0, external_crypto_.createHash)('sha1').update(JSON.stringify({
@@ -136731,7 +137015,7 @@ var __webpack_exports__ = {};
         }
     }
     function getPreflightMarkerPath(projectPath) {
-        const packageRoot = (0, optional_deps_lib.He)();
+        const packageRoot = (0, develop_context.H)();
         if (!packageRoot) return;
         const cacheDir = getPreflightCacheDir(packageRoot);
         return external_path_.join(cacheDir, `${getProjectKey(projectPath)}.json`);
@@ -136781,7 +137065,6 @@ var __webpack_exports__ = {};
             }));
         } catch  {}
     }
-    var optional_deps_contracts = __webpack_require__("./webpack/webpack-lib/optional-deps-contracts.ts");
     var react = __webpack_require__("./webpack/plugin-js-frameworks/js-tools/react.ts");
     var preact = __webpack_require__("./webpack/plugin-js-frameworks/js-tools/preact.ts");
     var vue = __webpack_require__("./webpack/plugin-js-frameworks/js-tools/vue.ts");
@@ -136794,7 +137077,7 @@ var __webpack_exports__ = {};
     var js_frameworks_lib_messages = __webpack_require__("./webpack/plugin-js-frameworks/js-frameworks-lib/messages.ts");
     var optional_deps_resolver = __webpack_require__("./webpack/webpack-lib/optional-deps-resolver.ts");
     function getInstallRootVerificationFailures(contractIds) {
-        return Array.from(new Set(contractIds.flatMap((contractId)=>(0, optional_deps_resolver.lr)((0, optional_deps_contracts.u)(contractId)))));
+        return Array.from(new Set(contractIds.flatMap((contractId)=>(0, optional_deps_resolver.lr)((0, optional_deps_contracts.uw)(contractId)))));
     }
     async function verifyContractsResolvedAtInstallRoot(contractIds) {
         let failures = getInstallRootVerificationFailures(contractIds);
@@ -136830,7 +137113,7 @@ var __webpack_exports__ = {};
         };
         const addActiveContract = (contractId)=>{
             activeContractIds.push(contractId);
-            usedIntegrations.push((0, optional_deps_contracts.u)(contractId).integration);
+            usedIntegrations.push((0, optional_deps_contracts.uw)(contractId).integration);
         };
         const usesTypeScript = (0, typescript.eE)(projectPath);
         const usesReact = (0, react.S)(projectPath);
@@ -136851,7 +137134,7 @@ var __webpack_exports__ = {};
             if (usesPostCss) usedIntegrations.push('PostCSS');
         } else addActiveContract('postcss');
         for (const contractId of Array.from(new Set(activeContractIds))){
-            const contract = (0, optional_deps_contracts.u)(contractId);
+            const contract = (0, optional_deps_contracts.uw)(contractId);
             const failures = (0, optional_deps_resolver.OE)(contract, projectPath);
             if (0 !== failures.length) {
                 contractsNeedingInstall.push(contractId);
@@ -136862,8 +137145,8 @@ var __webpack_exports__ = {};
             const uniqueIntegrations = Array.from(new Set(usedIntegrations));
             const installPlans = uniqueIntegrations.map((integration)=>({
                     integration,
-                    dependencies: missingByIntegration[integration] || []
-                })).filter((plan)=>plan.dependencies.length > 0);
+                    dependencySpecs: missingByIntegration[integration] || []
+                })).filter((plan)=>plan.dependencySpecs.length > 0);
             const didInstall = await (0, integrations.Dy)(installPlans);
             if (!didInstall) throw new Error('[Optional] Optional dependencies failed to install.');
             await verifyContractsResolvedAtInstallRoot(Array.from(new Set(contractsNeedingInstall)));
@@ -136899,17 +137182,17 @@ var __webpack_exports__ = {};
         ];
         const missing = requiredFiles.filter((file)=>!external_fs_.existsSync(file));
         if (0 === missing.length) return;
-        const pm = (0, package_manager._c)({
+        const pm = package_manager_resolvePackageManager({
             cwd: developRoot
         });
-        const command = (0, package_manager.tj)(pm, [
+        const command = buildInstallCommand(pm, [
             'run',
             'compile'
         ]);
         const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
         const stdio = isAuthor ? 'inherit' : 'ignore';
         if (isAuthor) console.warn(messages.TL('extension-develop build artifacts (dist missing)'));
-        await (0, package_manager.Qt)(command.command, command.args, {
+        await execInstallCommand(command.command, command.args, {
             cwd: developRoot,
             stdio
         });
@@ -136944,7 +137227,7 @@ var __webpack_exports__ = {};
                 __webpack_require__.e("552").then(__webpack_require__.bind(__webpack_require__, "./webpack/webpack-lib/stats-handler.ts")),
                 Promise.all([
                     __webpack_require__.e("215"),
-                    __webpack_require__.e("270")
+                    __webpack_require__.e("677")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./webpack/webpack-config.ts"))
             ]);
             const debug = isAuthor;
@@ -137089,7 +137372,7 @@ var __webpack_exports__ = {};
             if ('true' === process.env.EXTENSION_DEV_DRY_RUN) return;
             const { devServer } = await Promise.all([
                 __webpack_require__.e("215"),
-                __webpack_require__.e("270"),
+                __webpack_require__.e("677"),
                 __webpack_require__.e("324")
             ]).then(__webpack_require__.bind(__webpack_require__, "./webpack/dev-server/index.ts"));
             await devServer(projectStructure, {
@@ -137164,22 +137447,13 @@ var __webpack_exports__ = {};
     var dark_mode = __webpack_require__("./webpack/webpack-lib/dark-mode.ts");
     var output_binaries_resolver = __webpack_require__("./webpack/plugin-browsers/browsers-lib/output-binaries-resolver.ts");
     var banner = __webpack_require__("./webpack/plugin-browsers/browsers-lib/banner.ts");
+    var runtime_options = __webpack_require__("./webpack/plugin-browsers/browsers-lib/runtime-options.ts");
     var chromium_context = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-context/index.ts");
     var chromium_launch = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-launch/index.ts");
     var firefox_context = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-context/index.ts");
     var firefox_launch = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-launch/index.ts");
-    async function runOnlyPreviewBrowser(opts) {
-        const sourceEnabled = false;
-        let exitScheduled = false;
-        const scheduleExitOnSignal = ()=>{
-            if (exitScheduled) return;
-            exitScheduled = true;
-            setTimeout(()=>process.exit(0), 10);
-        };
-        process.once('SIGINT', scheduleExitOnSignal);
-        process.once('SIGTERM', scheduleExitOnSignal);
-        process.once('SIGHUP', scheduleExitOnSignal);
-        const compilationLike = {
+    function createPreviewCompilationLike(opts) {
+        return {
             options: {
                 mode: 'production',
                 context: opts.contextDir,
@@ -137189,8 +137463,9 @@ var __webpack_exports__ = {};
             },
             errors: []
         };
-        (0, output_binaries_resolver.LB)(compilationLike);
-        const common = {
+    }
+    function buildPreviewPluginOptions(opts) {
+        return {
             extension: opts.extensionsToLoad,
             browser: opts.browser,
             noOpen: opts.noOpen,
@@ -137204,47 +137479,81 @@ var __webpack_exports__ = {};
             geckoBinary: opts.geckoBinary,
             instanceId: opts.instanceId,
             port: opts.port,
-            source: sourceEnabled ? opts.source : void 0,
-            watchSource: sourceEnabled ? opts.watchSource : void 0,
             dryRun: opts.dryRun
         };
+    }
+    function buildPreviewChromiumOptions(opts) {
+        const pluginOptions = buildPreviewPluginOptions(opts);
+        return {
+            extension: pluginOptions.extension,
+            browser: pluginOptions.browser,
+            noOpen: pluginOptions.noOpen,
+            profile: pluginOptions.profile,
+            preferences: pluginOptions.preferences,
+            browserFlags: pluginOptions.browserFlags,
+            excludeBrowserFlags: pluginOptions.excludeBrowserFlags,
+            startingUrl: pluginOptions.startingUrl,
+            chromiumBinary: pluginOptions.chromiumBinary,
+            instanceId: pluginOptions.instanceId,
+            port: pluginOptions.port,
+            dryRun: pluginOptions.dryRun
+        };
+    }
+    function buildPreviewFirefoxOptions(opts) {
+        const pluginOptions = buildPreviewPluginOptions(opts);
+        return {
+            extension: pluginOptions.extension,
+            browser: pluginOptions.browser,
+            profile: pluginOptions.profile,
+            preferences: pluginOptions.preferences,
+            browserFlags: pluginOptions.browserFlags,
+            startingUrl: pluginOptions.startingUrl,
+            geckoBinary: pluginOptions.geckoBinary,
+            instanceId: pluginOptions.instanceId,
+            port: pluginOptions.port,
+            dryRun: pluginOptions.dryRun
+        };
+    }
+    function buildPreviewBannerOptions(opts) {
+        return {
+            browser: opts.browser,
+            outPath: opts.outPath,
+            includeExtensionId: true,
+            includeRunId: false,
+            readyPath: opts.readyPath
+        };
+    }
+    async function runOnlyPreviewBrowser(opts) {
+        let exitScheduled = false;
+        const scheduleExitOnSignal = ()=>{
+            if (exitScheduled) return;
+            exitScheduled = true;
+            setTimeout(()=>process.exit(0), 10);
+        };
+        process.once('SIGINT', scheduleExitOnSignal);
+        process.once('SIGTERM', scheduleExitOnSignal);
+        process.once('SIGHUP', scheduleExitOnSignal);
+        const compilationLike = createPreviewCompilationLike(opts);
+        const previewPluginOptions = buildPreviewPluginOptions(opts);
+        const bannerOptions = buildPreviewBannerOptions(opts);
+        (0, output_binaries_resolver.LB)(compilationLike);
         if ('chrome' === opts.browser || 'edge' === opts.browser || 'chromium' === opts.browser || 'chromium-based' === opts.browser) {
             const ctx = (0, chromium_context.g)();
-            const launcher = new chromium_launch.f(common, ctx);
+            const launcher = new chromium_launch.f(buildPreviewChromiumOptions(opts), ctx);
             await launcher.runOnce(compilationLike, {
                 enableCdpPostLaunch: false
             });
-            await (0, banner.M)({
-                browser: opts.browser,
-                outPath: opts.outPath,
-                includeExtensionId: true,
-                includeRunId: false,
-                readyPath: opts.readyPath
-            });
+            await (0, banner.M)(bannerOptions);
             return;
         }
         if ('firefox' === opts.browser || 'gecko-based' === opts.browser || 'firefox-based' === opts.browser) {
             const ctx = (0, firefox_context.D)();
-            const launcher = new firefox_launch.c(common, ctx);
-            await launcher.runOnce(compilationLike, {
-                browser: opts.browser,
-                mode: 'production',
-                profile: opts.profile,
-                persistProfile: opts.persistProfile,
-                preferences: opts.preferences,
-                browserFlags: opts.browserFlags,
-                excludeBrowserFlags: opts.excludeBrowserFlags,
-                startingUrl: opts.startingUrl,
-                geckoBinary: opts.geckoBinary,
-                port: opts.port
-            });
-            await (0, banner.M)({
-                browser: opts.browser,
-                outPath: opts.outPath,
-                includeExtensionId: true,
-                includeRunId: false,
-                readyPath: opts.readyPath
-            });
+            const launcher = new firefox_launch.c(buildPreviewFirefoxOptions(opts), ctx);
+            await launcher.runOnce(compilationLike, (0, runtime_options.zU)(previewPluginOptions, 'production', {
+                persistProfile: previewPluginOptions.persistProfile,
+                geckoBinary: previewPluginOptions.geckoBinary
+            }));
+            await (0, banner.M)(bannerOptions);
             return;
         }
         throw new Error(`Unsupported browser: ${String(opts.browser)}`);