extension 4.1.12 → 4.1.13

package/dist/browsers.cjs

@@ -641,12 +641,6 @@ var __webpack_modules__ = {
         function firefoxLaunchCalled() {
             return `${getLoggingPrefix('debug')} browser  launch browser=firefox`;
         }
-        function firefoxBinaryArgsExtracted(args) {
-            return `${getLoggingPrefix('debug')} browser  args="${args}"`;
-        }
-        function firefoxNoBinaryArgsFound() {
-            return `${getLoggingPrefix('debug')} browser  args=none`;
-        }
         function firefoxFailedToStart(error) {
             return `${getLoggingPrefix('error')} Firefox failed to start.\n${pintor__rspack_import_8_default().red(errorDetail(error))}`;
         }
@@ -656,8 +650,8 @@ var __webpack_modules__ = {
         function firefoxDryRunBinary(path) {
             return `${getLoggingPrefix('info')} ${pintor__rspack_import_8_default().gray('PATH')} ${pintor__rspack_import_8_default().underline(path)}`;
         }
-        function firefoxDryRunConfig(cfg) {
-            return `${getLoggingPrefix('info')} ${pintor__rspack_import_8_default().gray('CONFIG')} ${pintor__rspack_import_8_default().gray(cfg)}`;
+        function firefoxDryRunArgs(args) {
+            return `${getLoggingPrefix('info')} ${pintor__rspack_import_8_default().gray('ARGS')} ${pintor__rspack_import_8_default().gray(args)}`;
         }
         function safariBuildCalled() {
             return `${getLoggingPrefix('debug')} browser  build browser=safari`;
@@ -957,7 +951,6 @@ var __webpack_modules__ = {
             bv: ()=>cdpUnifiedExtensionLog,
             cD: ()=>targetActorHasActiveRequestError,
             cF: ()=>safariRebuilt,
-            dN: ()=>firefoxNoBinaryArgsFound,
             dk: ()=>generalBrowserError,
             dw: ()=>devFirefoxProfilePath,
             e_: ()=>runningInDevelopment,
@@ -968,14 +961,13 @@ var __webpack_modules__ = {
             fw: ()=>safariOpening,
             hE: ()=>cdpClientConnectionClosed,
             io: ()=>emptyLine,
-            iv: ()=>firefoxBinaryArgsExtracted,
             jP: ()=>rdpInvalidRequestPayload,
             jR: ()=>safariBuilding,
             jc: ()=>safariProjectStale,
             jk: ()=>requireGeckoBinaryForGeckoBased,
-            k6: ()=>firefoxDryRunConfig,
             kK: ()=>preferringSystemBrowserOverSnapshot,
             l9: ()=>parsingPacketError,
+            lO: ()=>firefoxDryRunArgs,
             l_: ()=>safariConverted,
             ne: ()=>requireChromiumBinaryForChromiumBased,
             nn: ()=>chromeProcessExited,
@@ -998,6 +990,22 @@ var __webpack_modules__ = {
             yc: ()=>safariDryRunNotBuilding
         });
     },
+    "./browsers/browsers-lib/newtab-override.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        var node_fs__rspack_import_0 = __webpack_require__("node:fs");
+        var node_path__rspack_import_1 = __webpack_require__("node:path");
+        function manifestDeclaresNewtabOverride(outPath) {
+            try {
+                const manifest = JSON.parse(node_fs__rspack_import_0.readFileSync(node_path__rspack_import_1.join(outPath, 'manifest.json'), 'utf-8'));
+                const overrides = manifest?.chrome_url_overrides || manifest?.['chromium:chrome_url_overrides'] || manifest?.['chrome:chrome_url_overrides'] || manifest?.['gecko:chrome_url_overrides'] || manifest?.['firefox:chrome_url_overrides'];
+                return Boolean(overrides && 'string' == typeof overrides.newtab && overrides.newtab.trim().length > 0);
+            } catch  {
+                return false;
+            }
+        }
+        __webpack_require__.d(__webpack_exports__, {
+            c: ()=>manifestDeclaresNewtabOverride
+        });
+    },
     "./browsers/browsers-lib/output-binaries-resolver.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         var node_fs__rspack_import_0 = __webpack_require__("node:fs");
         var node_path__rspack_import_1 = __webpack_require__("node:path");
@@ -1472,6 +1480,7 @@ var __webpack_modules__ = {
         }
         function resolveProfileConfig(input) {
             const { managedBaseDir, useSystemProfile, persistProfile, keepProfileChanges, copyFromProfile, resolveExplicit } = input;
+            const provision = false !== input.provision;
             const rawProfile = normalizeProfileOption(input.rawProfile);
             if (false === rawProfile || useSystemProfile) return {
                 kind: 'system',
@@ -1502,6 +1511,14 @@ var __webpack_modules__ = {
                 profilePath = external_node_path_.join(managedBaseDir, human);
             }
             const isFreshTarget = !external_node_fs_.existsSync(profilePath) || 0 === external_node_fs_.readdirSync(profilePath).length;
+            if (!provision) return {
+                kind: 'managed',
+                profilePath,
+                persisted,
+                ...hasCopyFrom(copyFromProfile) && isFreshTarget ? {
+                    seededFrom: copyFromProfile.trim()
+                } : {}
+            };
             external_node_fs_.mkdirSync(profilePath, {
                 recursive: true
             });
@@ -1975,6 +1992,7 @@ var __webpack_modules__ = {
                 preferences: opts.preferences,
                 browserFlags: opts.browserFlags,
                 startingUrl: opts.startingUrl,
+                noOpen: opts.noOpen,
                 geckoBinary: opts.geckoBinary,
                 instanceId: opts.instanceId,
                 port: opts.port,
@@ -2179,6 +2197,38 @@ var __webpack_modules__ = {
         var messaging = __webpack_require__("./helpers/messaging.ts");
         var banner = __webpack_require__("./browsers/browsers-lib/banner.ts");
         var instance_registry = __webpack_require__("./browsers/browsers-lib/instance-registry.ts");
+        const MSG_REFERENCE = /__MSG_([A-Za-z0-9_@]+?)__/g;
+        function collectMsgReferences(value) {
+            const found = [];
+            const seen = new Set();
+            const visit = (node)=>{
+                if ('string' == typeof node) {
+                    MSG_REFERENCE.lastIndex = 0;
+                    let match = MSG_REFERENCE.exec(node);
+                    while(null !== match){
+                        const name = match[1];
+                        if (name && !name.startsWith('@@') && !seen.has(name)) {
+                            seen.add(name);
+                            found.push(name);
+                        }
+                        match = MSG_REFERENCE.exec(node);
+                    }
+                    return;
+                }
+                if (Array.isArray(node)) {
+                    for (const item of node)visit(item);
+                    return;
+                }
+                if (node && 'object' == typeof node) for (const item of Object.values(node))visit(item);
+            };
+            visit(value);
+            return found;
+        }
+        function findUndefinedMsgReferences(value, catalogKeys) {
+            const lower = new Set();
+            for (const key of catalogKeys)lower.add(String(key).toLowerCase());
+            return collectMsgReferences(value).filter((name)=>!lower.has(name.toLowerCase()));
+        }
         function diagnoseChromiumManifestRefusal(manifest) {
             const m = manifest;
             if (2 === Number(m?.manifest_version)) return 'mv2';
@@ -2313,7 +2363,7 @@ var __webpack_modules__ = {
                     if (external_node_fs_.existsSync(catalogPath)) try {
                         const raw = external_node_fs_.readFileSync(catalogPath, 'utf8').replace(/^\uFEFF/, '');
                         const catalog = JSON.parse(raw);
-                        catalogKeys = new Set(Object.keys(catalog || {}).map((key)=>key.toLowerCase()));
+                        catalogKeys = new Set(Object.keys(catalog || {}));
                     } catch  {
                         blockers.push(`default_locale: _locales/${defaultLocale}/messages.json is not valid JSON, Chrome refuses the whole extension.`);
                     }
@@ -2321,11 +2371,7 @@ var __webpack_modules__ = {
                 } catch  {
                     return blockers;
                 }
-                if (catalogKeys) {
-                    const refs = new Set();
-                    collectMsgRefs(m, refs);
-                    for (const ref of refs)if (!catalogKeys.has(ref.toLowerCase())) blockers.push(`__MSG_${ref}__: used in the manifest but not defined in _locales/${defaultLocale}/messages.json, Chrome refuses the whole extension.`);
-                }
+                if (catalogKeys) for (const ref of findUndefinedMsgReferences(m, catalogKeys))blockers.push(`__MSG_${ref}__: used in the manifest but not defined in _locales/${defaultLocale}/messages.json, Chrome refuses the whole extension.`);
             } else try {
                 if (external_node_fs_.existsSync(localesDir)) {
                     const hasCatalog = external_node_fs_.readdirSync(localesDir).some((entry)=>external_node_fs_.existsSync(external_node_path_.join(localesDir, entry, 'messages.json')));
@@ -2346,13 +2392,6 @@ var __webpack_modules__ = {
             } catch  {}
             return [];
         }
-        function collectMsgRefs(value, out) {
-            if ('string' == typeof value) {
-                const match = /^__MSG_(.+)__$/.exec(value.trim());
-                if (match && !match[1].startsWith('@@')) out.add(match[1]);
-            } else if (Array.isArray(value)) for (const item of value)collectMsgRefs(item, out);
-            else if (value && 'object' == typeof value) for (const item of Object.values(value))collectMsgRefs(item, out);
-        }
         function isValidDottedVersion(version) {
             if (!version) return false;
             const parts = version.split('.');
@@ -2533,7 +2572,19 @@ var __webpack_modules__ = {
             });
             external_node_fs_.writeFileSync(preferencesPath, JSON.stringify(mergedPreferences), 'utf8');
         }
-        function browserConfig(compilation, configOptions) {
+        function chromiumLaunchPlan(binary, chromiumConfig, startingUrl) {
+            return {
+                binary,
+                args: startingUrl ? [
+                    ...chromiumConfig,
+                    startingUrl
+                ] : [
+                    ...chromiumConfig
+                ]
+            };
+        }
+        function browserConfig(compilation, configOptions, mode = {}) {
+            const provision = false !== mode.provision;
             const extensionsToLoad = (0, runtime_options.fT)(configOptions.extension);
             const devWantsCDP = compilation?.options?.mode === 'development';
             const rawProfile = configOptions.profile;
@@ -2557,17 +2608,18 @@ var __webpack_modules__ = {
                 persistProfile: configOptions.persistProfile,
                 keepProfileChanges: configOptions.keepProfileChanges,
                 copyFromProfile: configOptions.copyFromProfile,
-                resolveExplicit: (trimmedProfile)=>external_node_path_.isAbsolute(trimmedProfile) ? trimmedProfile : external_node_path_.resolve(contextDir, trimmedProfile)
+                resolveExplicit: (trimmedProfile)=>external_node_path_.isAbsolute(trimmedProfile) ? trimmedProfile : external_node_path_.resolve(contextDir, trimmedProfile),
+                provision
             });
             const userProfilePath = resolved.profilePath;
-            if ('managed' === resolved.kind) {
+            if ('managed' === resolved.kind && provision) {
                 if ((0, messaging._o)()) (0, messaging._w)(messages.sY(shownPath(userProfilePath)));
                 if (!resolved.persisted) try {
                     const maxAgeHours = parseInt(String(process.env.EXTENSION_TMP_PROFILE_MAX_AGE_HOURS || ''), 10);
                     (0, shared_utils.CW)(managedBaseDir, external_node_path_.basename(userProfilePath), Number.isFinite(maxAgeHours) ? maxAgeHours : 12);
                 } catch  {}
             }
-            if (userProfilePath) {
+            if (userProfilePath && provision) {
                 external_node_fs_.mkdirSync(userProfilePath, {
                     recursive: true
                 });
@@ -2888,7 +2940,10 @@ var __webpack_modules__ = {
                         process.exit(1);
                     }
                 }
-                if (this.options?.dryRun || process.env.VITEST || process.env.VITEST_WORKER_ID) return void logChromiumDryRun(this.options?.chromiumBinary ? (0, wsl_support.f7)(String(this.options.chromiumBinary)) : 'chromium-mock-binary', []);
+                const inTestRunner = Boolean(process.env.VITEST || process.env.VITEST_WORKER_ID);
+                const dryRun = Boolean(this.options?.dryRun);
+                if (inTestRunner && !dryRun) return void logChromiumDryRun(this.options?.chromiumBinary ? (0, wsl_support.f7)(String(this.options.chromiumBinary)) : 'chromium-mock-binary', []);
+                if (inTestRunner && dryRun && !this.options?.chromiumBinary) return void this.printDryRunPlan(compilation, 'chromium-mock-binary');
                 const browser = this.options?.browser;
                 let browserBinaryLocation = null;
                 let printedGuidance = false;
@@ -3197,6 +3252,8 @@ var __webpack_modules__ = {
                         instanceId: this.options.instanceId,
                         extension: extensionsToLoad,
                         logLevel: this.options.logLevel
+                    }, {
+                        provision: !dryRun
                     });
                 } catch (error) {
                     if (shared_utils.ci(error)) (0, ready_stamp.iD)((0, extension_output_path.W)(compilation, void 0), {
@@ -3229,7 +3286,7 @@ var __webpack_modules__ = {
                         enableCdp
                     });
                 } catch  {}
-                if (this.options.dryRun) return void logChromiumDryRun(browserBinaryLocation, chromiumConfig);
+                if (dryRun) return void this.printDryRunPlan(compilation, browserBinaryLocation, chromiumConfig);
                 const usePipe = chromiumConfig.includes('--remote-debugging-pipe');
                 this.closeHandlerContext = {
                     isDevMode: 'development' === compilation.options.mode,
@@ -3299,14 +3356,18 @@ var __webpack_modules__ = {
                     reportReady();
                 }
             }
+            printDryRunPlan(compilation, binary, chromiumConfig) {
+                const flags = chromiumConfig ?? browserConfig(compilation, {
+                    ...this.options
+                }, {
+                    provision: false
+                });
+                const plan = chromiumLaunchPlan(binary, flags, this.options?.startingUrl);
+                logChromiumDryRun(plan.binary, plan.args);
+            }
             async launchWithDirectSpawn(binary, chromeFlags, usePipe = false) {
                 if ((0, messaging._o)()) this.logger.info(messages.xy());
-                const launchArgs = this.options?.startingUrl ? [
-                    ...chromeFlags,
-                    this.options.startingUrl
-                ] : [
-                    ...chromeFlags
-                ];
+                const { args: launchArgs } = chromiumLaunchPlan(binary, chromeFlags, this.options?.startingUrl);
                 const stdio = usePipe ? [
                     'ignore',
                     'ignore',
@@ -3579,6 +3640,29 @@ var __webpack_modules__ = {
             return /^(1|true)$/i.test(String(env.MOZ_HEADLESS || '').trim()) || (0, shared_utils.ZO)(env);
         }
         class FirefoxBinaryDetector {
+            static launchPlan(input) {
+                if (input.profilePath) return FirefoxBinaryDetector.generateFirefoxArgs(input.binaryPath, input.profilePath, input.debugPort, input.binaryArgs, input.headless);
+                const args = [
+                    ...input.headless ? [
+                        '-headless'
+                    ] : [],
+                    ...input.debugPort > 0 ? [
+                        '-start-debugger-server',
+                        String(input.debugPort)
+                    ] : [],
+                    ...'win32' === process.platform ? [
+                        '-wait-for-browser'
+                    ] : [],
+                    ...input.headless ? [] : [
+                        '--foreground'
+                    ],
+                    ...input.binaryArgs
+                ];
+                return {
+                    binary: input.binaryPath,
+                    args
+                };
+            }
             static generateFirefoxArgs(binaryPath, profilePath, debugPort, additionalArgs = [], headless = false) {
                 const headlessArgs = headless ? [
                     '-headless'
@@ -3708,7 +3792,8 @@ var __webpack_modules__ = {
                 ...customPrefs
             };
         }
-        async function browserConfig(compilation, configOptions) {
+        async function resolveFirefoxLaunchConfig(compilation, configOptions, mode = {}) {
+            const provision = false !== mode.provision;
             const { browser, profile, browserFlags = [] } = configOptions;
             const binaryArgs = [];
             const excludeFlags = configOptions.excludeBrowserFlags || [];
@@ -3736,17 +3821,18 @@ var __webpack_modules__ = {
                 persistProfile: configOptions.persistProfile,
                 keepProfileChanges: configOptions.keepProfileChanges,
                 copyFromProfile: configOptions.copyFromProfile,
-                resolveExplicit: (trimmedProfile)=>external_node_path_.isAbsolute(trimmedProfile) ? trimmedProfile : external_node_path_.resolve(contextDir, trimmedProfile)
+                resolveExplicit: (trimmedProfile)=>external_node_path_.isAbsolute(trimmedProfile) ? trimmedProfile : external_node_path_.resolve(contextDir, trimmedProfile),
+                provision
             });
             const profilePath = resolved.profilePath;
-            if ('managed' === resolved.kind) {
+            if ('managed' === resolved.kind && provision) {
                 if ((0, messaging._o)()) (0, messaging._w)(messages.sY(shownPath(profilePath)));
                 if (!resolved.persisted) try {
                     const maxAgeHours = parseInt(String(process.env.EXTENSION_TMP_PROFILE_MAX_AGE_HOURS || ''), 10);
                     (0, shared_utils.CW)(managedBaseDir, external_node_path_.basename(profilePath), Number.isFinite(maxAgeHours) ? maxAgeHours : 12);
                 } catch  {}
             }
-            if (profilePath) {
+            if (profilePath && provision) {
                 try {
                     external_node_fs_.mkdirSync(profilePath, {
                         recursive: true
@@ -3759,7 +3845,7 @@ var __webpack_modules__ = {
                     });
                 } catch  {}
             }
-            if (profilePath) try {
+            if (profilePath && provision) try {
                 const prefs = getPreferences(configOptions?.preferences || {});
                 function serializeValue(value) {
                     if ('string' == typeof value) return JSON.stringify(value);
@@ -3779,13 +3865,17 @@ var __webpack_modules__ = {
             ];
             if (binaryArgs.length > 0) parts.unshift(`--binary-args="${binaryArgs.join(' ')}"`);
             if (profilePath) parts.splice(1, 0, `--profile="${profilePath}"`);
-            return parts.join(' ');
+            return {
+                profilePath,
+                binaryArgs,
+                config: parts.join(' ')
+            };
         }
-        function logFirefoxDryRun(browserBinaryLocation, firefoxConfig) {
+        function logFirefoxDryRun(browserBinaryLocation, launchArgs) {
             if ((0, messaging._o)()) (0, messaging._w)(messages.A9());
             (0, messaging._w)(messages.qn());
             (0, messaging._w)(messages.LD(browserBinaryLocation));
-            (0, messaging._w)(messages.k6(firefoxConfig));
+            (0, messaging._w)(messages.lO(launchArgs.join(' ')));
         }
         const activeInstances = new Set();
         let globalHandlersInstalled = false;
@@ -3850,6 +3940,7 @@ var __webpack_modules__ = {
                 activeInstances.delete(instance);
             };
         }
+        var newtab_override = __webpack_require__("./browsers/browsers-lib/newtab-override.ts");
         var constants = __webpack_require__("./browsers/browsers-lib/constants.ts");
         var manifest_readiness = __webpack_require__("./browsers/run-chromium/manifest-readiness.ts");
         function resolveAddonDirectory(baseDir, inputPath) {
@@ -4103,6 +4194,110 @@ var __webpack_modules__ = {
                 } catch  {}
             });
         }
+        const MANAGER_ADDON_ID = 'devtools@extension.js';
+        const OPEN_NEW_TAB_EXPRESSION = "(function () { var api = globalThis.browser || globalThis.chrome; api.tabs.create({active: true}); return true;})()";
+        const TARGET_WAIT_MS = 2000;
+        function reportStep(step, detail) {
+            if (!(0, messaging._o)()) return;
+            const reason = detail instanceof Error ? detail.message : void 0 === detail ? '' : ` ${JSON.stringify(detail).slice(0, 300)}`;
+            (0, messaging.mR)(`[browser] Firefox new-tab courtesy: ${step}${reason}`);
+        }
+        async function findManagerAddon(client) {
+            const reply = await client.request({
+                to: 'root',
+                type: 'listAddons'
+            });
+            return (reply?.addons || []).find((addon)=>addon?.id === MANAGER_ADDON_ID);
+        }
+        function manager_tab_unsubscribe(client, listener) {
+            if ('function' == typeof client.off) client.off('message', listener);
+            else client.removeListener?.('message', listener);
+        }
+        function isBackgroundPage(target) {
+            return /_generated_background_page\.html|\/background/.test(String(target?.url || ''));
+        }
+        async function resolveConsoleActorViaWatcher(client, descriptorActor) {
+            const watcher = await client.request({
+                to: descriptorActor,
+                type: 'getWatcher',
+                isServerTargetSwitchingEnabled: true
+            });
+            const noop = ()=>{};
+            if (!watcher?.actor) return {
+                release: noop
+            };
+            const watcherActor = watcher.actor;
+            const release = ()=>{
+                client.request({
+                    to: watcherActor,
+                    type: 'unwatchTargets',
+                    targetType: 'frame'
+                }).catch(()=>{});
+            };
+            const targets = [];
+            const collect = (message)=>{
+                const event = message;
+                if (event?.type === 'target-available-form' && event.target) targets.push(event.target);
+            };
+            client.on('message', collect);
+            try {
+                collect(await client.request({
+                    to: watcherActor,
+                    type: 'watchTargets',
+                    targetType: 'frame'
+                }));
+                const deadline = Date.now() + TARGET_WAIT_MS;
+                while(Date.now() < deadline){
+                    const background = targets.find((target)=>target.consoleActor && isBackgroundPage(target));
+                    if (background) return {
+                        consoleActor: background.consoleActor,
+                        release
+                    };
+                    await new Promise((resolve)=>setTimeout(resolve, 50));
+                }
+                return {
+                    consoleActor: targets.find((target)=>target.consoleActor)?.consoleActor,
+                    release
+                };
+            } finally{
+                manager_tab_unsubscribe(client, collect);
+            }
+        }
+        async function resolveConsoleActor(client, addon) {
+            if (addon.consoleActor) return {
+                consoleActor: addon.consoleActor,
+                release: ()=>{}
+            };
+            if (!addon.actor) return {
+                release: ()=>{}
+            };
+            return await resolveConsoleActorViaWatcher(client, addon.actor);
+        }
+        async function openManagerNewTab(client) {
+            try {
+                const addon = await findManagerAddon(client);
+                if (!addon) {
+                    reportStep('manager add-on not listed');
+                    return false;
+                }
+                const { consoleActor, release } = await resolveConsoleActor(client, addon);
+                if (!consoleActor) {
+                    release();
+                    reportStep('no console actor for the manager background page');
+                    return false;
+                }
+                try {
+                    const result = await client.evaluate(consoleActor, OPEN_NEW_TAB_EXPRESSION);
+                    reportStep('tabs.create evaluated', result);
+                } finally{
+                    release();
+                }
+                return true;
+            } catch (error) {
+                reportStep('failed', error);
+                return false;
+            }
+        }
         function requestErrorToMessage(error) {
             if (error instanceof Error) return String(error);
             try {
@@ -4291,21 +4486,33 @@ var __webpack_modules__ = {
             const raw = parseInt(String(process.env.EXTENSION_RDP_REQUEST_TIMEOUT_MS || ''), 10);
             return Number.isFinite(raw) && raw > 0 ? raw : 30000;
         }
+        function surfaceTransportError(emitter, error) {
+            if (emitter.listenerCount('error') > 0) return void emitter.emit('error', error);
+            (0, messaging.Gg)(error instanceof Error ? error.message : String(error));
+        }
         class RdpTransport extends external_node_events_default() {
             async connect(port, host = '127.0.0.1') {
                 await new Promise((resolve, reject)=>{
+                    let connected = false;
                     try {
                         const c = external_node_net_default().createConnection({
                             host,
                             port
                         }, ()=>{
+                            connected = true;
                             if ((0, messaging._o)()) (0, messaging._w)(messages.EI(host, port));
                             resolve();
                         });
                         this.conn = c;
+                        this.lost = false;
                         c.on('data', this.onData.bind(this));
-                        c.on('error', reject);
-                        c.on('end', this.onEnd.bind(this));
+                        c.on('error', (err)=>{
+                            if (connected) return;
+                            this.conn = void 0;
+                            reject(err);
+                        });
+                        c.on('end', this.onConnectionLost.bind(this));
+                        c.on('close', this.onConnectionLost.bind(this));
                         c.on('timeout', this.onTimeout.bind(this));
                     } catch (err) {
                         reject(err);
@@ -4313,11 +4520,15 @@ var __webpack_modules__ = {
                 });
             }
             disconnect() {
-                if (!this.conn) return;
-                this.conn.removeAllListeners();
-                this.conn.end();
-                const err = new Error(messages.qN('firefox'));
-                this.rejectAll(err);
+                const c = this.conn;
+                if (!c) return;
+                this.conn = void 0;
+                this.lost = true;
+                this.incoming = Buffer.alloc(0);
+                c.removeAllListeners();
+                c.on('error', ()=>{});
+                c.end();
+                this.rejectAll(new Error(messages.qN('firefox')));
             }
             rejectAll(error) {
                 for (const entry of this.active.values()){
@@ -4389,8 +4600,8 @@ var __webpack_modules__ = {
                 const { remainingData, parsedMessage, error, fatal } = parseRdpFrame(this.incoming);
                 this.incoming = remainingData;
                 if (error) {
-                    this.emit('error', new Error(messages.l9('firefox', error)));
-                    if (fatal) this.disconnect();
+                    surfaceTransportError(this, new Error(messages.l9('firefox', error)));
+                    if (fatal) this.onConnectionLost();
                     return !fatal;
                 }
                 if (!parsedMessage) return false;
@@ -4398,10 +4609,11 @@ var __webpack_modules__ = {
                 return true;
             }
             handleMessage(message) {
-                if (!message.from) return void this.emit('error', new Error(messages.HH('firefox', message)));
-                const entry = this.active.get(message.from);
+                const from = message.from;
+                if (!from) return void surfaceTransportError(this, new Error(messages.HH('firefox', message)));
+                const entry = this.active.get(from);
                 if (entry) {
-                    this.active.delete(message.from);
+                    this.active.delete(from);
                     if (entry.timer) clearTimeout(entry.timer);
                     if (message.error) entry.deferred.reject(message);
                     else entry.deferred.resolve(message);
@@ -4410,7 +4622,17 @@ var __webpack_modules__ = {
                 }
                 this.emit('message', message);
             }
-            onEnd() {
+            onConnectionLost() {
+                if (this.lost) return;
+                this.lost = true;
+                const c = this.conn;
+                this.conn = void 0;
+                this.incoming = Buffer.alloc(0);
+                if (c) {
+                    c.removeAllListeners();
+                    c.on('error', ()=>{});
+                    c.destroy();
+                }
                 this.rejectAll(new Error(messages.qN('firefox')));
                 this.emit('end');
             }
@@ -4418,7 +4640,7 @@ var __webpack_modules__ = {
                 this.emit('timeout');
             }
             constructor(...args){
-                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", []);
+                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", []), _define_property(this, "lost", false);
             }
         }
         function messaging_client_define_property(obj, key, value) {
@@ -4431,15 +4653,20 @@ var __webpack_modules__ = {
             else obj[key] = value;
             return obj;
         }
+        const RECONNECT_MAX_ATTEMPTS = 5;
+        const RECONNECT_RETRY_DELAY_MS = 1000;
         class MessagingClient extends external_node_events_default() {
             async connect(port) {
-                this.lastPort = port;
                 this.disconnectedByUser = false;
+                await this.openTransport(port);
+            }
+            async openTransport(port) {
+                this.lastPort = port;
                 await this.transport.connect(port);
                 if (!this.forwardingSetup) {
                     this.forwardingSetup = true;
                     this.transport.on('message', (message)=>this.emit('message', message));
-                    this.transport.on('error', (error)=>this.emit('error', error));
+                    this.transport.on('error', (error)=>surfaceTransportError(this, error));
                     this.transport.on('end', ()=>{
                         this.emit('end');
                         this.attemptReconnect();
@@ -4454,20 +4681,21 @@ var __webpack_modules__ = {
             async attemptReconnect() {
                 if (this.disconnectedByUser || this.reconnecting || !this.lastPort) return;
                 this.reconnecting = true;
-                const maxAttempts = 5;
-                const retryDelay = 1000;
-                for(let i = 0; i < maxAttempts; i++){
-                    await new Promise((r)=>setTimeout(r, retryDelay));
-                    try {
-                        this.transport = new RdpTransport();
-                        this.forwardingSetup = false;
-                        await this.connect(this.lastPort);
-                        this.reconnecting = false;
-                        this.emit('reconnected');
-                        return;
-                    } catch  {}
+                try {
+                    for(let i = 0; i < RECONNECT_MAX_ATTEMPTS; i++){
+                        await new Promise((r)=>setTimeout(r, RECONNECT_RETRY_DELAY_MS));
+                        if (this.disconnectedByUser) return;
+                        try {
+                            this.transport = new RdpTransport();
+                            this.forwardingSetup = false;
+                            await this.openTransport(this.lastPort);
+                            this.emit('reconnected');
+                            return;
+                        } catch  {}
+                    }
+                } finally{
+                    this.reconnecting = false;
                 }
-                this.reconnecting = false;
             }
             async request(requestProps) {
                 if ('string' == typeof requestProps) return await this.transport.request({
@@ -4656,6 +4884,10 @@ var __webpack_modules__ = {
                 });
                 if (!bannerPrinted) throw new Error(messages.WV(this.options.browser, 'Failed to print runningInDevelopment banner; add-on may not be installed.'));
             }
+            async openNewTab() {
+                if (!this.client) return false;
+                return await openManagerNewTab(this.client);
+            }
             async enableUnifiedLogging(opts) {
                 try {
                     if (this.loggingAttached) return;
@@ -4709,6 +4941,9 @@ var __webpack_modules__ = {
             getAddonInstallRefusalReason() {
                 return this.remote.getAddonInstallRefusalReason();
             }
+            async openNewTab() {
+                return await this.remote.openNewTab();
+            }
             getExtensionId() {
                 return this.remote.getDerivedExtensionId();
             }
@@ -4771,6 +5006,14 @@ var __webpack_modules__ = {
             } catch (error) {
                 throw withRefusalReason(error);
             }
+            try {
+                const outPath = String(compilation?.options?.output?.path || '');
+                if (!plugin.startingUrl && !plugin.noOpen && (0, newtab_override.c)(outPath)) {
+                    const live = plugin.rdpController || controller;
+                    const opened = await live.openNewTab?.();
+                    if (!opened && (0, messaging._o)()) (0, messaging.mR)('[browser] Firefox: could not open the new-tab override page.');
+                }
+            } catch  {}
             return controller;
         }
         var external_node_child_process_ = __webpack_require__("node:child_process");
@@ -4853,7 +5096,7 @@ var __webpack_modules__ = {
                     debug: (...a)=>console?.debug?.(...a)
                 };
                 await this.launch(compilation, options);
-                if ('development' === options.mode && !this.host.extensionLoadRefused) this.ctx.logger?.info?.((0, ready_message.G)(options.mode, this.host.browser));
+                if (options?.mode === 'development' && !this.host.extensionLoadRefused) this.ctx.logger?.info?.((0, ready_message.G)(options.mode, this.host.browser));
                 this.ctx.didLaunch = true;
             }
             apply(compiler) {
@@ -4918,12 +5161,10 @@ var __webpack_modules__ = {
                     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;
-                }
+                const inTestRunner = Boolean(process.env.VITEST || process.env.VITEST_WORKER_ID);
+                const dryRun = Boolean(this.host.dryRun);
+                if (inTestRunner && !dryRun) return void logFirefoxDryRun('firefox-mock-binary', []);
+                if (inTestRunner && dryRun && !this.host.geckoBinary) return void await this.printDryRunPlan(compilation, options, 'firefox-mock-binary');
                 let browserBinaryLocation = resolveManagedBinary();
                 let skipDetection = Boolean(browserBinaryLocation);
                 const engineBased = 'gecko-based' === this.host.browser || 'firefox-based' === this.host.browser;
@@ -5017,25 +5258,25 @@ var __webpack_modules__ = {
                     rdpPort: debugPort
                 });
                 const effectiveInstanceId = this.host.instanceId;
-                let firefoxCfg;
-                firefoxCfg = await browserConfig(compilation, {
+                const launchConfig = await resolveFirefoxLaunchConfig(compilation, {
                     ...options,
                     profile: this.host.profile,
                     preferences: this.host.preferences || {},
                     instanceId: effectiveInstanceId
+                }, {
+                    provision: !dryRun
+                });
+                const { profilePath, binaryArgs: firefoxArgs } = launchConfig;
+                const plan = FirefoxBinaryDetector.launchPlan({
+                    binaryPath,
+                    profilePath,
+                    debugPort,
+                    binaryArgs: firefoxArgs,
+                    headless: isFirefoxHeadlessRequested()
                 });
-                if (this.host.dryRun) return void logFirefoxDryRun(binaryPath, firefoxCfg);
-                const firefoxArgs = [];
-                const binaryArgsMatch = firefoxCfg.match(/--binary-args="([^"]*)"/);
-                if (binaryArgsMatch) {
-                    const rawArgs = String(binaryArgsMatch[1] || '').trim();
-                    if (rawArgs) firefoxArgs.push(...rawArgs.split(' ').filter((arg)=>arg.trim().length > 0));
-                    if ((0, messaging._o)()) this.ctx.logger?.info?.(messages.iv(binaryArgsMatch[1]));
-                } else if ((0, messaging._o)()) this.ctx.logger?.info?.(messages.dN());
-                const profileMatch = firefoxCfg.match(/--profile="([^"]*)"/);
-                if (profileMatch) {
-                    const profilePath = profileMatch[1];
-                    const { binary, args } = FirefoxBinaryDetector.generateFirefoxArgs(binaryPath, profilePath, debugPort, firefoxArgs, isFirefoxHeadlessRequested());
+                if (dryRun) return void logFirefoxDryRun(plan.binary, plan.args);
+                if (profilePath) {
+                    const { binary, args } = plan;
                     this.host.launchProfilePath = profilePath;
                     this.child = await this.spawnFirefoxChild(binary, args, wslFallbackBinary);
                     (0, ready_stamp.M)(this.extensionOutputPath, {
@@ -5075,23 +5316,7 @@ var __webpack_modules__ = {
                     } catch  {}
                 } else {
                     if ((0, messaging._o)()) this.ctx.logger?.warn?.('[browser] Firefox profile not set; skipping RDP add-on install.');
-                    const args = [
-                        ...isFirefoxHeadlessRequested() ? [
-                            '-headless'
-                        ] : [],
-                        ...debugPort > 0 ? [
-                            '-start-debugger-server',
-                            String(debugPort)
-                        ] : [],
-                        ...'win32' === process.platform ? [
-                            '-wait-for-browser'
-                        ] : [],
-                        ...isFirefoxHeadlessRequested() ? [] : [
-                            '--foreground'
-                        ],
-                        ...firefoxArgs
-                    ];
-                    this.child = await this.spawnFirefoxChild(binaryPath, args, wslFallbackBinary);
+                    this.child = await this.spawnFirefoxChild(plan.binary, plan.args, wslFallbackBinary);
                     (0, ready_stamp.M)(this.extensionOutputPath, {
                         browserPid: this.child?.pid,
                         extensionId: this.extensionOutputPath ? (0, banner.MT)(this.extensionOutputPath) : void 0
@@ -5101,6 +5326,24 @@ var __webpack_modules__ = {
                     this.scheduleWatchTimeout();
                 }
             }
+            async printDryRunPlan(compilation, options, binaryPath) {
+                const launchConfig = await resolveFirefoxLaunchConfig(compilation, {
+                    ...options,
+                    profile: this.host.profile,
+                    preferences: this.host.preferences || {},
+                    instanceId: this.host.instanceId
+                }, {
+                    provision: false
+                });
+                const plan = FirefoxBinaryDetector.launchPlan({
+                    binaryPath,
+                    profilePath: launchConfig.profilePath,
+                    debugPort: (0, shared_utils.jl)(this.host.port, this.host.instanceId),
+                    binaryArgs: launchConfig.binaryArgs,
+                    headless: isFirefoxHeadlessRequested()
+                });
+                logFirefoxDryRun(plan.binary, plan.args);
+            }
             resolveSpawnStdio() {
                 if ('win32' !== process.platform) return [
                     'pipe',
@@ -5314,6 +5557,7 @@ var __webpack_modules__ = {
                 preferences: pluginOptions.preferences,
                 browserFlags: pluginOptions.browserFlags,
                 startingUrl: pluginOptions.startingUrl,
+                noOpen: pluginOptions.noOpen,
                 geckoBinary: pluginOptions.geckoBinary,
                 instanceId: pluginOptions.instanceId,
                 port: pluginOptions.port,