@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/browser-Dx3_S2cG.mjs

@@ -0,0 +1,4369 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { C as CAPTCHA_MAX_RETRIES, D as CAPTCHA_RESULT_TIMEOUT_MS, E as CAPTCHA_POLL_INTERVAL_MS, O as CAPTCHA_SOLVER_BASE_URL, S as CAPTCHA_DEFAULT_TIMEOUT_MS, T as CAPTCHA_MIN_TIMEOUT_MS, k as CAPTCHA_SUBMIT_TIMEOUT_MS, w as CAPTCHA_MAX_TIMEOUT_MS, wn as SCRIPTS_MAX_CAP, x as CAPTCHA_DEFAULT_RETRIES } from "./constants-CDZLOoVv.mjs";
+import { t as DetailedDataManager } from "./DetailedDataManager-HT49OrvF.mjs";
+import { c as getConfig, l as projectRoot, o as resolveOutputDirectory, s as resolveScreenshotOutputPath } from "./outputPaths-um7lCRY3.mjs";
+import { c as CamoufoxBrowserManager, n as StealthScripts, s as AICaptchaDetector } from "./modules-tZozf0LQ.mjs";
+import { t as PrerequisiteError } from "./PrerequisiteError-TuyZIs6n.mjs";
+import { n as isBetterSqlite3RelatedError, t as formatBetterSqlite3Error } from "./betterSqlite3-DLSBZodi.mjs";
+import { t as cdpLimit } from "./concurrency-Drev_Vz9.mjs";
+import { a as argString, i as argObject, n as argEnum, o as argStringArray, r as argNumber, s as argStringRequired, t as argBool } from "./parse-args-B4cY5Vx5.mjs";
+import { n as capabilityReport } from "./capabilities-CcHlvWgK.mjs";
+import "./definitions-BRaefg3u.mjs";
+import { t as R } from "./ResponseBuilder-CJXWmWNw.mjs";
+import { join } from "path";
+import { randomUUID } from "node:crypto";
+import { readFile, writeFile } from "fs/promises";
+//#region src/server/domains/browser/handlers/browser-control.ts
+const projectEnvPath = join(projectRoot, ".env");
+const CHROME_CHANNELS = new Set([
+	"stable",
+	"beta",
+	"dev",
+	"canary"
+]);
+var BrowserControlHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	markMonitoringContextChanged(context) {
+		try {
+			this.deps.consoleMonitor.markContextChanged();
+		} catch (error) {
+			logger.warn(`[${context}] Failed to mark monitoring context as stale: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	async syncTabRegistryWithCollectorPages(context) {
+		try {
+			const resolvedPages = await this.deps.collector.listResolvedPages();
+			this.deps.getTabRegistry().reconcilePages(resolvedPages.map((entry) => entry.page), resolvedPages.map(({ page: _page, ...meta }) => meta));
+		} catch (error) {
+			logger.warn(`[${context}] Failed to sync attached tabs into TabRegistry: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	parseHeadlessArg(value) {
+		if (typeof value === "boolean") return value;
+		if (typeof value === "number") {
+			if (value === 1) return true;
+			if (value === 0) return false;
+			return;
+		}
+		if (typeof value === "string") {
+			const normalized = value.trim().toLowerCase();
+			if ([
+				"true",
+				"1",
+				"yes",
+				"on"
+			].includes(normalized)) return true;
+			if ([
+				"false",
+				"0",
+				"no",
+				"off"
+			].includes(normalized)) return false;
+		}
+	}
+	parseChromeConnectRequest(args) {
+		const channelValue = argString(args, "channel");
+		if (channelValue && !CHROME_CHANNELS.has(channelValue)) throw new Error(`Invalid channel "${channelValue}". Expected one of: stable, beta, dev, canary.`);
+		return {
+			browserURL: argString(args, "browserURL"),
+			wsEndpoint: argString(args, "wsEndpoint"),
+			autoConnect: argBool(args, "autoConnect"),
+			userDataDir: argString(args, "userDataDir"),
+			channel: channelValue
+		};
+	}
+	parseChromeLaunchRequest(args) {
+		return {
+			headless: this.parseHeadlessArg(args.headless),
+			args: argStringArray(args, "args"),
+			enableV8NativesSyntax: argBool(args, "enableV8NativesSyntax")
+		};
+	}
+	hasChromeConnectRequest(request) {
+		return Boolean(request.browserURL || request.wsEndpoint || request.autoConnect || request.userDataDir || request.channel);
+	}
+	describeChromeConnectRequest(request) {
+		if (request.wsEndpoint) return request.wsEndpoint;
+		if (request.browserURL) return request.browserURL;
+		if (request.userDataDir) return `autoConnect:${request.userDataDir}`;
+		return `autoConnect:${request.channel ?? "stable"}`;
+	}
+	isAutoConnectRequest(request) {
+		return Boolean(request.autoConnect || request.userDataDir || request.channel);
+	}
+	getAutoConnectApprovalHint(request) {
+		if (!this.isAutoConnectRequest(request)) return null;
+		return "Chrome 144+ autoConnect may prompt for manual approval. Switch to Chrome and click Allow for this client if prompted.";
+	}
+	shouldAttemptLinuxHeadfulFallback(headlessArg, error) {
+		const requestedHeadful = headlessArg === false || headlessArg === void 0 && process.env.PUPPETEER_HEADLESS === "false";
+		const linuxRuntime = process.platform === "linux" || process.env.JSHOOK_FORCE_LINUX_FALLBACK === "true";
+		if (!requestedHeadful || !linuxRuntime) return false;
+		const message = error instanceof Error ? error.message : String(error);
+		return /Missing X server|cannot open display|Failed to launch the browser process|ozone|No protocol specified|X11|Wayland|DevToolsActivePort/i.test(message);
+	}
+	async persistHeadlessEnv(value) {
+		try {
+			let envContent = "";
+			try {
+				envContent = await readFile(projectEnvPath, "utf-8");
+			} catch (error) {
+				if (error?.code !== "ENOENT") throw error;
+			}
+			const nextLine = `PUPPETEER_HEADLESS=${value}`;
+			await writeFile(projectEnvPath, /^PUPPETEER_HEADLESS=.*$/m.test(envContent) ? envContent.replace(/^PUPPETEER_HEADLESS=.*$/m, nextLine) : `${envContent.trimEnd()}\n${nextLine}\n`, "utf-8");
+		} catch (error) {
+			logger.warn(`Failed to persist PUPPETEER_HEADLESS=${value} to .env: ${String(error)}`);
+		}
+	}
+	async handleBrowserLaunch(args) {
+		try {
+			if (argString(args, "driver", "chrome") === "camoufox") {
+				if (argString(args, "mode", "launch") === "connect") {
+					const wsEndpoint = argString(args, "wsEndpoint");
+					if (!wsEndpoint) return R.fail("wsEndpoint is required for connect mode. Use camoufox_server({ action: \"launch\" }) first to get a wsEndpoint.").json();
+					return R.ok().merge({
+						driver: "camoufox",
+						mode: "connect",
+						wsEndpoint,
+						message: "Connected to Camoufox server. Use page_navigate to begin."
+					}).json();
+				}
+				return R.ok().merge({
+					driver: "camoufox",
+					mode: "launch",
+					message: "Camoufox (Firefox) browser launched",
+					note: "Use page_navigate to begin. CDP debugger is limited in Firefox; network_enable and console_monitor({ action: \"enable\" }) use Playwright events and are fully supported."
+				}).json();
+			}
+			if (argString(args, "mode", "launch") === "connect") {
+				const connectRequest = this.parseChromeConnectRequest(args);
+				if (!this.hasChromeConnectRequest(connectRequest)) return R.fail("browserURL, wsEndpoint, autoConnect, userDataDir, or channel is required for chrome connect mode.").json();
+				await this.deps.collector.connect(connectRequest);
+				const status = await this.deps.collector.getStatus();
+				return R.ok().merge({
+					driver: "chrome",
+					mode: "connect",
+					endpoint: this.describeChromeConnectRequest(connectRequest),
+					autoConnect: this.isAutoConnectRequest(connectRequest),
+					channel: connectRequest.channel ?? null,
+					userDataDir: connectRequest.userDataDir ?? null,
+					manualApprovalMayBeRequired: this.isAutoConnectRequest(connectRequest),
+					approvalHint: this.getAutoConnectApprovalHint(connectRequest),
+					message: "Connected to existing Chrome browser successfully",
+					status
+				}).json();
+			}
+			const launchRequest = this.parseChromeLaunchRequest(args);
+			try {
+				const launch = await this.deps.collector.launch(launchRequest);
+				if (launch.action === "relaunched") this.markMonitoringContextChanged("browser_launch_relaunch");
+				const status = await this.deps.collector.getStatus();
+				return R.ok().merge({
+					driver: "chrome",
+					message: launch.action === "relaunched" ? "Browser relaunched successfully" : "Browser launched successfully",
+					launchAction: launch.action,
+					relaunchReason: launch.reason ?? null,
+					v8NativeSyntaxEnabled: launch.launchOptions.v8NativeSyntaxEnabled,
+					launchArgs: launch.launchOptions.args,
+					status
+				}).json();
+			} catch (error) {
+				if (!this.shouldAttemptLinuxHeadfulFallback(launchRequest.headless, error)) throw error;
+				const reason = error instanceof Error ? error.message : String(error);
+				logger.warn(`Headful launch failed on Linux, fallback to headless=true: ${reason}`);
+				process.env.PUPPETEER_HEADLESS = "true";
+				await this.persistHeadlessEnv("true");
+				const launch = await this.deps.collector.launch({
+					...launchRequest,
+					headless: true
+				});
+				const fallbackStatus = await this.deps.collector.getStatus();
+				return R.ok().merge({
+					driver: "chrome",
+					message: "Browser launched with Linux fallback (headless=true)",
+					launchAction: launch.action,
+					relaunchReason: launch.reason ?? null,
+					v8NativeSyntaxEnabled: launch.launchOptions.v8NativeSyntaxEnabled,
+					launchArgs: launch.launchOptions.args,
+					status: fallbackStatus,
+					fallback: {
+						applied: true,
+						reason: "Headful browser is unavailable in current Linux runtime; switched to headless and updated .env",
+						newEnv: "PUPPETEER_HEADLESS=true"
+					}
+				}).json();
+			}
+		} catch (error) {
+			return R.fail(error).json();
+		}
+	}
+	async handleBrowserClose(_args) {
+		try {
+			await this.deps.collector.close();
+			return R.ok().set("message", "Browser closed successfully").json();
+		} catch (e) {
+			return R.fail(e).json();
+		}
+	}
+	async handleBrowserStatus(_args) {
+		try {
+			const status = await this.deps.collector.getStatus();
+			return R.ok().merge({
+				driver: "chrome",
+				...status
+			}).json();
+		} catch (e) {
+			return R.fail(e).json();
+		}
+	}
+	async handleBrowserListTabs(args) {
+		const connectRequest = this.parseChromeConnectRequest(args);
+		try {
+			if (this.hasChromeConnectRequest(connectRequest)) await this.deps.collector.connect(connectRequest);
+			const pages = await this.deps.collector.listPages();
+			const registry = this.deps.getTabRegistry();
+			await this.syncTabRegistryWithCollectorPages("browser_list_tabs");
+			const enrichedPages = pages.map((page) => {
+				const tab = registry.getTabByIndex(page.index);
+				return {
+					...page,
+					pageId: tab?.pageId ?? null,
+					aliases: tab?.aliases ?? []
+				};
+			});
+			const currentInfo = registry.getContextMeta();
+			return R.ok().merge({
+				count: pages.length,
+				pages: enrichedPages,
+				currentPageId: currentInfo.pageId,
+				currentIndex: currentInfo.tabIndex,
+				autoConnect: this.isAutoConnectRequest(connectRequest),
+				manualApprovalMayBeRequired: this.isAutoConnectRequest(connectRequest),
+				approvalHint: this.getAutoConnectApprovalHint(connectRequest),
+				hint: "Use browser_select_tab(index=N) to switch to a specific tab"
+			}).json();
+		} catch (error) {
+			return R.fail(error).set("hint", "Make sure browser is attached via browser_attach first, or provide browserURL/autoConnect. Chrome 144+ autoConnect may require manual approval in the Chrome window.").set("approvalHint", this.getAutoConnectApprovalHint(connectRequest)).json();
+		}
+	}
+	async handleBrowserSelectTab(args) {
+		try {
+			const index = argNumber(args, "index");
+			const urlPattern = argString(args, "urlPattern");
+			const titlePattern = argString(args, "titlePattern");
+			const registry = this.deps.getTabRegistry();
+			if (index !== void 0) {
+				const clearedTarget = await this.deps.clearAttachedTargetContext("browser_select_tab");
+				await this.deps.collector.selectPage(index);
+				const pages = await this.deps.collector.listPages();
+				await this.syncTabRegistryWithCollectorPages("browser_select_tab");
+				const selected = pages[index];
+				const tab = registry.setCurrentByIndex(index);
+				if (tab?.pageId || clearedTarget.detached) this.markMonitoringContextChanged("browser_select_tab");
+				return R.ok().merge({
+					selectedIndex: index,
+					selectedPageId: tab?.pageId ?? null,
+					url: selected?.url,
+					title: selected?.title,
+					contextSwitched: true,
+					detachedCdpTarget: clearedTarget.detached,
+					detachedCdpTargetId: clearedTarget.targetId,
+					monitoringBindingDeferred: Boolean(tab?.pageId),
+					networkMonitoringEnabled: false,
+					consoleMonitoringEnabled: false
+				}).json();
+			}
+			const pages = await this.deps.collector.listPages();
+			let matchIndex = -1;
+			for (const page of pages) {
+				if (urlPattern && page.url.includes(urlPattern)) {
+					matchIndex = page.index;
+					break;
+				}
+				if (titlePattern && page.title.includes(titlePattern)) {
+					matchIndex = page.index;
+					break;
+				}
+			}
+			if (matchIndex === -1) return R.fail("No matching tab found").set("availablePages", pages).json();
+			const clearedTarget = await this.deps.clearAttachedTargetContext("browser_select_tab");
+			await this.deps.collector.selectPage(matchIndex);
+			await this.syncTabRegistryWithCollectorPages("browser_select_tab");
+			const selected = pages[matchIndex];
+			const tab = registry.setCurrentByIndex(matchIndex);
+			if (tab?.pageId || clearedTarget.detached) this.markMonitoringContextChanged("browser_select_tab");
+			return R.ok().merge({
+				selectedIndex: matchIndex,
+				selectedPageId: tab?.pageId ?? null,
+				url: selected?.url,
+				title: selected?.title,
+				contextSwitched: true,
+				detachedCdpTarget: clearedTarget.detached,
+				detachedCdpTargetId: clearedTarget.targetId,
+				monitoringBindingDeferred: Boolean(tab?.pageId),
+				networkMonitoringEnabled: false,
+				consoleMonitoringEnabled: false
+			}).json();
+		} catch (error) {
+			return R.fail(error).json();
+		}
+	}
+	async handleBrowserAttach(args) {
+		let connectRequest = null;
+		try {
+			connectRequest = this.parseChromeConnectRequest(args);
+			if (!this.hasChromeConnectRequest(connectRequest)) return R.fail("browserURL, wsEndpoint, autoConnect, userDataDir, or channel is required").json();
+			const clearedTarget = await this.deps.clearAttachedTargetContext("browser_attach");
+			await this.deps.collector.connect(connectRequest);
+			const rawPageIndex = args.pageIndex;
+			const pageIndex = typeof rawPageIndex === "number" ? rawPageIndex : typeof rawPageIndex === "string" && rawPageIndex.trim() !== "" ? Number(rawPageIndex) : 0;
+			const selectedIndex = Number.isFinite(pageIndex) ? pageIndex : 0;
+			const pages = await this.deps.collector.listPages();
+			if (pages.length > 0 && selectedIndex < pages.length) await this.deps.collector.selectPage(selectedIndex);
+			else if (pages.length > 0) {
+				await this.deps.collector.selectPage(0);
+				logger.warn(`[browser_attach] pageIndex ${selectedIndex} out of range (0-${pages.length - 1}), fell back to 0`);
+			}
+			const registry = this.deps.getTabRegistry();
+			await this.syncTabRegistryWithCollectorPages("browser_attach");
+			const actualIndex = pages.length > 0 ? Math.min(selectedIndex, pages.length - 1) : 0;
+			const tab = pages.length > 0 ? registry.setCurrentByIndex(actualIndex) : null;
+			const selected = pages[actualIndex];
+			const pageHandleReady = Boolean(tab?.pageId);
+			if (pageHandleReady) this.markMonitoringContextChanged("browser_attach");
+			const status = await this.deps.collector.getStatus();
+			return R.ok().merge({
+				message: "Attached to existing browser successfully",
+				endpoint: this.describeChromeConnectRequest(connectRequest),
+				autoConnect: this.isAutoConnectRequest(connectRequest),
+				channel: connectRequest.channel ?? null,
+				userDataDir: connectRequest.userDataDir ?? null,
+				manualApprovalMayBeRequired: this.isAutoConnectRequest(connectRequest),
+				approvalHint: this.getAutoConnectApprovalHint(connectRequest),
+				selectedIndex: actualIndex,
+				selectedPageId: tab?.pageId ?? null,
+				currentUrl: selected?.url ?? null,
+				currentTitle: selected?.title ?? null,
+				totalPages: pages.length,
+				contextSwitched: pages.length > 0,
+				detachedCdpTarget: clearedTarget.detached,
+				detachedCdpTargetId: clearedTarget.targetId,
+				monitoringBindingDeferred: pageHandleReady,
+				networkMonitoringEnabled: false,
+				consoleMonitoringEnabled: false,
+				takeoverReady: pageHandleReady,
+				note: pageHandleReady ? "Monitoring will auto-rebind on the next console/network operation for the selected tab." : "Connected to existing Chrome, but the selected tab does not currently expose a stable Puppeteer Page handle. Tab discovery still works; try selecting a different tab or navigate the tab and retry.",
+				status
+			}).json();
+		} catch (error) {
+			return R.fail(error).set("approvalHint", this.getAutoConnectApprovalHint(connectRequest ?? {})).json();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/camoufox-browser.ts
+function extractCamoufoxServerConfig(args) {
+	const addons = argStringArray(args, "addons");
+	const excludeAddons = argStringArray(args, "excludeAddons");
+	const fonts = argStringArray(args, "fonts");
+	return {
+		headless: argBool(args, "headless", true),
+		os: argString(args, "os", "windows"),
+		geoip: argBool(args, "geoip", false),
+		humanize: argBool(args, "humanize", false),
+		proxy: argString(args, "proxy") || void 0,
+		blockImages: argBool(args, "blockImages", false),
+		blockWebrtc: argBool(args, "blockWebrtc", false),
+		blockWebgl: argBool(args, "blockWebgl", false),
+		locale: argString(args, "locale") || void 0,
+		addons: addons.length > 0 ? addons : void 0,
+		fonts: fonts.length > 0 ? fonts : void 0,
+		excludeAddons: excludeAddons.length > 0 ? excludeAddons : void 0,
+		customFontsOnly: argBool(args, "customFontsOnly", false),
+		screen: args.screen,
+		window: args.window,
+		fingerprint: argObject(args, "fingerprint"),
+		webglConfig: argObject(args, "webglConfig"),
+		firefoxUserPrefs: argObject(args, "firefoxUserPrefs"),
+		mainWorldEval: argBool(args, "mainWorldEval", false),
+		enableCache: argBool(args, "enableCache", false)
+	};
+}
+/**
+* Check if camoufox-js is available and has all required dependencies.
+* Returns error message if not available, null if available.
+*/
+async function checkCamoufoxDependencies() {
+	try {
+		await import("camoufox-js");
+		return null;
+	} catch (error) {
+		const errorMsg = error instanceof Error ? error.message : String(error);
+		if (isBetterSqlite3RelatedError(error)) return `Camoufox requires the same native SQLite backend used by trace tooling. ${formatBetterSqlite3Error(error)}`;
+		if (errorMsg.includes("Cannot find package 'camoufox-js'")) return "camoufox-js package is not installed. Run: pnpm add camoufox-js && npx camoufox-js fetch";
+		return `Camoufox dependencies check failed: ${errorMsg}`;
+	}
+}
+var CamoufoxBrowserHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleCamoufoxServerLaunch(args) {
+		try {
+			const depError = await checkCamoufoxDependencies();
+			if (depError) {
+				logger.warn(`Camoufox dependencies not available: ${depError}`);
+				return R.fail(depError).set("hint", "Camoufox is optional. Use browser_launch with Chrome driver instead, or install dependencies.").json();
+			}
+			const port = argNumber(args, "port");
+			const ws_path = argString(args, "ws_path");
+			const config = extractCamoufoxServerConfig(args);
+			let camoufoxManager = this.deps.getCamoufoxManager();
+			if (!camoufoxManager) {
+				camoufoxManager = new CamoufoxBrowserManager(config);
+				this.deps.setCamoufoxManager(camoufoxManager);
+			}
+			const wsEndpoint = await camoufoxManager.launchAsServer(port, ws_path);
+			return R.ok().merge({
+				wsEndpoint,
+				config: {
+					os: config.os,
+					headless: config.headless,
+					geoip: config.geoip,
+					locale: config.locale,
+					blockWebgl: config.blockWebgl
+				},
+				message: "Camoufox server launched. Connect with: browser_launch(driver=\"camoufox\", mode=\"connect\", wsEndpoint=<wsEndpoint>)"
+			}).json();
+		} catch (error) {
+			return R.fail(error).set("hint", "Try running: npx camoufox-js fetch to download browser binaries").json();
+		}
+	}
+	async handleCamoufoxServerClose(_args) {
+		try {
+			const camoufoxManager = this.deps.getCamoufoxManager();
+			if (!camoufoxManager) return R.fail("No camoufox server is running.").json();
+			await camoufoxManager.closeBrowserServer();
+			return R.ok().set("message", "Camoufox server closed.").json();
+		} catch (e) {
+			return R.fail(e).json();
+		}
+	}
+	async handleCamoufoxServerStatus(_args) {
+		try {
+			const wsEndpoint = this.deps.getCamoufoxManager()?.getBrowserServerEndpoint() ?? null;
+			return R.ok().merge({
+				running: wsEndpoint !== null,
+				wsEndpoint
+			}).json();
+		} catch (e) {
+			return R.fail(e).json();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/page-navigation.ts
+var PageNavigationHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handlePageNavigate(args) {
+		try {
+			const url = argString(args, "url", "");
+			const rawWaitUntil = argString(args, "waitUntil", "networkidle");
+			const timeout = argNumber(args, "timeout");
+			const enableNetworkMonitoring = argBool(args, "enableNetworkMonitoring");
+			if (this.deps.getActiveDriver() === "camoufox") {
+				const playwrightWaitUntil = rawWaitUntil === "networkidle2" ? "networkidle" : rawWaitUntil;
+				const page = await this.deps.getCamoufoxPage();
+				await page.goto(url, {
+					waitUntil: playwrightWaitUntil,
+					timeout
+				});
+				this.deps.consoleMonitor.setPlaywrightPage(page);
+				if (enableNetworkMonitoring) await this.deps.consoleMonitor.enable({
+					enableNetwork: true,
+					enableExceptions: true
+				});
+				const navigatedUrl = page.url();
+				this.deps.eventBus?.emit("browser:navigated", {
+					url: navigatedUrl,
+					timestamp: (/* @__PURE__ */ new Date()).toISOString()
+				});
+				return R.ok().build({
+					driver: "camoufox",
+					url: navigatedUrl,
+					title: await page.title(),
+					network_monitoring: { enabled: this.deps.consoleMonitor.isNetworkEnabled() }
+				});
+			}
+			if (enableNetworkMonitoring) await this.deps.consoleMonitor.enable({
+				enableNetwork: true,
+				enableExceptions: true
+			});
+			const waitUntil = {
+				networkidle: "networkidle2",
+				commit: "load"
+			}[rawWaitUntil] || rawWaitUntil;
+			await this.deps.pageController.navigate(url, {
+				waitUntil,
+				timeout
+			});
+			const currentUrl = await this.deps.pageController.getURL();
+			const title = await this.deps.pageController.getTitle();
+			this.deps.eventBus?.emit("browser:navigated", {
+				url: currentUrl,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return R.ok().build({
+				url: currentUrl,
+				title,
+				network_monitoring: { enabled: this.deps.consoleMonitor.isNetworkEnabled() }
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageReload(_args) {
+		try {
+			if (this.deps.getActiveDriver() === "camoufox") {
+				await (await this.deps.getCamoufoxPage()).reload();
+				return R.ok().build({
+					message: "Page reloaded",
+					driver: "camoufox"
+				});
+			}
+			await this.deps.pageController.reload();
+			return R.ok().build({ message: "Page reloaded" });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageBack(args) {
+		try {
+			const timeout = argNumber(args, "timeout", 1e4);
+			if (this.deps.getActiveDriver() === "camoufox") {
+				const page = await this.deps.getCamoufoxPage();
+				await page.goBack();
+				return R.ok().build({
+					url: page.url(),
+					driver: "camoufox"
+				});
+			}
+			await this.deps.pageController.goBack(timeout);
+			const url = await this.deps.pageController.getURL();
+			return R.ok().build({ url });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageForward(args) {
+		try {
+			const timeout = argNumber(args, "timeout", 1e4);
+			if (this.deps.getActiveDriver() === "camoufox") {
+				const page = await this.deps.getCamoufoxPage();
+				await page.goForward();
+				return R.ok().build({
+					url: page.url(),
+					driver: "camoufox"
+				});
+			}
+			await this.deps.pageController.goForward(timeout);
+			const url = await this.deps.pageController.getURL();
+			return R.ok().build({ url });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/page-interaction.ts
+var PageInteractionHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	toErrorMessage(error) {
+		if (error instanceof Error) return error.message;
+		return typeof error === "string" ? error : "";
+	}
+	parseNumberArg(value, options = {}) {
+		let parsed;
+		if (typeof value === "number" && Number.isFinite(value)) parsed = value;
+		else if (typeof value === "string") {
+			const trimmed = value.trim();
+			if (trimmed.length > 0) {
+				const n = Number(trimmed);
+				if (Number.isFinite(n)) parsed = n;
+			}
+		}
+		if (parsed === void 0) parsed = options.defaultValue;
+		if (parsed === void 0) return;
+		if (options.integer) parsed = Math.trunc(parsed);
+		if (typeof options.min === "number") parsed = Math.max(options.min, parsed);
+		if (typeof options.max === "number") parsed = Math.min(options.max, parsed);
+		return parsed;
+	}
+	parseMouseButton(value) {
+		if (typeof value === "string") {
+			const normalized = value.trim().toLowerCase();
+			if (normalized === "left" || normalized === "right" || normalized === "middle") return normalized;
+		}
+		return "left";
+	}
+	async getCamoufoxInteractionContext(frameOptions) {
+		const page = await this.deps.getCamoufoxPage();
+		if (!frameOptions?.frameUrl && !frameOptions?.frameSelector) return page;
+		return await this.deps.pageController.resolveFrame(page, frameOptions);
+	}
+	async handlePageClick(args) {
+		try {
+			const selector = argString(args, "selector", "");
+			const button = this.parseMouseButton(args.button);
+			const clickCount = this.parseNumberArg(args.clickCount, {
+				defaultValue: 1,
+				min: 1,
+				max: 10,
+				integer: true
+			});
+			const delay = this.parseNumberArg(args.delay, {
+				min: 0,
+				max: 6e4,
+				integer: true
+			});
+			const timeout = this.parseNumberArg(args.timeout, {
+				defaultValue: 1e4,
+				min: 1e3,
+				max: 12e4,
+				integer: true
+			});
+			const frameUrl = argString(args, "frameUrl");
+			const frameSelector = argString(args, "frameSelector");
+			const frameOptions = frameUrl || frameSelector ? {
+				frameUrl: frameUrl || void 0,
+				frameSelector: frameSelector || void 0
+			} : void 0;
+			if (!selector || typeof selector !== "string" || selector.trim().length === 0) return R.fail("selector parameter is required").build();
+			if (this.deps.getActiveDriver() === "camoufox") {
+				await (await this.getCamoufoxInteractionContext(frameOptions)).click(selector, {
+					button,
+					clickCount,
+					delay
+				});
+				return R.ok().build({
+					driver: "camoufox",
+					message: `Clicked: ${selector}`,
+					...frameOptions ? { frame: frameOptions } : {}
+				});
+			}
+			try {
+				if (frameOptions) await this.deps.pageController.click(selector, {
+					button,
+					clickCount,
+					delay,
+					timeout
+				}, frameOptions);
+				else await this.deps.pageController.click(selector, {
+					button,
+					clickCount,
+					delay,
+					timeout
+				});
+			} catch (error) {
+				const msg = this.toErrorMessage(error);
+				if (msg.includes("detached") || msg.includes("timed out") || msg.includes("Execution context was destroyed") || msg.includes("callFunctionOn") || msg.includes("Target closed")) return R.ok().build({
+					message: `Clicked ${selector} - navigation triggered`,
+					navigated: true,
+					...frameOptions ? { frame: frameOptions } : {}
+				});
+				throw error;
+			}
+			return R.ok().build({
+				message: `Clicked: ${selector}`,
+				...frameOptions ? { frame: frameOptions } : {}
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageType(args) {
+		try {
+			const selector = argString(args, "selector", "");
+			const text = argString(args, "text", "");
+			const delay = argNumber(args, "delay");
+			const frameUrl = argString(args, "frameUrl");
+			const frameSelector = argString(args, "frameSelector");
+			const frameOptions = frameUrl || frameSelector ? {
+				frameUrl: frameUrl || void 0,
+				frameSelector: frameSelector || void 0
+			} : void 0;
+			if (this.deps.getActiveDriver() === "camoufox") {
+				await (await this.getCamoufoxInteractionContext(frameOptions)).fill(selector, text);
+				return R.ok().build({
+					driver: "camoufox",
+					message: `Typed into ${selector}`,
+					...frameOptions ? { frame: frameOptions } : {}
+				});
+			}
+			if (frameOptions) await this.deps.pageController.type(selector, text, { delay }, frameOptions);
+			else await this.deps.pageController.type(selector, text, { delay });
+			return R.ok().build({
+				message: `Typed into ${selector}`,
+				...frameOptions ? { frame: frameOptions } : {}
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageSelect(args) {
+		try {
+			const selector = argString(args, "selector", "");
+			const values = argStringArray(args, "values");
+			const frameUrl = argString(args, "frameUrl");
+			const frameSelector = argString(args, "frameSelector");
+			const frameOptions = frameUrl || frameSelector ? {
+				frameUrl: frameUrl || void 0,
+				frameSelector: frameSelector || void 0
+			} : void 0;
+			if (this.deps.getActiveDriver() === "camoufox") {
+				await (await this.getCamoufoxInteractionContext(frameOptions)).selectOption(selector, values);
+				return R.ok().build({
+					driver: "camoufox",
+					message: `Selected in ${selector}: ${values.join(", ")}`,
+					...frameOptions ? { frame: frameOptions } : {}
+				});
+			}
+			if (frameOptions) await this.deps.pageController.select(selector, values, frameOptions);
+			else await this.deps.pageController.select(selector, values);
+			return R.ok().build({
+				message: `Selected in ${selector}: ${values.join(", ")}`,
+				...frameOptions ? { frame: frameOptions } : {}
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageHover(args) {
+		try {
+			const selector = argString(args, "selector", "");
+			const frameUrl = argString(args, "frameUrl");
+			const frameSelector = argString(args, "frameSelector");
+			const frameOptions = frameUrl || frameSelector ? {
+				frameUrl: frameUrl || void 0,
+				frameSelector: frameSelector || void 0
+			} : void 0;
+			if (this.deps.getActiveDriver() === "camoufox") {
+				await (await this.getCamoufoxInteractionContext(frameOptions)).hover(selector);
+				return R.ok().build({
+					driver: "camoufox",
+					message: `Hovered: ${selector}`,
+					...frameOptions ? { frame: frameOptions } : {}
+				});
+			}
+			if (frameOptions) await this.deps.pageController.hover(selector, frameOptions);
+			else await this.deps.pageController.hover(selector);
+			return R.ok().build({
+				message: `Hovered: ${selector}`,
+				...frameOptions ? { frame: frameOptions } : {}
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageScroll(args) {
+		try {
+			const x = argNumber(args, "x", 0);
+			const y = argNumber(args, "y", 0);
+			if (this.deps.getActiveDriver() === "camoufox") {
+				await (await this.deps.getCamoufoxPage()).evaluate((position) => {
+					window.scrollTo(position.x || 0, position.y || 0);
+				}, {
+					x,
+					y
+				});
+				return R.ok().build({
+					driver: "camoufox",
+					message: `Scrolled to: x=${x || 0}, y=${y || 0}`
+				});
+			}
+			await this.deps.pageController.scroll({
+				x,
+				y
+			});
+			return R.ok().build({ message: `Scrolled to: x=${x || 0}, y=${y || 0}` });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePagePressKey(args) {
+		try {
+			const key = argString(args, "key", "");
+			if (this.deps.getActiveDriver() === "camoufox") {
+				await (await this.deps.getCamoufoxPage()).keyboard.press(key);
+				return R.ok().build({
+					driver: "camoufox",
+					key
+				});
+			}
+			await this.deps.pageController.pressKey(key);
+			return R.ok().build({ key });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/evaluation-utils.ts
+/** Recursively remove keys listed in `fields` from any nested object/array. */
+function filterFields(value, fields) {
+	if (Array.isArray(value)) return value.map((item) => filterFields(item, fields));
+	if (value !== null && typeof value === "object") {
+		const obj = value;
+		const out = {};
+		for (const [key, nested] of Object.entries(obj)) if (!fields.has(key)) out[key] = filterFields(nested, fields);
+		return out;
+	}
+	return value;
+}
+/**
+* Recursively replace base64 payloads with a short placeholder.
+* Catches: data:[mime];base64,<payload> and bare strings >500 chars of [A-Za-z0-9+/=]
+*/
+function stripBase64Values(value) {
+	if (typeof value === "string") {
+		if (/^data:[a-z+-]+\/[a-z+-]+;base64,/i.test(value)) return `[base64 ~${Math.round(value.length / 1024)}KB stripped]`;
+		if (value.length > 500 && /^[A-Za-z0-9+/=\r\n]+$/.test(value.replace(/\s/g, ""))) return `[base64 ~${value.length}chars stripped]`;
+		return value;
+	}
+	if (Array.isArray(value)) return value.map((item) => stripBase64Values(item));
+	if (value !== null && typeof value === "object") {
+		const obj = value;
+		const out = {};
+		for (const [key, nested] of Object.entries(obj)) out[key] = stripBase64Values(nested);
+		return out;
+	}
+	return value;
+}
+function applyEvaluationPostFilters(raw, detailedDataManager, options) {
+	let result = options.autoSummarize ? detailedDataManager.smartHandle(raw, options.maxSize) : raw;
+	if (options.fieldFilter && options.fieldFilter.length > 0) result = filterFields(result, new Set(options.fieldFilter));
+	if (options.stripBase64) result = stripBase64Values(result);
+	return result;
+}
+//#endregion
+//#region src/server/domains/browser/handlers/page-evaluation.ts
+var PageEvaluationHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async getCamoufoxEvaluationContext(frameOptions) {
+		const page = await this.deps.getCamoufoxPage();
+		if (!frameOptions?.frameUrl && !frameOptions?.frameSelector) return page;
+		return await this.deps.pageController.resolveFrame(page, frameOptions);
+	}
+	async handlePageEvaluate(args) {
+		try {
+			const code = argString(args, "script", "") || argString(args, "code", "");
+			const autoSummarize = argBool(args, "autoSummarize", true);
+			const maxSize = argNumber(args, "maxSize", 51200);
+			const fieldFilterArg = argStringArray(args, "fieldFilter");
+			const doStripBase64 = argBool(args, "stripBase64", false);
+			const frameUrl = argString(args, "frameUrl");
+			const frameSelector = argString(args, "frameSelector");
+			const frameOptions = frameUrl || frameSelector ? {
+				frameUrl: frameUrl || void 0,
+				frameSelector: frameSelector || void 0
+			} : void 0;
+			if (this.deps.getActiveDriver() === "camoufox") {
+				const context = await this.getCamoufoxEvaluationContext(frameOptions);
+				const evaluateExpression = new Function(`return (${code})`);
+				const processedResult = applyEvaluationPostFilters(await context.evaluate(evaluateExpression), this.deps.detailedDataManager, {
+					autoSummarize,
+					maxSize,
+					fieldFilter: fieldFilterArg ?? void 0,
+					stripBase64: doStripBase64
+				});
+				return R.ok().build({
+					driver: "camoufox",
+					...frameOptions ? { frame: frameOptions } : {},
+					result: processedResult
+				});
+			}
+			const processedResult = applyEvaluationPostFilters(frameOptions ? await this.deps.pageController.evaluate(code, frameOptions) : await this.deps.pageController.evaluate(code), this.deps.detailedDataManager, {
+				autoSummarize,
+				maxSize,
+				fieldFilter: fieldFilterArg ?? void 0,
+				stripBase64: doStripBase64
+			});
+			return R.ok().build({
+				...frameOptions ? { frame: frameOptions } : {},
+				result: processedResult
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageScreenshot(args) {
+		try {
+			const requestedPath = argString(args, "path");
+			const type = argString(args, "type", "png");
+			const quality = argNumber(args, "quality");
+			const fullPage = argBool(args, "fullPage", false);
+			const clipArg = argObject(args, "clip");
+			const rawSelector = args.selector;
+			const selectors = [];
+			if (Array.isArray(rawSelector)) for (const s of rawSelector) {
+				const trimmed = typeof s === "string" ? s.trim() : "";
+				if (trimmed.length > 0 && trimmed.toLowerCase() !== "all") selectors.push(trimmed);
+			}
+			else if (typeof rawSelector === "string") {
+				const trimmed = rawSelector.trim();
+				if (trimmed.length > 0 && trimmed.toLowerCase() !== "all") selectors.push(trimmed);
+			}
+			if (selectors.length > 1) return this.screenshotBatch(selectors, requestedPath, type, quality);
+			const selector = selectors[0] ?? "";
+			const { absolutePath, displayPath, pathRewritten } = await resolveScreenshotOutputPath({
+				requestedPath,
+				type,
+				fallbackName: selector ? "element" : clipArg ? "region" : "page",
+				fallbackDir: "screenshots/manual"
+			});
+			if (this.deps.getActiveDriver() === "camoufox") {
+				const page = await this.deps.getCamoufoxPage();
+				let buffer;
+				if (selector) {
+					const element = await page.$(selector);
+					if (!element) return R.fail(`Element not found: ${selector}`).build();
+					buffer = await element.screenshot({
+						path: absolutePath,
+						type,
+						quality
+					});
+				} else buffer = await page.screenshot({
+					path: absolutePath,
+					type,
+					quality,
+					fullPage: clipArg ? false : fullPage
+				});
+				return R.ok().build({
+					driver: "camoufox",
+					selector: selector || void 0,
+					clip: clipArg || void 0,
+					message: `Screenshot taken: ${displayPath}`,
+					path: displayPath,
+					pathRewritten,
+					size: buffer?.length ?? 0
+				});
+			}
+			let buffer;
+			if (selector) {
+				const element = await (await this.deps.pageController.getPage()).$(selector);
+				if (!element) return R.fail(`Element not found: ${selector}`).build();
+				buffer = await element.screenshot({
+					path: absolutePath,
+					type,
+					quality
+				});
+			} else buffer = await this.deps.pageController.screenshot({
+				path: absolutePath,
+				type,
+				quality,
+				fullPage: clipArg ? false : fullPage,
+				clip: clipArg
+			});
+			return R.ok().build({
+				selector: selector || void 0,
+				clip: clipArg || void 0,
+				message: `Screenshot taken: ${displayPath}`,
+				path: displayPath,
+				pathRewritten,
+				size: buffer.length
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	/** Take one screenshot per selector and return all results. */
+	async screenshotBatch(selectors, requestedPath, type, quality) {
+		const isCamoufox = this.deps.getActiveDriver() === "camoufox";
+		const results = [];
+		for (const selector of selectors) {
+			const { absolutePath, displayPath } = await resolveScreenshotOutputPath({
+				requestedPath: requestedPath ? requestedPath.replace(/(\.\w+)$/, `-${selector.replace(/[^a-zA-Z0-9]/g, "_")}$1`) : void 0,
+				type,
+				fallbackName: `element-${selector.replace(/[^a-zA-Z0-9]/g, "_")}`,
+				fallbackDir: "screenshots/manual"
+			});
+			try {
+				let size = 0;
+				if (isCamoufox) {
+					const element = await (await this.deps.getCamoufoxPage()).$(selector);
+					if (!element) {
+						results.push({
+							selector,
+							success: false,
+							error: `Element not found: ${selector}`
+						});
+						continue;
+					}
+					size = (await element.screenshot({
+						path: absolutePath,
+						type,
+						quality
+					}))?.length ?? 0;
+				} else {
+					const element = await (await this.deps.pageController.getPage()).$(selector);
+					if (!element) {
+						results.push({
+							selector,
+							success: false,
+							error: `Element not found: ${selector}`
+						});
+						continue;
+					}
+					size = (await element.screenshot({
+						path: absolutePath,
+						type,
+						quality
+					})).length;
+				}
+				results.push({
+					selector,
+					success: true,
+					path: displayPath,
+					size
+				});
+			} catch (err) {
+				results.push({
+					selector,
+					success: false,
+					error: String(err)
+				});
+			}
+		}
+		return R.ok().build({
+			mode: "batch",
+			total: selectors.length,
+			succeeded: results.filter((r) => r.success).length,
+			results
+		});
+	}
+	async handlePageInjectScript(args) {
+		try {
+			const script = argString(args, "script", "");
+			await this.deps.pageController.injectScript(script);
+			return R.ok().build({ message: "Script injected" });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageWaitForSelector(args) {
+		try {
+			const selector = argString(args, "selector", "");
+			const timeout = argNumber(args, "timeout");
+			if (this.deps.getActiveDriver() === "camoufox") {
+				const page = await this.deps.getCamoufoxPage();
+				try {
+					await page.waitForSelector(selector, { timeout: timeout || 3e4 });
+					const element = await page.evaluate((sel) => {
+						const el = document.querySelector(sel);
+						if (!el) return null;
+						return {
+							tagName: el.tagName.toLowerCase(),
+							id: el.id || void 0,
+							className: el.className || void 0,
+							textContent: el.textContent?.trim().substring(0, 100) || void 0,
+							attributes: Array.from(el.attributes).reduce((acc, attr) => {
+								acc[attr.name] = attr.value;
+								return acc;
+							}, {})
+						};
+					}, selector);
+					return R.ok().build({
+						driver: "camoufox",
+						element,
+						message: `Selector appeared: ${selector}`
+					});
+				} catch {
+					return R.fail(`Timeout waiting for selector: ${selector}`).build({ driver: "camoufox" });
+				}
+			}
+			const result = await this.deps.pageController.waitForSelector(selector, timeout);
+			return R.ok().merge(result).build();
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/page-data.ts
+var PageDataHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleGetContent(_args) {
+		try {
+			const html = await this.deps.pageController.getContent();
+			return R.ok().build({ html });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleGetTitle(_args) {
+		try {
+			const title = await this.deps.pageController.getTitle();
+			return R.ok().build({ title });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleGetUrl(_args) {
+		try {
+			const url = await this.deps.pageController.getURL();
+			return R.ok().build({ url });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleGetText(args) {
+		try {
+			const selector = argString(args, "selector", "");
+			const text = await this.deps.pageController.evaluate(`document.querySelector(${JSON.stringify(selector)})?.textContent || ""`);
+			return R.ok().build({
+				selector,
+				text
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleGetOuterHtml(args) {
+		try {
+			const selector = argString(args, "selector", "");
+			const html = await this.deps.pageController.evaluate(`document.querySelector(${JSON.stringify(selector)})?.outerHTML || ""`);
+			return R.ok().build({
+				selector,
+				html
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleGetScrollPosition(_args) {
+		try {
+			const pos = await this.deps.pageController.evaluate(`({
+        scrollX: window.scrollX,
+        scrollY: window.scrollY,
+        maxScrollX: document.documentElement.scrollWidth - window.innerWidth,
+        maxScrollY: document.documentElement.scrollHeight - window.innerHeight
+      })`);
+			return R.ok().build(pos);
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageSetCookies(args) {
+		try {
+			const cookies = args.cookies;
+			await this.deps.pageController.setCookies(cookies);
+			return R.ok().build({ message: `Set ${cookies.length} cookies` });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageGetCookies(_args) {
+		try {
+			const cookies = await this.deps.pageController.getCookies();
+			return R.ok().build({
+				count: cookies.length,
+				cookies
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async getPageCookieCount() {
+		return (await this.deps.pageController.getCookies()).length;
+	}
+	async handlePageClearCookies(_args) {
+		try {
+			await this.deps.pageController.clearCookies();
+			return R.ok().build({ message: "Cookies cleared" });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageSetViewport(args) {
+		try {
+			const width = argNumber(args, "width", 0);
+			const height = argNumber(args, "height", 0);
+			await this.deps.pageController.setViewport(width, height);
+			return R.ok().build({ viewport: {
+				width,
+				height
+			} });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageEmulateDevice(args) {
+		try {
+			const device = argString(args, "device", "");
+			await this.deps.pageController.emulateDevice(device);
+			return R.ok().build({ device });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageGetLocalStorage(_args) {
+		try {
+			const storage = await this.deps.pageController.getLocalStorage();
+			return R.ok().build({
+				count: Object.keys(storage).length,
+				storage
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handlePageSetLocalStorage(args) {
+		try {
+			const key = argString(args, "key", "");
+			const value = argString(args, "value", "");
+			await this.deps.pageController.setLocalStorage(key, value);
+			return R.ok().build({ key });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/console-handlers.ts
+var ConsoleHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleConsoleMonitor(args) {
+		try {
+			if (argString(args, "action") === "enable") {
+				await this.deps.consoleMonitor.enable();
+				return R.ok().build({ message: "Console monitoring enabled" });
+			} else {
+				await this.deps.consoleMonitor.disable();
+				return R.ok().build({ message: "Console monitoring disabled" });
+			}
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleConsoleGetLogs(args) {
+		try {
+			const type = argString(args, "type");
+			const limit = argNumber(args, "limit");
+			const since = argNumber(args, "since");
+			const logs = this.deps.consoleMonitor.getLogs({
+				type,
+				limit,
+				since
+			});
+			const result = {
+				count: logs.length,
+				logs
+			};
+			const processedResult = this.deps.detailedDataManager.smartHandle(result, 51200);
+			return R.ok().merge(processedResult).build();
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleConsoleExecute(args) {
+		try {
+			const expression = argString(args, "expression", "");
+			const result = await this.deps.consoleMonitor.execute(expression);
+			return R.ok().build({ result });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/script-management.ts
+var ScriptManagementHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleGetAllScripts(args) {
+		try {
+			const includeSource = argBool(args, "includeSource", false);
+			const MAX_SCRIPTS_CAP = SCRIPTS_MAX_CAP;
+			const maxScripts = Math.min(argNumber(args, "maxScripts", includeSource ? 200 : 1e3), MAX_SCRIPTS_CAP);
+			const scripts = await this.deps.scriptManager.getAllScripts(includeSource, maxScripts);
+			const data = {
+				count: scripts.length,
+				scripts
+			};
+			const processed = this.deps.detailedDataManager.smartHandle(data);
+			return R.ok().merge(processed).build();
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleGetScriptSource(args) {
+		try {
+			const scriptId = argString(args, "scriptId");
+			const url = argString(args, "url");
+			const preview = argBool(args, "preview", true);
+			const maxLines = argNumber(args, "maxLines", 100);
+			const startLine = argNumber(args, "startLine");
+			const endLine = argNumber(args, "endLine");
+			const script = await this.deps.scriptManager.getScriptSource(scriptId, url);
+			if (!script) return R.fail("Script not found").build();
+			if (preview || startLine !== void 0 || endLine !== void 0) {
+				const source = script.source || "";
+				const lines = source.split("\n");
+				const totalLines = lines.length;
+				const size = source.length;
+				let previewContent;
+				let actualStartLine;
+				let actualEndLine;
+				if (startLine !== void 0 && endLine !== void 0) {
+					actualStartLine = Math.max(1, startLine);
+					actualEndLine = Math.min(totalLines, endLine);
+					previewContent = lines.slice(actualStartLine - 1, actualEndLine).join("\n");
+				} else {
+					actualStartLine = 1;
+					actualEndLine = Math.min(maxLines, totalLines);
+					previewContent = lines.slice(0, maxLines).join("\n");
+				}
+				const result = {
+					scriptId: script.scriptId,
+					url: script.url,
+					preview: true,
+					totalLines,
+					size,
+					sizeKB: (size / 1024).toFixed(1) + "KB",
+					showingLines: `${actualStartLine}-${actualEndLine}`,
+					content: previewContent,
+					hint: size > 51200 ? `Script is large (${(size / 1024).toFixed(1)}KB). Use startLine/endLine to get specific sections, or set preview=false to get full source (will return detailId).` : "Set preview=false to get full source"
+				};
+				return R.ok().build(result);
+			}
+			const processedScript = this.deps.detailedDataManager.smartHandle(script, 51200);
+			return R.ok().merge(processedScript).build();
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/captcha-handlers.ts
+var CaptchaHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleCaptchaDetect(_args) {
+		try {
+			const page = await this.deps.pageController.getPage();
+			const result = await this.deps.captchaDetector.detect(page);
+			return R.ok().build({
+				captcha_detected: result.detected,
+				captcha_info: result
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleCaptchaWait(args) {
+		try {
+			const timeout = argNumber(args, "timeout", this.deps.captchaTimeout);
+			const page = await this.deps.pageController.getPage();
+			logger.info("Waiting for CAPTCHA to be solved...");
+			if (!await this.deps.captchaDetector.waitForCompletion(page, timeout)) return R.fail("CAPTCHA wait timed out").build();
+			return R.ok().build({ message: "CAPTCHA solved" });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleCaptchaConfig(args) {
+		try {
+			if (args.autoDetectCaptcha !== void 0) this.deps.setAutoDetectCaptcha(argBool(args, "autoDetectCaptcha", false));
+			if (args.autoSwitchHeadless !== void 0) this.deps.setAutoSwitchHeadless(argBool(args, "autoSwitchHeadless", false));
+			if (args.captchaTimeout !== void 0) this.deps.setCaptchaTimeout(argNumber(args, "captchaTimeout", 0));
+			return R.ok().build({ config: {
+				autoDetectCaptcha: this.deps.autoDetectCaptcha,
+				autoSwitchHeadless: this.deps.autoSwitchHeadless,
+				captchaTimeout: this.deps.captchaTimeout
+			} });
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+};
+//#endregion
+//#region src/modules/stealth/CDPTimingProxy.types.ts
+const DEFAULT_TIMING_OPTIONS = {
+	enabled: true,
+	minDelayMs: 20,
+	maxDelayMs: 80,
+	burstMode: false
+};
+//#endregion
+//#region src/modules/stealth/SessionProfileManager.ts
+var SessionProfileManager = class SessionProfileManager {
+	static instance = null;
+	cachedProfile = null;
+	static DEFAULT_TTL_SEC = 1800;
+	static getInstance() {
+		if (!SessionProfileManager.instance) SessionProfileManager.instance = new SessionProfileManager();
+		return SessionProfileManager.instance;
+	}
+	async exportFromPage(page, options = {}) {
+		const cookies = await page.cookies();
+		const pageMeta = await page.evaluate(() => {
+			const nav = navigator;
+			const uaData = nav.userAgentData;
+			const clientHints = {
+				secChUa: Array.isArray(uaData?.brands) ? uaData.brands.map((b) => `"${b.brand}";v="${b.version}"`).join(", ") : void 0,
+				secChUaMobile: typeof uaData?.mobile === "boolean" ? uaData.mobile ? "?1" : "?0" : void 0,
+				secChUaPlatform: uaData?.platform ? `"${uaData.platform}"` : void 0
+			};
+			return {
+				userAgent: nav.userAgent,
+				platform: nav.platform,
+				acceptLanguage: nav.language,
+				referer: document.referrer || void 0,
+				clientHints
+			};
+		});
+		const origin = options.origin ?? this.safeOrigin(page.url());
+		const ttlSec = options.ttlSec ?? SessionProfileManager.DEFAULT_TTL_SEC;
+		const profile = {
+			cookies: cookies.map((c) => ({
+				name: c.name,
+				value: c.value,
+				domain: c.domain,
+				path: c.path,
+				expires: c.expires,
+				size: c.size,
+				httpOnly: c.httpOnly,
+				secure: c.secure,
+				session: c.session,
+				sameSite: c.sameSite,
+				sourceScheme: c.sourceScheme
+			})),
+			userAgent: pageMeta.userAgent,
+			acceptLanguage: pageMeta.acceptLanguage,
+			referer: options.referer ?? pageMeta.referer,
+			clientHints: pageMeta.clientHints,
+			platform: pageMeta.platform,
+			origin,
+			collectedAt: Date.now(),
+			ttlSec
+		};
+		this.cachedProfile = profile;
+		logger.info(`Session profile exported: cookies=${profile.cookies.length}, origin=${profile.origin ?? "unknown"}, ttlSec=${profile.ttlSec}`);
+		return profile;
+	}
+	serialize(profile) {
+		return JSON.stringify(profile);
+	}
+	deserialize(raw) {
+		const parsed = JSON.parse(raw);
+		return {
+			cookies: Array.isArray(parsed.cookies) ? parsed.cookies : [],
+			userAgent: parsed.userAgent,
+			acceptLanguage: parsed.acceptLanguage,
+			referer: parsed.referer,
+			clientHints: parsed.clientHints,
+			platform: parsed.platform,
+			origin: parsed.origin,
+			collectedAt: typeof parsed.collectedAt === "number" ? parsed.collectedAt : Date.now(),
+			ttlSec: typeof parsed.ttlSec === "number" && parsed.ttlSec > 0 ? parsed.ttlSec : SessionProfileManager.DEFAULT_TTL_SEC
+		};
+	}
+	setProfile(profile) {
+		this.cachedProfile = profile;
+	}
+	getProfile() {
+		return this.cachedProfile;
+	}
+	getValidProfile(now = Date.now()) {
+		if (!this.cachedProfile || this.isExpired(this.cachedProfile, now)) return null;
+		return this.cachedProfile;
+	}
+	isExpired(profile, now = Date.now()) {
+		return profile.collectedAt + profile.ttlSec * 1e3 <= now;
+	}
+	clearProfile() {
+		this.cachedProfile = null;
+	}
+	static resetInstance() {
+		SessionProfileManager.instance = null;
+	}
+	safeOrigin(url) {
+		if (!url || url === "about:blank") return void 0;
+		try {
+			return new URL(url).origin;
+		} catch {
+			return;
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/stealth-injection.ts
+/** Module-level jitter configuration shared across handler calls. */
+const jitterOptions = { ...DEFAULT_TIMING_OPTIONS };
+let fingerprintManagerInstance = null;
+const sessionProfileManager = SessionProfileManager.getInstance();
+async function getFingerprintManager() {
+	if (fingerprintManagerInstance) return fingerprintManagerInstance;
+	try {
+		fingerprintManagerInstance = (await import("./FingerprintManager-BN4UQWnX.mjs")).FingerprintManager.getInstance();
+		return fingerprintManagerInstance;
+	} catch {
+		return null;
+	}
+}
+var StealthInjectionHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleStealthInject(_args) {
+		try {
+			if (this.deps.getActiveDriver() === "camoufox") return R.ok().build({
+				driver: "camoufox",
+				message: "Camoufox uses C++ engine-level fingerprint spoofing — JS-layer stealth scripts are not needed and have been skipped."
+			});
+			const page = await this.deps.pageController.getPage();
+			const fm = await getFingerprintManager();
+			let fingerprintApplied = false;
+			if (fm?.isAvailable()) try {
+				let profile = fm.getActiveProfile();
+				if (!profile) profile = await fm.generateFingerprint();
+				if (profile) {
+					await fm.injectFingerprint(page, profile);
+					fingerprintApplied = true;
+				}
+			} catch (err) {
+				logger.warn("Fingerprint injection failed, falling back to StealthScripts:", err);
+			}
+			await StealthScripts.injectAll(page);
+			if (fingerprintApplied && fm) {
+				const activeProfile = fm.getActiveProfile();
+				const cached = sessionProfileManager.getValidProfile();
+				const mergedProfile = {
+					cookies: cached?.cookies ?? [],
+					userAgent: activeProfile?.headers?.["User-Agent"] ?? cached?.userAgent,
+					acceptLanguage: activeProfile?.headers?.["Accept-Language"] ?? cached?.acceptLanguage,
+					referer: cached?.referer,
+					clientHints: cached?.clientHints,
+					platform: activeProfile?.os ?? cached?.platform,
+					origin: cached?.origin,
+					collectedAt: cached?.collectedAt ?? Date.now(),
+					ttlSec: cached?.ttlSec ?? 1800
+				};
+				sessionProfileManager.setProfile(mergedProfile);
+			}
+			return R.ok().build({
+				message: "Stealth scripts injected successfully",
+				fingerprintApplied,
+				_nextStepHint: "Stealth patches are now active. Next: navigate to your target URL with page_navigate. Do NOT call stealth_inject again — it only needs to run once per page."
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleStealthSetUserAgent(args) {
+		try {
+			const platform = argString(args, "platform", "windows");
+			const page = await this.deps.pageController.getPage();
+			await StealthScripts.setRealisticUserAgent(page, platform);
+			return R.ok().build({
+				platform,
+				message: `User-Agent set for ${platform}`,
+				_nextStepHint: "User-Agent is now configured. Next: call stealth_inject to apply all anti-detection patches, then page_navigate to your target URL."
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleStealthConfigureJitter(args) {
+		try {
+			if (args.enabled !== void 0) jitterOptions.enabled = Boolean(args.enabled);
+			if (typeof args.minDelayMs === "number") jitterOptions.minDelayMs = args.minDelayMs;
+			if (typeof args.maxDelayMs === "number") jitterOptions.maxDelayMs = args.maxDelayMs;
+			if (args.burstMode !== void 0) jitterOptions.burstMode = Boolean(args.burstMode);
+			return R.ok().build({
+				jitterOptions,
+				message: `CDP timing jitter ${jitterOptions.enabled ? "enabled" : "disabled"}: ${jitterOptions.minDelayMs}-${jitterOptions.maxDelayMs}ms${jitterOptions.burstMode ? " (burst mode)" : ""}`
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleStealthGenerateFingerprint(args) {
+		try {
+			if (this.deps.getActiveDriver() === "camoufox") try {
+				const fingerprints = await import("camoufox-js/fingerprints");
+				const os = argString(args, "os", "windows");
+				const fp = await fingerprints.generateFingerprint(os);
+				return R.ok().build({
+					fingerprint: fp,
+					driver: "camoufox",
+					message: "Fingerprint generated using camoufox native engine. Apply via browser_launch(fingerprint=...) before launching."
+				});
+			} catch (err) {
+				return R.fail(`Camoufox fingerprint generation failed: ${err instanceof Error ? err.message : String(err)}`).build();
+			}
+			const fm = await getFingerprintManager();
+			if (!fm?.isAvailable()) return R.fail("fingerprint-generator/fingerprint-injector packages are not installed. Install them with: pnpm add fingerprint-generator fingerprint-injector").merge({
+				available: false,
+				capability: "fingerprint_generator",
+				status: "unavailable",
+				fix: "Install fingerprint-generator and fingerprint-injector: pnpm add fingerprint-generator fingerprint-injector"
+			}).build();
+			const profile = await fm.generateFingerprint({
+				os: args.os,
+				browser: args.browser ?? "chrome",
+				locale: args.locale ?? "en-US"
+			});
+			return R.ok().build({
+				profile,
+				message: "Fingerprint generated and cached. It will be auto-applied on next stealth_inject."
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+	async handleStealthVerify(_args) {
+		try {
+			const page = await this.deps.pageController.getPage();
+			const result = await new (await (import("./StealthVerifier-BWmPgQsv.mjs"))).StealthVerifier().verify(page);
+			return R.ok().merge(result).build();
+		} catch (err) {
+			return R.fail(`Stealth verification failed: ${err instanceof Error ? err.message : String(err)}`).build();
+		}
+	}
+	async handleCamoufoxGeolocation(args) {
+		try {
+			const locale = argString(args, "locale");
+			if (!locale) return R.fail("locale is required (e.g. \"en-US\", \"zh-CN\")").build();
+			let geo;
+			try {
+				geo = await (await import("camoufox-js/locale")).getGeolocation(locale);
+			} catch (err) {
+				return R.fail(`Camoufox locale module unavailable: ${err instanceof Error ? err.message : String(err)}. Ensure camoufox-js is installed.`).merge({
+					available: false,
+					capability: "camoufox_locale",
+					status: "unavailable",
+					fix: "Install camoufox-js and fetch its browser assets: pnpm add camoufox-js && npx camoufox-js fetch"
+				}).build();
+			}
+			let publicIp = null;
+			const proxy = argString(args, "proxy");
+			if (proxy) try {
+				publicIp = await (await import("camoufox-js/ip")).publicIP(proxy);
+			} catch {}
+			return R.ok().build({
+				locale,
+				geolocation: geo,
+				publicIp
+			});
+		} catch (e) {
+			return R.fail(e).build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/framework-state.ts
+var FrameworkStateHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleFrameworkStateExtract(args) {
+		const framework = argString(args, "framework", "auto");
+		const selector = argString(args, "selector", "");
+		const maxDepth = argNumber(args, "maxDepth", 5);
+		try {
+			const page = await this.deps.getActivePage();
+			try {
+				const cdp = await page.createCDPSession();
+				await Promise.race([cdp.send("Runtime.evaluate", {
+					expression: "1",
+					returnByValue: true
+				}), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("cdp_unreachable")), 3e3))]);
+			} catch {
+				throw new PrerequisiteError("CDP session unresponsive — the debugger may be blocking page evaluation. Call debugger_lifecycle({ action: 'disable' })() before framework_state_extract, or run it before debugger_lifecycle({ action: 'enable' }).");
+			}
+			const evalPromise = page.evaluate((opts) => {
+				const win = window;
+				function safeSerialize(val, depth = 0) {
+					if (depth > 4) return "[deep]";
+					if (val === null || val === void 0) return val;
+					if (typeof val === "function") return "[Function]";
+					if (typeof val !== "object") return val;
+					if (Array.isArray(val)) return val.slice(0, 20).map((v) => safeSerialize(v, depth + 1));
+					try {
+						const out = {};
+						let count = 0;
+						for (const k of Object.keys(val)) {
+							if (count++ > 30) {
+								out["__truncated__"] = true;
+								break;
+							}
+							out[k] = safeSerialize(val[k], depth + 1);
+						}
+						return out;
+					} catch {
+						return "[unserializable]";
+					}
+				}
+				const getRootEl = () => {
+					if (opts.selector) return document.querySelector(opts.selector) ?? document.body;
+					return document.getElementById("root") ?? document.getElementById("app") ?? document.querySelector("[data-reactroot]") ?? document.body;
+				};
+				const extractReact = () => {
+					const rootObj = getRootEl();
+					const fiberKey = Object.keys(rootObj).find((k) => k.startsWith("__reactFiber") || k.startsWith("__reactInternalInstance") || k.startsWith("__reactFiberContainer"));
+					if (!fiberKey) return null;
+					const states = [];
+					const visited = /* @__PURE__ */ new WeakSet();
+					const visitFiber = (fiber, depth) => {
+						if (!fiber || depth > opts.maxDepth || visited.has(fiber)) return;
+						visited.add(fiber);
+						if (fiber["memoizedState"]) {
+							const stateList = [];
+							let s = fiber["memoizedState"];
+							let guard = 0;
+							while (s && guard++ < 20) {
+								const queue = s["queue"];
+								const val = s["memoizedState"] !== void 0 ? s["memoizedState"] : queue?.["lastRenderedState"];
+								if (val !== void 0) stateList.push(safeSerialize(val));
+								s = s["next"] ?? null;
+							}
+							if (stateList.length > 0) {
+								const fiberType = fiber["type"];
+								const componentName = typeof fiberType === "object" && fiberType !== null ? String(fiberType["name"] ?? "anonymous") : typeof fiberType === "string" ? fiberType : "anonymous";
+								states.push({
+									component: componentName,
+									state: stateList
+								});
+							}
+						}
+						visitFiber(fiber["child"] ?? null, depth + 1);
+						visitFiber(fiber["sibling"] ?? null, depth + 1);
+					};
+					visitFiber(rootObj[fiberKey] ?? null, 0);
+					return states;
+				};
+				const extractVue3 = () => {
+					const rootObj = getRootEl();
+					const vueKey = Object.keys(rootObj).find((k) => k === "__vueParentComponent" || k === "__vue_app__" || k.startsWith("__vue"));
+					if (!vueKey) return null;
+					const comp = rootObj[vueKey];
+					if (!comp) return null;
+					const states = [];
+					const visited = /* @__PURE__ */ new WeakSet();
+					const visitComp = (c, depth) => {
+						if (!c || depth > opts.maxDepth || visited.has(c)) return;
+						visited.add(c);
+						const setupState = safeSerialize(c["setupState"] ?? c["ctx"]);
+						const data = safeSerialize(c["$data"] ?? c["data"]);
+						if (setupState || data) {
+							const compType = c["type"];
+							states.push({
+								component: compType?.["__name"] ?? "unknown",
+								setupState,
+								data
+							});
+						}
+						const children = c["subTree"]?.["children"];
+						if (Array.isArray(children)) {
+							for (const child of children) if (child?.["component"]) visitComp(child["component"], depth + 1);
+						}
+					};
+					visitComp(comp, 0);
+					return states;
+				};
+				const extractVue2 = () => {
+					const rootObj = getRootEl();
+					const vueKey = Object.keys(rootObj).find((k) => k === "__vue__");
+					if (!vueKey) return null;
+					const vm = rootObj[vueKey];
+					if (!vm) return null;
+					const states = [];
+					const visited = /* @__PURE__ */ new WeakSet();
+					const visitVm = (v, depth) => {
+						if (!v || depth > opts.maxDepth || visited.has(v)) return;
+						visited.add(v);
+						const options = v["$options"];
+						states.push({
+							component: options?.["name"] ?? "unknown",
+							data: safeSerialize(v["$data"])
+						});
+						const children = v["$children"];
+						if (Array.isArray(children)) for (const child of children) visitVm(child, depth + 1);
+					};
+					visitVm(vm, 0);
+					return states;
+				};
+				const extractSvelte = () => {
+					const states = [];
+					const visited = /* @__PURE__ */ new WeakSet();
+					const svelteEls = document.querySelectorAll("[class]");
+					const candidates = [getRootEl(), ...Array.from(svelteEls)];
+					let foundAny = false;
+					for (const el of candidates) {
+						const obj = el;
+						if (!Object.keys(obj).some((k) => k === "$$" || k === "__svelte_meta" || k.startsWith("__s"))) continue;
+						foundAny = true;
+						const ctx = obj["$$"];
+						if (!ctx || visited.has(ctx)) continue;
+						visited.add(ctx);
+						const componentName = (obj["__svelte_meta"]?.["loc"])?.["file"];
+						const ctxArray = ctx["ctx"];
+						const stateObj = {};
+						if (Array.isArray(ctxArray)) {
+							let idx = 0;
+							for (const val of ctxArray.slice(0, 20)) {
+								if (val !== void 0 && typeof val !== "function") stateObj[`$${idx}`] = safeSerialize(val);
+								idx++;
+							}
+						}
+						const fragment = ctx["fragment"];
+						if (Object.keys(stateObj).length > 0 || fragment) states.push({
+							component: componentName ?? el.tagName?.toLowerCase() ?? "svelte-component",
+							state: [stateObj],
+							...componentName ? { file: componentName } : {}
+						});
+						if (states.length >= 50) break;
+					}
+					return foundAny ? states : null;
+				};
+				const extractSolid = () => {
+					const states = [];
+					const dx = win["_$DX"];
+					const hy = win["_$HY"];
+					if (!dx && !hy) {
+						if (!document.querySelector("[data-hk]")) return null;
+						states.push({
+							component: "SolidRoot",
+							state: [{ _note: "Solid detected via hydration markers; install solid-devtools for full state extraction" }]
+						});
+						return states;
+					}
+					if (dx) {
+						const roots = dx["roots"];
+						if (roots && typeof roots === "object") {
+							const entries = roots instanceof Map ? Array.from(roots.values()) : Object.values(roots);
+							let count = 0;
+							for (const root of entries) {
+								if (count++ >= opts.maxDepth * 10) break;
+								const name = root["name"] ?? "SolidComponent";
+								const value = root["value"] ?? root["state"];
+								states.push({
+									component: name,
+									state: value ? [safeSerialize(value)] : []
+								});
+							}
+						}
+					}
+					if (hy && states.length === 0) states.push({
+						component: "SolidHydration",
+						state: [safeSerialize(hy)]
+					});
+					return states.length > 0 ? states : null;
+				};
+				const extractPreact = () => {
+					const rootObj = getRootEl();
+					const rootKeys = Object.keys(rootObj);
+					if (rootKeys.some((k) => k.startsWith("__reactFiber") || k.startsWith("__reactInternalInstance"))) return null;
+					if (!rootKeys.some((k) => k === "__k" || k === "__e" || k === "_dom")) return null;
+					const states = [];
+					const visited = /* @__PURE__ */ new WeakSet();
+					const visitVNode = (vnode, depth) => {
+						if (!vnode || depth > opts.maxDepth || visited.has(vnode)) return;
+						visited.add(vnode);
+						const component = vnode["__c"];
+						if (component) {
+							const compState = component["state"];
+							const compProps = component["props"];
+							const hooks = component["__H"];
+							const hookStates = [];
+							if (hooks) {
+								const list = hooks["__"];
+								if (Array.isArray(list)) for (const h of list.slice(0, 20)) {
+									const val = h["__"] ?? h["_value"];
+									if (val !== void 0) hookStates.push(safeSerialize(val));
+								}
+							}
+							const typeName = vnode["type"];
+							const name = typeof typeName === "function" ? typeName["displayName"] ?? typeName["name"] ?? "PreactComponent" : typeof typeName === "string" ? typeName : "PreactComponent";
+							if (compState || hookStates.length > 0) states.push({
+								component: String(name),
+								state: hookStates.length > 0 ? hookStates : compState ? [safeSerialize(compState)] : [],
+								...compProps ? { props: safeSerialize(compProps) } : {}
+							});
+						}
+						const children = vnode["__k"];
+						if (Array.isArray(children)) {
+							for (const child of children) if (child) visitVNode(child, depth + 1);
+						}
+					};
+					const rootVNode = rootObj["__k"];
+					if (Array.isArray(rootVNode)) {
+						for (const vn of rootVNode) if (vn) visitVNode(vn, 0);
+					} else if (rootObj["_children"]) {
+						const alt = rootObj["_children"];
+						if (Array.isArray(alt)) {
+							for (const vn of alt) if (vn) visitVNode(vn, 0);
+						}
+					}
+					return states.length > 0 ? states : null;
+				};
+				const extractMetaFramework = () => {
+					const nextData = win["__NEXT_DATA__"];
+					if (nextData) return {
+						framework: "nextjs",
+						route: nextData["page"],
+						buildId: nextData["buildId"],
+						runtimeConfig: safeSerialize(nextData["runtimeConfig"]),
+						props: safeSerialize(nextData["props"])
+					};
+					const nuxt = win["__NUXT__"];
+					if (nuxt) {
+						if (nuxt["config"] !== void 0 || nuxt["_errors"] !== void 0) return {
+							framework: "nuxt3",
+							state: safeSerialize(nuxt["state"]),
+							config: safeSerialize(nuxt["config"]),
+							payload: safeSerialize(nuxt["data"])
+						};
+						return {
+							framework: "nuxt2",
+							state: safeSerialize(nuxt["state"]),
+							serverRendered: nuxt["serverRendered"]
+						};
+					}
+					return null;
+				};
+				const rootObj = getRootEl();
+				const keys = Object.keys(rootObj);
+				const hasReactMarker = keys.some((k) => k.startsWith("__reactFiber") || k.startsWith("__reactInternalInstance") || k.startsWith("__reactFiberContainer"));
+				const hasVue3Marker = keys.some((k) => k === "__vueParentComponent" || k === "__vue_app__");
+				const hasVue2Marker = keys.some((k) => k === "__vue__");
+				const hasSvelteMarker = keys.some((k) => k === "$$" || k === "__svelte_meta" || k.startsWith("__s"));
+				const hasSolidMarker = win["_$DX"] !== void 0 || win["_$HY"] !== void 0 || Boolean(document.querySelector("[data-hk]"));
+				const hasPreactMarker = keys.some((k) => k === "__k" || k === "__e" || k === "_dom" || k === "_children");
+				let detectedFramework = opts.framework;
+				if (detectedFramework === "preact" && hasReactMarker) detectedFramework = "react";
+				if (detectedFramework === "auto") {
+					if (hasReactMarker) detectedFramework = "react";
+					else if (hasVue3Marker) detectedFramework = "vue3";
+					else if (hasVue2Marker) detectedFramework = "vue2";
+					else if (hasSvelteMarker) detectedFramework = "svelte";
+					else if (hasSolidMarker) detectedFramework = "solid";
+					else if (hasPreactMarker) detectedFramework = "preact";
+				}
+				let states = null;
+				if (detectedFramework === "react" || detectedFramework === "auto") states = extractReact();
+				if (!states && (detectedFramework === "vue3" || detectedFramework === "auto")) states = extractVue3();
+				if (!states && (detectedFramework === "vue2" || detectedFramework === "auto")) states = extractVue2();
+				if (!states && (detectedFramework === "svelte" || detectedFramework === "auto")) states = extractSvelte();
+				if (!states && (detectedFramework === "solid" || detectedFramework === "auto")) states = extractSolid();
+				if (!states && (detectedFramework === "preact" || detectedFramework === "auto")) states = extractPreact();
+				const meta = extractMetaFramework();
+				return {
+					detected: detectedFramework,
+					states: states ?? [],
+					found: states !== null && states.length > 0,
+					...meta ? { meta } : {}
+				};
+			}, {
+				framework,
+				selector,
+				maxDepth
+			});
+			const result = await Promise.race([evalPromise, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("page.evaluate timed out after 30000ms")), 3e4))]);
+			return R.ok().build(result);
+		} catch (error) {
+			return R.fail(error).build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/indexeddb-dump.ts
+var IndexedDBDumpHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleIndexedDBDump(args) {
+		const database = argString(args, "database", "");
+		const store = argString(args, "store", "");
+		const maxRecords = argNumber(args, "maxRecords", 100);
+		try {
+			const result = await (await this.deps.getActivePage()).evaluate(async (opts) => {
+				const dbList = await indexedDB.databases();
+				const output = {};
+				for (const dbInfo of dbList) {
+					if (!dbInfo.name) continue;
+					if (opts.database && dbInfo.name !== opts.database) continue;
+					const dbName = dbInfo.name;
+					let db;
+					try {
+						db = await new Promise((resolve, reject) => {
+							const req = dbInfo.version ? indexedDB.open(dbName, dbInfo.version) : indexedDB.open(dbName);
+							req.addEventListener("success", () => resolve(req.result), { once: true });
+							req.addEventListener("error", () => reject(req.error), { once: true });
+						});
+					} catch {
+						output[dbName] = { __error__: ["failed to open"] };
+						continue;
+					}
+					const storeNames = Array.from(db.objectStoreNames);
+					const dbData = {};
+					for (const storeName of storeNames) {
+						if (opts.store && storeName !== opts.store) continue;
+						try {
+							dbData[storeName] = await new Promise((resolve, reject) => {
+								try {
+									const req = db.transaction(storeName, "readonly").objectStore(storeName).getAll();
+									req.addEventListener("success", () => resolve(req.result.slice(0, opts.maxRecords)), { once: true });
+									req.addEventListener("error", () => reject(req.error), { once: true });
+								} catch (e) {
+									reject(e);
+								}
+							});
+						} catch {
+							dbData[storeName] = ["__error reading store__"];
+						}
+					}
+					db.close();
+					output[dbName] = dbData;
+				}
+				return output;
+			}, {
+				database,
+				store,
+				maxRecords
+			});
+			return R.ok().build(result);
+		} catch (error) {
+			return R.fail(error).build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/detailed-data.ts
+var DetailedDataHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleGetDetailedData(args) {
+		try {
+			const detailId = argString(args, "detailId", "");
+			const path = argString(args, "path");
+			const data = this.deps.detailedDataManager.retrieve(detailId, path);
+			return R.ok().build({
+				detailId,
+				path: path || "full",
+				data
+			});
+		} catch (error) {
+			return R.fail(error).set("hint", "DetailId may have expired (TTL: 10 minutes) or is invalid").build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/target-evaluation.ts
+var TargetEvaluationHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleBrowserEvaluateCdpTarget(args) {
+		try {
+			const code = argString(args, "script", "") || argString(args, "code", "");
+			const autoSummarize = argBool(args, "autoSummarize", true);
+			const maxSize = argNumber(args, "maxSize", 51200);
+			const fieldFilterArg = argStringArray(args, "fieldFilter");
+			const doStripBase64 = argBool(args, "stripBase64", false);
+			const returnByValue = argBool(args, "returnByValue", true);
+			const awaitPromise = argBool(args, "awaitPromise", true);
+			if (!code) return R.fail("code is required").build();
+			const activeTarget = this.deps.pageController.getAttachedTargetInfo();
+			if (!activeTarget) return R.fail("No CDP target is currently attached. Call browser_attach_cdp_target(targetId=\"...\") first.").build();
+			const processedResult = applyEvaluationPostFilters(await this.deps.pageController.evaluateAttachedTarget(code, {
+				returnByValue,
+				awaitPromise
+			}), this.deps.detailedDataManager, {
+				autoSummarize,
+				maxSize,
+				fieldFilter: fieldFilterArg ?? void 0,
+				stripBase64: doStripBase64
+			});
+			return R.ok().build({
+				target: activeTarget,
+				result: processedResult
+			});
+		} catch (error) {
+			logger.error("Failed to evaluate in CDP target:", error);
+			return R.fail(error instanceof Error ? error.message : String(error)).build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/target-control.ts
+var TargetControlHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	markMonitoringContextChanged(context) {
+		try {
+			this.deps.consoleMonitor.markContextChanged();
+		} catch (error) {
+			logger.warn(`[${context}] Failed to mark monitoring context as stale: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	safeOrigin(url) {
+		if (!url) return null;
+		try {
+			return new URL(url).origin;
+		} catch {
+			return null;
+		}
+	}
+	async clearAttachedTargetContext(context) {
+		const activeTarget = this.deps.collector.getAttachedTargetInfo();
+		if (!activeTarget) return {
+			detached: false,
+			targetId: null,
+			type: null
+		};
+		const detached = await this.deps.collector.detachCdpTarget();
+		if (detached) logger.info(`[${context}] Detached active CDP target ${activeTarget.targetId} before switching page context`);
+		return {
+			detached,
+			targetId: activeTarget.targetId,
+			type: activeTarget.type ?? null
+		};
+	}
+	async handleBrowserListCdpTargets(args) {
+		try {
+			const type = argString(args, "type");
+			const types = argStringArray(args, "types");
+			const targetId = argString(args, "targetId");
+			const urlPattern = argString(args, "urlPattern");
+			const titlePattern = argString(args, "titlePattern");
+			const attachedOnly = argBool(args, "attachedOnly", false);
+			const discoverOOPIF = argBool(args, "discoverOOPIF", true);
+			const targets = await this.deps.collector.listCdpTargets({
+				type: type ?? void 0,
+				types: types ?? void 0,
+				targetId: targetId ?? void 0,
+				urlPattern: urlPattern ?? void 0,
+				titlePattern: titlePattern ?? void 0,
+				attachedOnly,
+				discoverOOPIF
+			});
+			const activeTarget = this.deps.collector.getAttachedTargetInfo();
+			const contextMeta = this.deps.getTabRegistry().getContextMeta();
+			const pages = await this.deps.collector.listPages();
+			const currentTab = typeof contextMeta.tabIndex === "number" ? pages[contextMeta.tabIndex] : void 0;
+			const currentTabUrl = currentTab?.url ?? null;
+			const currentTabOrigin = this.safeOrigin(currentTabUrl);
+			const enrichedTargets = targets.map((target) => {
+				const targetUrl = target.url;
+				const targetOrigin = this.safeOrigin(targetUrl);
+				const currentTabMatch = currentTabUrl !== null && targetUrl === currentTabUrl;
+				const sameOriginAsCurrentTab = currentTabOrigin !== null && targetOrigin !== null && currentTabOrigin === targetOrigin;
+				const isActiveTarget = activeTarget?.targetId === target.targetId;
+				const relationHints = [];
+				if (isActiveTarget) relationHints.push("active_target");
+				if (currentTabMatch) relationHints.push("matches_current_tab_url");
+				if (!currentTabMatch && sameOriginAsCurrentTab) relationHints.push("same_origin_as_current_tab");
+				if (target.openerId && activeTarget?.targetId === target.openerId) relationHints.push("opened_by_active_target");
+				if (target.openerId && !relationHints.includes("opened_by_active_target")) relationHints.push("has_opener_target");
+				if (target.openerFrameId) relationHints.push("has_opener_frame");
+				return {
+					...target,
+					isActiveTarget,
+					matchesCurrentTabUrl: currentTabMatch,
+					sameOriginAsCurrentTab,
+					relationHints
+				};
+			});
+			return R.ok().build({
+				count: enrichedTargets.length,
+				activeTarget,
+				currentTab: currentTab ? {
+					index: currentTab.index,
+					url: currentTab.url,
+					title: currentTab.title
+				} : null,
+				filters: {
+					type: type ?? null,
+					types: types ?? null,
+					targetId: targetId ?? null,
+					urlPattern: urlPattern ?? null,
+					titlePattern: titlePattern ?? null,
+					attachedOnly
+				},
+				targets: enrichedTargets
+			});
+		} catch (error) {
+			logger.error("Failed to list CDP targets:", error);
+			return R.fail(error instanceof Error ? error.message : String(error)).build();
+		}
+	}
+	async handleBrowserAttachCdpTarget(args) {
+		try {
+			const targetId = argString(args, "targetId");
+			if (!targetId) throw new Error("targetId is required");
+			const target = await this.deps.collector.attachCdpTarget(targetId);
+			this.markMonitoringContextChanged("browser_attach_cdp_target");
+			return R.ok().build({
+				attached: true,
+				target
+			});
+		} catch (error) {
+			logger.error("Failed to attach CDP target:", error);
+			return R.fail(error instanceof Error ? error.message : String(error)).build();
+		}
+	}
+	async handleBrowserDetachCdpTarget(_args) {
+		try {
+			const activeTarget = this.deps.collector.getAttachedTargetInfo();
+			const detached = await this.deps.collector.detachCdpTarget();
+			if (detached) this.markMonitoringContextChanged("browser_detach_cdp_target");
+			return R.ok().build({
+				detached,
+				targetId: activeTarget?.targetId ?? null
+			});
+		} catch (error) {
+			logger.error("Failed to detach CDP target:", error);
+			return R.fail(error instanceof Error ? error.message : String(error)).build();
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/js-heap.ts
+const NODE_TYPE_NAMES = [
+	"hidden",
+	"array",
+	"string",
+	"object",
+	"code",
+	"closure",
+	"regexp",
+	"number",
+	"native",
+	"synthetic",
+	"concatenated string",
+	"sliced string",
+	"symbol",
+	"bigint"
+];
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+function isCDPPageLike(value) {
+	return isRecord$1(value) && typeof value.createCDPSession === "function";
+}
+function isHeapSnapshotChunk(value) {
+	return isRecord$1(value) && typeof value.chunk === "string";
+}
+var JSHeapSearchHandlers = class {
+	detailedDataManager;
+	constructor(deps) {
+		this.deps = deps;
+		this.detailedDataManager = DetailedDataManager.getInstance();
+	}
+	async handleJSHeapSearch(args) {
+		const pattern = argString(args, "pattern", "") || argString(args, "query", "");
+		const maxResults = argNumber(args, "maxResults", 50);
+		const caseSensitive = argBool(args, "caseSensitive", false);
+		if (!pattern) return R.fail("pattern is required").build();
+		return cdpLimit(async () => {
+			let cdpSession = null;
+			let ownedSession = false;
+			try {
+				const page = await this.deps.getActivePage();
+				if (!isCDPPageLike(page)) throw new Error("Active page does not support CDP session creation");
+				cdpSession = await page.createCDPSession();
+				ownedSession = true;
+				logger.info("[js_heap_search] Taking heap snapshot", {
+					patternLength: pattern.length,
+					caseSensitive,
+					maxResults
+				});
+				await cdpSession.send("HeapProfiler.enable");
+				const snapshotChunks = [];
+				let snapshotSize = 0;
+				cdpSession.on("HeapProfiler.addHeapSnapshotChunk", (params) => {
+					if (isHeapSnapshotChunk(params)) {
+						snapshotChunks.push(params.chunk);
+						snapshotSize += params.chunk.length;
+					}
+				});
+				await cdpSession.send("HeapProfiler.takeHeapSnapshot", {
+					reportProgress: false,
+					treatGlobalObjectsAsRoots: true,
+					captureNumericValue: false
+				});
+				await cdpSession.send("HeapProfiler.disable");
+				logger.info(`[js_heap_search] Snapshot size: ${(snapshotSize / 1024).toFixed(1)} KB`);
+				const snapshotData = snapshotChunks.join("");
+				snapshotChunks.length = 0;
+				const matches = this.searchSnapshot(snapshotData, pattern, maxResults, caseSensitive);
+				const result = {
+					success: true,
+					pattern,
+					caseSensitive,
+					snapshotSizeKB: Math.round(snapshotSize / 1024),
+					matchCount: matches.length,
+					truncated: matches.length >= maxResults,
+					matches,
+					tip: matches.length > 0 ? "Use page_evaluate to inspect the objects at the paths found. E.g., eval the objectPath as a JS expression." : "No matches found. The value may be encrypted, compressed, or stored in a non-string form."
+				};
+				return R.ok().build(this.detailedDataManager.smartHandle(result, 51200));
+			} catch (error) {
+				logger.error("[js_heap_search] Error:", error);
+				return R.fail(error).build();
+			} finally {
+				if (ownedSession && cdpSession) try {
+					await cdpSession.detach();
+				} catch {}
+			}
+		});
+	}
+	searchSnapshot(snapshotData, pattern, maxResults, caseSensitive) {
+		try {
+			let parsed;
+			try {
+				parsed = JSON.parse(snapshotData);
+			} catch {
+				return [];
+			}
+			if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return [];
+			const snapshot = parsed;
+			const stringsRaw = snapshot.strings;
+			const nodesRaw = snapshot.nodes;
+			const snapshotMeta = typeof snapshot.snapshot === "object" && snapshot.snapshot !== null ? snapshot.snapshot : null;
+			const meta = snapshotMeta && typeof snapshotMeta.meta === "object" && snapshotMeta.meta !== null ? snapshotMeta.meta : null;
+			const nodeFieldsRaw = meta?.node_fields;
+			const nodeTypesRaw = meta?.node_types;
+			if (!Array.isArray(nodeFieldsRaw) || !Array.isArray(stringsRaw) || !Array.isArray(nodesRaw)) return [];
+			const nodeFieldCount = nodeFieldsRaw.length;
+			if (nodeFieldCount === 0) return [];
+			const typeIdx = nodeFieldsRaw.indexOf("type");
+			const nameIdx = nodeFieldsRaw.indexOf("name");
+			const idIdx = nodeFieldsRaw.indexOf("id");
+			if (typeIdx < 0 || nameIdx < 0) return [];
+			const nodeTypeTable = Array.isArray(nodeTypesRaw) && Array.isArray(nodeTypesRaw[0]) ? nodeTypesRaw[0] : [];
+			const searchStr = caseSensitive ? pattern : pattern.toLowerCase();
+			const matches = [];
+			const nodeCount = Math.floor(nodesRaw.length / nodeFieldCount);
+			const stringsArr = stringsRaw;
+			for (let i = 0; i < nodeCount && matches.length < maxResults; i++) {
+				const base = i * nodeFieldCount;
+				const typeOrdinal = nodesRaw[base + typeIdx];
+				const nameOrdinal = nodesRaw[base + nameIdx];
+				if (typeof nameOrdinal !== "number" || nameOrdinal < 0 || nameOrdinal >= stringsArr.length) continue;
+				const tableName = nodeTypeTable[typeOrdinal];
+				const nodeTypeName = (typeof tableName === "string" ? tableName : void 0) ?? NODE_TYPE_NAMES[typeOrdinal] ?? `type_${typeOrdinal}`;
+				if (nodeTypeName !== "string" && nodeTypeName !== "concatenated string" && nodeTypeName !== "sliced string") continue;
+				const value = stringsArr[nameOrdinal];
+				if (typeof value !== "string") continue;
+				if (!(caseSensitive ? value : value.toLowerCase()).includes(searchStr)) continue;
+				const rawId = idIdx >= 0 ? nodesRaw[base + idIdx] : void 0;
+				const nodeId = rawId !== void 0 ? rawId : i;
+				matches.push({
+					nodeId,
+					nodeType: nodeTypeName,
+					value: value.length > 200 ? `${value.slice(0, 200)}…` : value,
+					objectPath: `[HeapNode #${nodeId}]`,
+					nameHint: value.slice(0, 80)
+				});
+			}
+			return matches;
+		} catch (error) {
+			logger.warn("[js_heap_search] Snapshot parse error:", error);
+			return [];
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/tab-workflow.ts
+const TAB_ACTIONS = new Set([
+	"alias_bind",
+	"alias_open",
+	"navigate",
+	"wait_for",
+	"context_set",
+	"context_get",
+	"transfer",
+	"list",
+	"clear"
+]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isTabAction(value) {
+	return typeof value === "string" && TAB_ACTIONS.has(value);
+}
+function isTabPageLike(value) {
+	return isRecord(value) && typeof value.goto === "function" && typeof value.waitForSelector === "function" && typeof value.evaluate === "function" && typeof value.url === "function" && typeof value.title === "function";
+}
+function isCamoufoxPageLike(value) {
+	if (!isTabPageLike(value) || !isRecord(value)) return false;
+	return typeof value.context === "function";
+}
+function isBrowserLike(value) {
+	return isRecord(value) && typeof value.newPage === "function" && typeof value.pages === "function";
+}
+function readRequiredString(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readAliasIndex(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+	return null;
+}
+function readTimeout(value, fallback) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+	return fallback;
+}
+var TabWorkflowHandlers = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	get registry() {
+		return this.deps.getTabRegistry();
+	}
+	async handleTabWorkflow(args) {
+		const action = args.action;
+		try {
+			if (!isTabAction(action)) return R.fail(`Unknown action: "${String(action)}". Valid: list, alias_bind, alias_open, navigate, wait_for, context_set, context_get, transfer, clear`).build();
+			switch (action) {
+				case "list": return this.listAliases();
+				case "clear": return this.clearState();
+				case "alias_bind": return await this.aliasBind(args);
+				case "alias_open": return await this.aliasOpen(args);
+				case "navigate": return await this.navigateAlias(args);
+				case "wait_for": return await this.waitFor(args);
+				case "context_set": return this.contextSet(args);
+				case "context_get": return this.contextGet(args);
+				case "transfer": return await this.transfer(args);
+			}
+		} catch (err) {
+			const errorMsg = err instanceof Error ? err.message : String(err);
+			logger.error("[tab_workflow] Action failed", {
+				action: typeof action === "string" ? action : String(action),
+				alias: typeof args.alias === "string" ? args.alias : void 0,
+				fromAlias: typeof args.fromAlias === "string" ? args.fromAlias : void 0,
+				error: errorMsg
+			});
+			return R.fail(errorMsg).build();
+		}
+	}
+	listAliases() {
+		const info = this.registry.getCurrentTabInfo(this.deps.getActiveDriver());
+		const context = this.registry.getSharedContextMap();
+		return R.ok().build({
+			aliases: info.aliases,
+			staleAliases: info.staleAliases,
+			currentPageId: info.currentPageId,
+			currentIndex: info.currentIndex,
+			currentUrl: info.url,
+			context
+		});
+	}
+	clearState() {
+		this.registry.clear();
+		return R.ok().build({ cleared: true });
+	}
+	async aliasBind(args) {
+		const alias = readRequiredString(args.alias);
+		const index = readAliasIndex(args.index);
+		if (!alias) return R.fail("alias is required").build();
+		if (index === null) return R.fail("index is required").build();
+		await this.reconcilePages();
+		const pageId = this.registry.bindAliasByIndex(alias, index);
+		if (!pageId) return R.fail(`No active page at index ${index}. Use browser_list_tabs to check available pages.`).build();
+		return R.ok().build({ bound: {
+			alias,
+			index,
+			pageId
+		} });
+	}
+	async aliasOpen(args) {
+		const alias = readRequiredString(args.alias);
+		const url = readRequiredString(args.url);
+		if (!alias) return R.fail("alias is required").build();
+		if (!url) return R.fail("url is required").build();
+		if (this.deps.getActiveDriver() === "camoufox") {
+			const currentPage = await this.deps.getCamoufoxPage();
+			if (!isCamoufoxPageLike(currentPage)) return R.fail("Cannot open new tab: camoufox page context not accessible").build();
+			const context = currentPage.context();
+			const newPage = await context.newPage();
+			await newPage.goto(url, { waitUntil: "domcontentloaded" });
+			const idx = context.pages().indexOf(newPage);
+			const pageTitle = await newPage.title();
+			const pageId = this.registry.registerPage(newPage, {
+				index: idx,
+				url: newPage.url(),
+				title: pageTitle
+			});
+			this.registry.bindAlias(alias, pageId);
+			return R.ok().build({
+				alias,
+				index: idx,
+				pageId,
+				url: newPage.url(),
+				title: pageTitle
+			});
+		}
+		const browser = await this.getBrowserFromController();
+		if (!browser) return R.fail("Cannot open new tab: browser instance not accessible via PageController").build();
+		const newPage = await browser.newPage();
+		await newPage.goto(url, { waitUntil: "domcontentloaded" });
+		const idx = (await browser.pages()).indexOf(newPage);
+		const pageTitle = await newPage.title();
+		const pageId = this.registry.registerPage(newPage, {
+			index: idx,
+			url: newPage.url(),
+			title: pageTitle
+		});
+		this.registry.bindAlias(alias, pageId);
+		return R.ok().build({
+			alias,
+			index: idx,
+			pageId,
+			url: newPage.url(),
+			title: pageTitle
+		});
+	}
+	async navigateAlias(args) {
+		const alias = readRequiredString(args.alias);
+		const url = readRequiredString(args.url);
+		if (!alias) return R.fail("alias is required").build();
+		if (!url) return R.fail("url is required").build();
+		const page = await this.getPageByAlias(alias);
+		if (!page) return R.fail(`No tab found for alias "${alias}". Use alias_bind or alias_open first.`).build();
+		await page.goto(url, { waitUntil: "domcontentloaded" });
+		return R.ok().build({
+			alias,
+			navigated: url,
+			currentUrl: page.url()
+		});
+	}
+	async waitFor(args) {
+		const alias = readRequiredString(args.alias);
+		const selector = readRequiredString(args.selector);
+		const text = readRequiredString(args.waitForText);
+		const timeoutMs = readTimeout(args.timeoutMs, 1e4);
+		if (!alias) return R.fail("alias is required").build();
+		if (!selector && !text) return R.fail("selector or waitForText is required").build();
+		const page = await this.getPageByAlias(alias);
+		if (!page) return R.fail(`No tab found for alias "${alias}"`).build();
+		if (selector) {
+			await page.waitForSelector(selector, { timeout: timeoutMs });
+			return R.ok().build({
+				alias,
+				waitedFor: selector,
+				found: true
+			});
+		}
+		const waitText = text;
+		const start = Date.now();
+		while (Date.now() - start < timeoutMs) {
+			const bodyTextValue = await page.evaluate(() => document.body.innerText);
+			if ((typeof bodyTextValue === "string" ? bodyTextValue : String(bodyTextValue ?? "")).includes(waitText)) return R.ok().build({
+				alias,
+				waitedForText: waitText,
+				found: true
+			});
+			await new Promise((r) => setTimeout(r, 500));
+		}
+		return R.fail(`Timeout waiting for text "${waitText}" in tab "${alias}"`).build();
+	}
+	contextSet(args) {
+		const key = readRequiredString(args.key);
+		const value = args.value;
+		if (!key) return R.fail("key is required").build();
+		this.registry.setSharedContext(key, value);
+		return R.ok().build({ set: {
+			key,
+			value
+		} });
+	}
+	contextGet(args) {
+		const key = readRequiredString(args.key);
+		if (!key) return R.fail("key is required").build();
+		const { value, found } = this.registry.getSharedContext(key);
+		return R.ok().build({
+			key,
+			value,
+			found
+		});
+	}
+	async transfer(args) {
+		const fromAlias = readRequiredString(args.fromAlias);
+		const key = readRequiredString(args.key);
+		const expression = readRequiredString(args.expression);
+		if (!fromAlias) return R.fail("fromAlias is required").build();
+		if (!key) return R.fail("key is required").build();
+		if (!expression) return R.fail("expression is required").build();
+		const page = await this.getPageByAlias(fromAlias);
+		if (!page) return R.fail(`No tab found for alias "${fromAlias}"`).build();
+		const value = await page.evaluate(expression);
+		this.registry.setSharedContext(key, value);
+		return R.ok().build({ transferred: {
+			fromAlias,
+			key,
+			value
+		} });
+	}
+	async getPageByAlias(alias) {
+		const pageId = this.registry.resolveAlias(alias);
+		if (!pageId) return null;
+		const page = this.registry.getPageById(pageId);
+		if (page && isTabPageLike(page)) return page;
+		await this.reconcilePages();
+		const retryPage = this.registry.getPageById(pageId);
+		if (retryPage && isTabPageLike(retryPage)) return retryPage;
+		return null;
+	}
+	async reconcilePages() {
+		if (this.deps.getActiveDriver() === "camoufox") {
+			const page = await this.deps.getCamoufoxPage();
+			if (isCamoufoxPageLike(page)) {
+				const pages = page.context().pages();
+				const meta = await Promise.all(pages.map(async (p, i) => ({
+					index: i,
+					url: p.url(),
+					title: await p.title()
+				})));
+				this.registry.reconcilePages(pages, meta);
+			}
+			return;
+		}
+		const browser = await this.getBrowserFromController();
+		if (!browser) return;
+		const pages = await browser.pages();
+		const meta = await Promise.all(pages.map(async (p, i) => ({
+			index: i,
+			url: p.url(),
+			title: await p.title()
+		})));
+		this.registry.reconcilePages(pages, meta);
+	}
+	async getBrowserFromController() {
+		const pc = this.deps.getPageController();
+		if (!isRecord(pc) || typeof pc.getBrowser !== "function") return null;
+		const browser = await pc.getBrowser();
+		return isBrowserLike(browser) ? browser : null;
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/jsdom-tools.ts
+/**
+* jsdom-tools.ts — Headless DOM analysis tools backed by the `jsdom` package.
+*
+* Provides 5 tools for offline HTML parsing, DOM querying, sandboxed script
+* execution, serialization and cookie management. Each call creates or
+* references a session keyed by UUID. Sessions auto-expire after
+* {@link SESSION_TTL_MS} of inactivity.
+*/
+const RUN_SCRIPTS_MODES = new Set([
+	"none",
+	"outside-only",
+	"dangerously"
+]);
+const COOKIE_ACTIONS = new Set([
+	"get",
+	"set",
+	"clear"
+]);
+/** Maximum HTML input size to prevent unbounded memory allocation. */
+const MAX_HTML_SIZE_BYTES = 10 * 1024 * 1024;
+/** Session lifetime in milliseconds. Configurable via env in future. */
+const SESSION_TTL_MS = 600 * 1e3;
+var JsdomHandlers = class {
+	sessions = /* @__PURE__ */ new Map();
+	createSessionId() {
+		return randomUUID();
+	}
+	scheduleExpiry(sessionId) {
+		const timer = setTimeout(() => {
+			logger.debug(`JSDOM session ${sessionId} expired after ${SESSION_TTL_MS}ms`);
+			this.closeSession(sessionId);
+		}, SESSION_TTL_MS);
+		timer.unref?.();
+		return timer;
+	}
+	refreshSessionExpiry(sessionId, session) {
+		clearTimeout(session.timer);
+		session.timer = this.scheduleExpiry(sessionId);
+	}
+	getSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (!session) throw new Error(`JSDOM session not found or expired: ${sessionId}`);
+		this.refreshSessionExpiry(sessionId, session);
+		return session;
+	}
+	closeSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (!session) return;
+		clearTimeout(session.timer);
+		try {
+			session.dom.window.close();
+		} catch (err) {
+			logger.debug(`JSDOM window close error: ${String(err)}`);
+		}
+		this.sessions.delete(sessionId);
+	}
+	/** Close all active sessions. Called on server shutdown. */
+	closeAll() {
+		for (const id of Array.from(this.sessions.keys())) this.closeSession(id);
+	}
+	async handleJsdomParse(args) {
+		try {
+			const html = argStringRequired(args, "html");
+			if (Buffer.byteLength(html, "utf8") > MAX_HTML_SIZE_BYTES) return R.fail(`HTML input exceeds ${MAX_HTML_SIZE_BYTES / 1024 / 1024}MB limit. Provide smaller HTML or use a URL.`).build();
+			const url = argString(args, "url", "about:blank");
+			const contentType = argString(args, "contentType", "text/html");
+			const runScripts = argEnum(args, "runScripts", RUN_SCRIPTS_MODES, "none");
+			const includeNodeLocations = argBool(args, "includeNodeLocations", false);
+			const pretendToBeVisual = argBool(args, "pretendToBeVisual", false);
+			const referrer = argString(args, "referrer", "");
+			const options = {
+				url,
+				contentType,
+				includeNodeLocations,
+				pretendToBeVisual,
+				storageQuota: argNumber(args, "storageQuotaBytes", 1e6)
+			};
+			if (runScripts !== "none") options.runScripts = runScripts;
+			if (referrer) options.referrer = referrer;
+			const { JSDOM } = await import("jsdom");
+			const dom = new JSDOM(html, options);
+			const sessionId = this.createSessionId();
+			const session = {
+				dom,
+				url,
+				runScripts,
+				includeNodeLocations,
+				createdAt: Date.now(),
+				timer: this.scheduleExpiry(sessionId)
+			};
+			this.sessions.set(sessionId, session);
+			const doc = dom.window.document;
+			return R.ok().set("sessionId", sessionId).set("title", doc.title || "").set("url", url).set("contentType", contentType).set("runScripts", runScripts).set("ttlMs", SESSION_TTL_MS).set("activeSessions", this.sessions.size).set("stats", {
+				elements: doc.getElementsByTagName("*").length,
+				scripts: doc.getElementsByTagName("script").length,
+				links: doc.getElementsByTagName("a").length,
+				images: doc.getElementsByTagName("img").length,
+				stylesheets: doc.querySelectorAll("link[rel=\"stylesheet\"], style").length
+			}).build();
+		} catch (error) {
+			return R.fail(error).build();
+		}
+	}
+	async handleJsdomQuery(args) {
+		try {
+			const sessionId = argStringRequired(args, "sessionId");
+			const selector = argStringRequired(args, "selector");
+			const maxResults = argNumber(args, "maxResults", 50);
+			const includeHtml = argBool(args, "includeHtml", false);
+			const includeText = argBool(args, "includeText", true);
+			const includeLocation = argBool(args, "includeLocation", false);
+			const attributes = argStringArray(args, "attributes");
+			const session = this.getSession(sessionId);
+			const doc = session.dom.window.document;
+			const all = Array.from(doc.querySelectorAll(selector));
+			const results = all.slice(0, maxResults).map((el) => {
+				const item = { tag: el.tagName.toLowerCase() };
+				if (attributes.length > 0) {
+					const picked = {};
+					for (const name of attributes) picked[name] = el.getAttribute(name);
+					item.attributes = picked;
+				} else {
+					const full = {};
+					for (const attr of Array.from(el.attributes)) full[attr.name] = attr.value;
+					item.attributes = full;
+				}
+				if (includeText) item.text = (el.textContent ?? "").trim();
+				if (includeHtml) item.html = el.outerHTML;
+				if (includeLocation && session.includeNodeLocations) try {
+					item.location = session.dom.nodeLocation(el) ?? null;
+				} catch {
+					item.location = null;
+				}
+				return item;
+			});
+			return R.ok().set("sessionId", sessionId).set("selector", selector).set("matched", all.length).set("returned", results.length).set("results", results).build();
+		} catch (error) {
+			return R.fail(error).build();
+		}
+	}
+	async handleJsdomExecute(args) {
+		try {
+			const sessionId = argStringRequired(args, "sessionId");
+			const code = argStringRequired(args, "code");
+			const timeoutHintMs = argNumber(args, "timeoutMs", 5e3);
+			const session = this.getSession(sessionId);
+			if (session.runScripts === "none") return R.fail("JSDOM session was created with runScripts=\"none\". Re-parse with runScripts=\"outside-only\" or \"dangerously\" to execute code.").build();
+			const logs = [];
+			const window = session.dom.window;
+			const originalConsole = window.console;
+			window.console = createCapturingConsole(originalConsole, logs);
+			let result;
+			let errorMessage = null;
+			try {
+				result = window.eval(code);
+			} catch (err) {
+				errorMessage = err instanceof Error ? err.message : String(err);
+			} finally {
+				window.console = originalConsole;
+			}
+			if (errorMessage !== null) return R.fail(errorMessage).set("consoleLogs", logs).build();
+			return R.ok().set("sessionId", sessionId).set("result", safeSerialize(result)).set("consoleLogs", logs).set("timeoutHintMs", timeoutHintMs).build();
+		} catch (error) {
+			return R.fail(error).build();
+		}
+	}
+	async handleJsdomSerialize(args) {
+		try {
+			const sessionId = argStringRequired(args, "sessionId");
+			const pretty = argBool(args, "pretty", false);
+			const fragment = argString(args, "selector", "");
+			const session = this.getSession(sessionId);
+			let html;
+			if (fragment) {
+				const element = session.dom.window.document.querySelector(fragment);
+				if (!element) return R.fail(`No element matches selector: ${fragment}`).build();
+				html = element.outerHTML;
+			} else html = session.dom.serialize();
+			if (pretty) html = prettyPrintHtml(html);
+			return R.ok().set("sessionId", sessionId).set("bytes", Buffer.byteLength(html, "utf8")).set("pretty", pretty).set("html", html).build();
+		} catch (error) {
+			return R.fail(error).build();
+		}
+	}
+	async handleJsdomCookies(args) {
+		try {
+			const sessionId = argStringRequired(args, "sessionId");
+			const action = argEnum(args, "action", COOKIE_ACTIONS, "get");
+			const session = this.getSession(sessionId);
+			const jar = session.dom.cookieJar;
+			const cookieUrl = argString(args, "url", session.url);
+			if (action === "get") {
+				const cookies = await jar.getCookies(cookieUrl);
+				return R.ok().set("sessionId", sessionId).set("url", cookieUrl).set("cookies", cookies.map(serializeCookie)).build();
+			}
+			if (action === "set") {
+				const cookie = argObject(args, "cookie");
+				if (!cookie) return R.fail("cookie object required for action=\"set\"").build();
+				const cookieStr = typeof cookie.raw === "string" ? cookie.raw : buildCookieString(cookie);
+				await jar.setCookie(cookieStr, cookieUrl);
+				return R.ok().set("sessionId", sessionId).set("action", "set").set("cookie", cookieStr).build();
+			}
+			const store = jar.store;
+			if (store && typeof store.removeAllCookies === "function") await new Promise((resolve, reject) => store.removeAllCookies((err) => err ? reject(err) : resolve()));
+			return R.ok().set("sessionId", sessionId).set("action", "clear").build();
+		} catch (error) {
+			return R.fail(error).build();
+		}
+	}
+};
+function serializeCookie(c) {
+	return {
+		key: c.key ?? "",
+		value: c.value ?? "",
+		domain: c.domain ?? null,
+		path: c.path ?? null,
+		expires: c.expires instanceof Date ? c.expires.toISOString() : c.expires ?? null,
+		httpOnly: c.httpOnly === true,
+		secure: c.secure === true,
+		sameSite: c.sameSite ?? null
+	};
+}
+function buildCookieString(cookie) {
+	const name = String(cookie.name ?? cookie.key ?? "");
+	const value = String(cookie.value ?? "");
+	if (!name) throw new Error("cookie.name (or cookie.key) is required");
+	const parts = [`${name}=${value}`];
+	if (typeof cookie.domain === "string") parts.push(`Domain=${cookie.domain}`);
+	if (typeof cookie.path === "string") parts.push(`Path=${cookie.path}`);
+	if (typeof cookie.expires === "string") parts.push(`Expires=${cookie.expires}`);
+	if (typeof cookie.maxAge === "number") parts.push(`Max-Age=${cookie.maxAge}`);
+	if (cookie.secure === true) parts.push("Secure");
+	if (cookie.httpOnly === true) parts.push("HttpOnly");
+	if (typeof cookie.sameSite === "string") parts.push(`SameSite=${cookie.sameSite}`);
+	return parts.join("; ");
+}
+function createCapturingConsole(original, logs) {
+	const levels = [
+		"log",
+		"info",
+		"warn",
+		"error",
+		"debug",
+		"trace"
+	];
+	const proxy = {};
+	for (const level of levels) proxy[level] = (...callArgs) => {
+		logs.push({
+			level,
+			args: callArgs.map((x) => safeSerialize(x))
+		});
+		const orig = original?.[level];
+		if (typeof orig === "function") try {
+			orig.apply(original, callArgs);
+		} catch {}
+	};
+	return proxy;
+}
+function safeSerialize(value) {
+	if (value === null || value === void 0) return value;
+	const t = typeof value;
+	if (t === "string" || t === "number" || t === "boolean") return value;
+	if (t === "bigint") return `${value.toString()}n`;
+	if (t === "function") return `[Function: ${value.name || "anonymous"}]`;
+	if (t === "symbol") return String(value);
+	try {
+		return JSON.parse(JSON.stringify(value));
+	} catch {
+		return String(value);
+	}
+}
+function prettyPrintHtml(html) {
+	return html.replace(/>(?=<)/g, ">\n");
+}
+//#endregion
+//#region src/modules/browser/TabRegistry.ts
+/**
+* TabRegistry — unified tab/page state for all browser tools.
+*
+* Replaces the fragmented model where tab_workflow kept its own alias→index map
+* and browser_control used collector.listPages()/selectPage() independently.
+*
+* Key properties:
+* - pageId is session-stable (survives tab open/close of other tabs)
+* - Alias binds to pageId, not index
+* - Stale detection when a previously registered page disappears
+* - Single source of truth for "current page"
+*/
+let globalIdCounter = 0;
+var TabRegistry = class {
+	pageIdByHandle = /* @__PURE__ */ new WeakMap();
+	tabsById = /* @__PURE__ */ new Map();
+	aliasToPageId = /* @__PURE__ */ new Map();
+	currentPageId = null;
+	sharedContext = /* @__PURE__ */ new Map();
+	/**
+	* Register a page and get a stable pageId.
+	* If the page object was previously registered, returns its existing pageId.
+	*/
+	registerPage(page, meta) {
+		const handle = page;
+		const existingId = this.pageIdByHandle.get(handle);
+		if (existingId) {
+			const existing = this.tabsById.get(existingId);
+			if (existing) {
+				existing.meta = meta;
+				existing.stale = false;
+			} else this.tabsById.set(existingId, {
+				page,
+				meta,
+				stale: false
+			});
+			return existingId;
+		}
+		globalIdCounter += 1;
+		const pageId = `tab-${globalIdCounter}`;
+		this.pageIdByHandle.set(handle, pageId);
+		this.tabsById.set(pageId, {
+			page,
+			meta,
+			stale: false
+		});
+		logger.debug(`[TabRegistry] Registered page ${pageId} (index=${meta.index}, url=${meta.url})`);
+		return pageId;
+	}
+	/**
+	* Reconcile the registry with a fresh pages list.
+	* - New pages get registered
+	* - Missing pages get marked stale
+	* - Index updates are applied
+	* Returns the full tab list.
+	*/
+	reconcilePages(pages, metaList) {
+		const activeIds = /* @__PURE__ */ new Set();
+		for (let i = 0; i < pages.length; i++) {
+			const page = pages[i];
+			const meta = metaList[i] ?? {
+				index: i,
+				url: "",
+				title: ""
+			};
+			const pageId = this.registerPage(page, {
+				...meta,
+				index: i
+			});
+			activeIds.add(pageId);
+		}
+		for (const [pageId, entry] of this.tabsById) if (!activeIds.has(pageId) && !entry.stale) {
+			entry.stale = true;
+			logger.debug(`[TabRegistry] Page ${pageId} marked stale`);
+		}
+		if (this.currentPageId && !activeIds.has(this.currentPageId)) {
+			logger.debug(`[TabRegistry] Current page ${this.currentPageId} is stale, clearing`);
+			this.currentPageId = null;
+		}
+		return this.listTabs();
+	}
+	/** Bind an alias to a pageId. */
+	bindAlias(alias, pageId) {
+		if (!this.tabsById.has(pageId)) return false;
+		this.aliasToPageId.set(alias, pageId);
+		return true;
+	}
+	/** Bind an alias to a page by its current index. */
+	bindAliasByIndex(alias, index) {
+		for (const [pageId, entry] of this.tabsById) if (entry.meta.index === index && !entry.stale) {
+			this.aliasToPageId.set(alias, pageId);
+			return pageId;
+		}
+		return null;
+	}
+	/** Remove an alias binding. */
+	unbindAlias(alias) {
+		return this.aliasToPageId.delete(alias);
+	}
+	/** Resolve an alias to its pageId. Returns null if alias not found or page is stale. */
+	resolveAlias(alias) {
+		const pageId = this.aliasToPageId.get(alias);
+		if (!pageId) return null;
+		const entry = this.tabsById.get(pageId);
+		if (!entry || entry.stale) return null;
+		return pageId;
+	}
+	/** Get the page object by pageId. Returns null if not found or stale. */
+	getPageById(pageId) {
+		const entry = this.tabsById.get(pageId);
+		if (!entry || entry.stale) return null;
+		return entry.page;
+	}
+	/** Get full tab descriptor by pageId. */
+	getTabById(pageId) {
+		const entry = this.tabsById.get(pageId);
+		if (!entry) return null;
+		const aliases = this.getAliasesForPageId(pageId);
+		return {
+			pageId,
+			index: entry.meta.index,
+			url: entry.meta.url,
+			title: entry.meta.title,
+			page: entry.page,
+			aliases,
+			stale: entry.stale
+		};
+	}
+	/** Get tab by current index. */
+	getTabByIndex(index) {
+		for (const [pageId, entry] of this.tabsById) if (entry.meta.index === index && !entry.stale) return this.getTabById(pageId);
+		return null;
+	}
+	/** Find a tab matching a predicate. */
+	findTab(predicate) {
+		for (const [pageId] of this.tabsById) {
+			const tab = this.getTabById(pageId);
+			if (tab && predicate(tab)) return tab;
+		}
+		return null;
+	}
+	/** Set the current page by pageId. */
+	setCurrentPageId(pageId) {
+		const entry = this.tabsById.get(pageId);
+		if (!entry || entry.stale) return false;
+		this.currentPageId = pageId;
+		return true;
+	}
+	/** Set the current page by index. Returns the tab descriptor or null. */
+	setCurrentByIndex(index) {
+		const tab = this.getTabByIndex(index);
+		if (tab) this.currentPageId = tab.pageId;
+		return tab;
+	}
+	/** Get the current pageId. */
+	getCurrentPageId() {
+		return this.currentPageId;
+	}
+	/** Get current page object. */
+	getCurrentPage() {
+		if (!this.currentPageId) return null;
+		return this.getPageById(this.currentPageId);
+	}
+	/** Get full info about the current tab, suitable for tool responses. */
+	getCurrentTabInfo(driver) {
+		const allAliases = [];
+		const staleAliases = [];
+		for (const [alias, pageId] of this.aliasToPageId) {
+			const entry = this.tabsById.get(pageId);
+			const stale = !entry || entry.stale;
+			allAliases.push({
+				alias,
+				pageId,
+				index: entry?.meta.index ?? null,
+				stale
+			});
+			if (stale) staleAliases.push(alias);
+		}
+		const currentEntry = this.currentPageId ? this.tabsById.get(this.currentPageId) : null;
+		const current = currentEntry && !currentEntry.stale ? currentEntry : null;
+		return {
+			driver,
+			currentPageId: current ? this.currentPageId : null,
+			currentIndex: current?.meta.index ?? null,
+			url: current?.meta.url ?? null,
+			title: current?.meta.title ?? null,
+			aliases: allAliases,
+			staleAliases
+		};
+	}
+	/** Get a compact context snapshot for tool response enrichment. */
+	getContextMeta() {
+		const currentEntry = this.currentPageId ? this.tabsById.get(this.currentPageId) : null;
+		const current = currentEntry && !currentEntry.stale ? currentEntry : null;
+		return {
+			url: current?.meta.url ?? null,
+			title: current?.meta.title ?? null,
+			tabIndex: current?.meta.index ?? null,
+			pageId: current ? this.currentPageId : null
+		};
+	}
+	/** List all non-stale tabs. */
+	listTabs() {
+		const result = [];
+		for (const [pageId, entry] of this.tabsById) if (!entry.stale) {
+			const aliases = this.getAliasesForPageId(pageId);
+			result.push({
+				pageId,
+				index: entry.meta.index,
+				url: entry.meta.url,
+				title: entry.meta.title,
+				page: entry.page,
+				aliases,
+				stale: false
+			});
+		}
+		return result.toSorted((a, b) => a.index - b.index);
+	}
+	/** List all tabs including stale ones. */
+	listAllTabs() {
+		const result = [];
+		for (const [pageId, entry] of this.tabsById) {
+			const aliases = this.getAliasesForPageId(pageId);
+			result.push({
+				pageId,
+				index: entry.meta.index,
+				url: entry.meta.url,
+				title: entry.meta.title,
+				page: entry.page,
+				aliases,
+				stale: entry.stale
+			});
+		}
+		return result.toSorted((a, b) => a.index - b.index);
+	}
+	setSharedContext(key, value) {
+		this.sharedContext.set(key, value);
+	}
+	getSharedContext(key) {
+		return {
+			value: this.sharedContext.get(key) ?? null,
+			found: this.sharedContext.has(key)
+		};
+	}
+	getSharedContextMap() {
+		const result = {};
+		this.sharedContext.forEach((v, k) => {
+			result[k] = v;
+		});
+		return result;
+	}
+	/** Clear all state. */
+	clear() {
+		this.tabsById.clear();
+		this.aliasToPageId.clear();
+		this.sharedContext.clear();
+		this.currentPageId = null;
+	}
+	getAliasesForPageId(pageId) {
+		const aliases = [];
+		for (const [alias, pid] of this.aliasToPageId) if (pid === pageId) aliases.push(alias);
+		return aliases;
+	}
+};
+//#endregion
+//#region src/server/domains/browser/handlers/facade-initializer.ts
+function initializeBrowserHandlerModules(deps) {
+	const commonDeps = {
+		getActiveDriver: deps.getActiveDriver,
+		getCamoufoxPage: deps.getCamoufoxPage
+	};
+	const tabRegistry = new TabRegistry();
+	const targetControl = new TargetControlHandlers({
+		collector: deps.collector,
+		consoleMonitor: deps.consoleMonitor,
+		getTabRegistry: () => tabRegistry
+	});
+	return {
+		tabRegistry,
+		targetControl,
+		browserControl: new BrowserControlHandlers({
+			collector: deps.collector,
+			pageController: deps.pageController,
+			consoleMonitor: deps.consoleMonitor,
+			getActiveDriver: deps.getActiveDriver,
+			getCamoufoxManager: deps.getCamoufoxManager,
+			getCamoufoxPage: deps.getCamoufoxPage,
+			getTabRegistry: () => tabRegistry,
+			clearAttachedTargetContext: (context) => targetControl.clearAttachedTargetContext(context)
+		}),
+		camoufoxBrowser: new CamoufoxBrowserHandlers({
+			getCamoufoxManager: deps.getCamoufoxManager,
+			setCamoufoxManager: deps.setCamoufoxManager,
+			closeCamoufox: deps.closeCamoufox
+		}),
+		pageNavigation: new PageNavigationHandlers({
+			pageController: deps.pageController,
+			consoleMonitor: deps.consoleMonitor,
+			eventBus: deps.eventBus,
+			...commonDeps
+		}),
+		pageInteraction: new PageInteractionHandlers({
+			pageController: deps.pageController,
+			...commonDeps
+		}),
+		pageEvaluation: new PageEvaluationHandlers({
+			pageController: deps.pageController,
+			detailedDataManager: deps.detailedDataManager,
+			...commonDeps
+		}),
+		targetEvaluation: new TargetEvaluationHandlers({
+			pageController: deps.pageController,
+			detailedDataManager: deps.detailedDataManager
+		}),
+		pageData: new PageDataHandlers({
+			pageController: deps.pageController,
+			...commonDeps
+		}),
+		consoleHandlers: new ConsoleHandlers({
+			consoleMonitor: deps.consoleMonitor,
+			detailedDataManager: deps.detailedDataManager
+		}),
+		scriptManagement: new ScriptManagementHandlers({
+			scriptManager: deps.scriptManager,
+			detailedDataManager: deps.detailedDataManager
+		}),
+		captchaHandlers: new CaptchaHandlers({
+			pageController: deps.pageController,
+			captchaDetector: deps.captchaDetector,
+			autoDetectCaptcha: deps.getAutoDetectCaptcha(),
+			autoSwitchHeadless: deps.getAutoSwitchHeadless(),
+			captchaTimeout: deps.getCaptchaTimeout(),
+			setAutoDetectCaptcha: deps.setAutoDetectCaptcha,
+			setAutoSwitchHeadless: deps.setAutoSwitchHeadless,
+			setCaptchaTimeout: deps.setCaptchaTimeout
+		}),
+		stealthInjection: new StealthInjectionHandlers({
+			pageController: deps.pageController,
+			...commonDeps
+		}),
+		frameworkState: new FrameworkStateHandlers({ getActivePage: () => deps.collector.getActivePage() }),
+		indexedDBDump: new IndexedDBDumpHandlers({ getActivePage: () => deps.collector.getActivePage() }),
+		jsHeapSearch: new JSHeapSearchHandlers({
+			getActivePage: () => deps.collector.getActivePage(),
+			getActiveDriver: deps.getActiveDriver
+		}),
+		tabWorkflow: new TabWorkflowHandlers({
+			getActiveDriver: deps.getActiveDriver,
+			getCamoufoxPage: deps.getCamoufoxPage,
+			getPageController: () => deps.pageController,
+			getTabRegistry: () => tabRegistry
+		}),
+		detailedData: new DetailedDataHandlers({ detailedDataManager: deps.detailedDataManager }),
+		jsdomHandlers: new JsdomHandlers()
+	};
+}
+//#endregion
+//#region src/server/domains/browser/handlers/human-behavior.ts
+/** Cubic Bezier: P(t) = (1-t)^3·P0 + 3(1-t)^2·t·P1 + 3(1-t)·t^2·P2 + t^3·P3 */
+function cubicBezier(p0, p1, p2, p3, t) {
+	const u = 1 - t;
+	const uu = u * u;
+	const uuu = uu * u;
+	const tt = t * t;
+	const ttt = tt * t;
+	return {
+		x: uuu * p0.x + 3 * uu * t * p1.x + 3 * u * tt * p2.x + ttt * p3.x,
+		y: uuu * p0.y + 3 * uu * t * p1.y + 3 * u * tt * p2.y + ttt * p3.y
+	};
+}
+/** Generate control points with lateral offset for natural curve feel. */
+function generateControlPoints(from, to) {
+	const dx = to.x - from.x;
+	const dy = to.y - from.y;
+	const perpX = -dy;
+	const perpY = dx;
+	const len = Math.sqrt(perpX * perpX + perpY * perpY) || 1;
+	const offset1 = (Math.random() - .5) * .4;
+	const offset2 = (Math.random() - .5) * .4;
+	return [{
+		x: from.x + dx * .3 + perpX / len * Math.abs(dx + dy) * offset1,
+		y: from.y + dy * .3 + perpY / len * Math.abs(dx + dy) * offset1
+	}, {
+		x: from.x + dx * .7 + perpX / len * Math.abs(dx + dy) * offset2,
+		y: from.y + dy * .7 + perpY / len * Math.abs(dx + dy) * offset2
+	}];
+}
+/** Easing functions for speed curves. */
+function easeT(t, curve) {
+	switch (curve) {
+		case "linear": return t;
+		case "ease-in": return t * t;
+		case "ease-out": return 1 - (1 - t) * (1 - t);
+		default: return t < .5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+	}
+}
+function sleep$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function handleHumanMouse(args, collector) {
+	try {
+		const page = await collector.getActivePage();
+		if (!page) return R.fail("No active page. Use browser_launch or browser_attach first.").build();
+		let toX = argNumber(args, "toX");
+		let toY = argNumber(args, "toY");
+		const selector = argString(args, "selector");
+		if (selector) {
+			const box = await page.evaluate((sel) => {
+				const el = document.querySelector(sel);
+				if (!el) return null;
+				const rect = el.getBoundingClientRect();
+				return {
+					x: rect.x + rect.width / 2,
+					y: rect.y + rect.height / 2
+				};
+			}, selector);
+			if (!box) return R.fail(`Selector not found: ${selector}`).build();
+			toX = box.x;
+			toY = box.y;
+		}
+		if (toX === void 0 || toY === void 0) return R.fail("Either selector or toX/toY coordinates are required").build();
+		const fromX = argNumber(args, "fromX", 0);
+		const fromY = argNumber(args, "fromY", 0);
+		const steps = Math.max(1, Math.min(argNumber(args, "steps", 24), 500));
+		const durationMs = Math.max(10, Math.min(argNumber(args, "durationMs", 600), 3e4));
+		const jitterPx = Math.max(0, Math.min(argNumber(args, "jitterPx", 1.5), 20));
+		const curve = argString(args, "curve", "ease");
+		const shouldClick = argBool(args, "click", false);
+		const from = {
+			x: fromX,
+			y: fromY
+		};
+		const to = {
+			x: toX,
+			y: toY
+		};
+		const [cp1, cp2] = generateControlPoints(from, to);
+		const stepDelay = durationMs / steps;
+		for (let i = 0; i <= steps; i++) {
+			const pt = cubicBezier(from, cp1, cp2, to, easeT(i / steps, curve));
+			if (i > 0 && i < steps) {
+				pt.x += (Math.random() - .5) * 2 * jitterPx;
+				pt.y += (Math.random() - .5) * 2 * jitterPx;
+			}
+			pt.x = Math.max(0, pt.x);
+			pt.y = Math.max(0, pt.y);
+			await page.mouse.move(pt.x, pt.y);
+			await sleep$1(stepDelay * (.8 + Math.random() * .4));
+		}
+		if (shouldClick) await page.mouse.click(toX, toY);
+		return R.ok().build({
+			from: {
+				x: fromX,
+				y: fromY
+			},
+			to: {
+				x: toX,
+				y: toY
+			},
+			steps,
+			durationMs,
+			clicked: shouldClick
+		});
+	} catch (e) {
+		return R.fail(e).build();
+	}
+}
+async function handleHumanScroll(args, collector) {
+	try {
+		const page = await collector.getActivePage();
+		if (!page) return R.fail("No active page.").build();
+		const distance = Math.max(1, Math.min(argNumber(args, "distance", 500), 1e4));
+		const direction = argString(args, "direction", "down");
+		const durationMs = Math.max(10, Math.min(argNumber(args, "durationMs", 1500), 3e4));
+		const segments = Math.max(1, Math.min(argNumber(args, "segments", 8), 200));
+		const pauseMs = typeof args["pauseMs"] === "number" && Number.isFinite(args["pauseMs"]) ? Math.max(0, Math.min(argNumber(args, "pauseMs", 80), 5e3)) : Math.max(0, Math.min(Math.round(durationMs / segments), 5e3));
+		const jitter = Math.max(0, Math.min(argNumber(args, "jitter", .3), 1));
+		const selector = argString(args, "selector");
+		const isVertical = direction === "up" || direction === "down";
+		const sign = direction === "down" || direction === "right" ? 1 : -1;
+		let scrolled = 0;
+		for (let i = 0; i < segments; i++) {
+			const decel = 1 - i / segments * .4;
+			const segmentDist = distance / segments * decel * (1 + (Math.random() - .5) * jitter * 2);
+			const actualDist = Math.min(segmentDist, distance - scrolled);
+			if (actualDist <= 0) break;
+			const deltaX = isVertical ? 0 : actualDist * sign;
+			const deltaY = isVertical ? actualDist * sign : 0;
+			if (selector) await page.evaluate((sel, dx, dy) => {
+				const el = document.querySelector(sel);
+				if (el) el.scrollBy({
+					left: dx,
+					top: dy,
+					behavior: "auto"
+				});
+			}, selector, deltaX, deltaY);
+			else await page.evaluate((dx, dy) => window.scrollBy({
+				left: dx,
+				top: dy,
+				behavior: "auto"
+			}), deltaX, deltaY);
+			scrolled += actualDist;
+			await sleep$1(pauseMs * (.5 + Math.random()));
+		}
+		return R.ok().build({
+			direction,
+			requestedDistance: distance,
+			actualScrolled: Math.round(scrolled),
+			durationMs,
+			pauseMs,
+			segments
+		});
+	} catch (e) {
+		return R.fail(e).build();
+	}
+}
+async function handleHumanTyping(args, collector) {
+	try {
+		const page = await collector.getActivePage();
+		if (!page) return R.fail("No active page.").build();
+		const selector = argString(args, "selector", "");
+		const text = argString(args, "text", "");
+		const wpm = Math.max(10, Math.min(argNumber(args, "wpm", 90), 300));
+		const errorRate = Math.max(0, Math.min(argNumber(args, "errorRate", .02), .3));
+		const correctDelayMs = Math.max(50, Math.min(argNumber(args, "correctDelayMs", 200), 2e3));
+		const clearFirst = argBool(args, "clearFirst", false);
+		if (!selector || !text) return R.fail("selector and text are required").build();
+		const avgDelayMs = 6e4 / (wpm * 5);
+		await page.click(selector);
+		if (clearFirst) await page.evaluate((sel) => {
+			const el = document.querySelector(sel);
+			if (el) el.value = "";
+		}, selector);
+		let typoCount = 0;
+		for (const char of text) {
+			if (Math.random() < errorRate && char !== " ") {
+				const wrongChar = String.fromCharCode(char.charCodeAt(0) + (Math.random() > .5 ? 1 : -1));
+				await page.keyboard.type(wrongChar, { delay: 0 });
+				await sleep$1(correctDelayMs * (.5 + Math.random()));
+				await page.keyboard.press("Backspace");
+				await sleep$1(50 + Math.random() * 50);
+				typoCount++;
+			}
+			await page.keyboard.type(char, { delay: 0 });
+			let delay = avgDelayMs * (.5 + Math.random());
+			if (char === " " || ".,:;!?".includes(char)) delay *= 1.5 + Math.random() * .5;
+			await sleep$1(delay);
+		}
+		return R.ok().build({
+			selector,
+			length: text.length,
+			wpm,
+			typosSimulated: typoCount,
+			errorRate
+		});
+	} catch (e) {
+		return R.fail(e).build();
+	}
+}
+//#endregion
+//#region src/server/domains/browser/handlers/captcha-solver.ts
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeSolverMode(rawMode) {
+	const value = typeof rawMode === "string" ? rawMode.toLowerCase() : "";
+	if (value === "hook") return "hook";
+	if (value === "external_service") return "external_service";
+	if (value === "2captcha" || value === "anticaptcha" || value === "capsolver") return "external_service";
+	return "manual";
+}
+function normalizeChallengeTypeHint(rawType) {
+	const value = typeof rawType === "string" ? rawType.toLowerCase() : "";
+	if (value === "image") return "image";
+	if (value === "widget" || value === "recaptcha_v2" || value === "recaptcha_v3" || value === "hcaptcha" || value === "funcaptcha" || value === "turnstile") return "widget";
+	if (value === "browser_check" || value === "managed_widget") return "browser_check";
+	return "auto";
+}
+function resolveLegacyServiceOverride(rawProvider) {
+	if (typeof rawProvider !== "string" || !rawProvider.trim()) return;
+	return rawProvider.trim().toLowerCase();
+}
+function resolveExternalServiceName(args) {
+	const legacyOverride = resolveLegacyServiceOverride(args.provider);
+	const configured = (process.env.CAPTCHA_PROVIDER || "").trim().toLowerCase();
+	return legacyOverride || configured || "2captcha";
+}
+async function solveWith2Captcha(apiKey, params, timeoutMs) {
+	const start = Date.now();
+	const baseUrl = CAPTCHA_SOLVER_BASE_URL;
+	if (!baseUrl) throw new Error("CAPTCHA_SOLVER_BASE_URL must be configured before using external_service mode.");
+	const submitBody = {
+		key: apiKey,
+		json: 1
+	};
+	if (params.taskKind === "turnstile" || params.taskKind === "recaptcha_v2" || params.taskKind === "hcaptcha") {
+		submitBody.method = params.taskKind === "turnstile" ? "turnstile" : params.taskKind === "hcaptcha" ? "hcaptcha" : "userrecaptcha";
+		submitBody.sitekey = params.siteKey;
+		submitBody.pageurl = params.pageUrl;
+	} else {
+		submitBody.method = "base64";
+		submitBody.body = params.imageBase64;
+	}
+	const submitData = await (await fetch(`${baseUrl}/in.php`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(submitBody),
+		signal: AbortSignal.timeout(CAPTCHA_SUBMIT_TIMEOUT_MS)
+	})).json();
+	if (submitData.status !== 1) throw new Error(`2captcha submit failed: ${JSON.stringify(submitData)}`);
+	const taskId = submitData.request;
+	const pollInterval = CAPTCHA_POLL_INTERVAL_MS;
+	while (true) {
+		const remaining = timeoutMs - (Date.now() - start);
+		if (remaining <= 0) break;
+		await sleep(Math.min(pollInterval, remaining));
+		if (Date.now() - start >= timeoutMs) break;
+		const resultUrl = new URL(`${baseUrl}/res.php`);
+		resultUrl.searchParams.set("key", apiKey);
+		resultUrl.searchParams.set("action", "get");
+		resultUrl.searchParams.set("id", taskId);
+		resultUrl.searchParams.set("json", "1");
+		const resultData = await (await fetch(resultUrl.toString(), { signal: AbortSignal.timeout(CAPTCHA_RESULT_TIMEOUT_MS) })).json();
+		if (resultData.status === 1) return {
+			token: resultData.request,
+			challengeType: params.taskKind === "image" ? "image" : "widget",
+			mode: "external_service",
+			durationMs: Date.now() - start
+		};
+		if (resultData.request !== "CAPCHA_NOT_READY") throw new Error(`2captcha solve failed: ${JSON.stringify(resultData)}`);
+	}
+	throw new Error(`2captcha solve timeout after ${timeoutMs}ms`);
+}
+async function handleCaptchaVisionSolve(args, collector) {
+	const page = await collector.getActivePage();
+	if (!page) return R.fail("No active page.").build();
+	const mode = normalizeSolverMode(args.mode ?? args.provider ?? process.env.CAPTCHA_PROVIDER);
+	const externalService = resolveExternalServiceName(args);
+	const apiKey = argString(args, "apiKey", "") || process.env.CAPTCHA_API_KEY || "";
+	const challengeTypeHint = normalizeChallengeTypeHint(args.challengeType ?? args.typeHint);
+	const timeoutMs = Math.min(Math.max(argNumber(args, "timeoutMs", CAPTCHA_DEFAULT_TIMEOUT_MS), CAPTCHA_MIN_TIMEOUT_MS), CAPTCHA_MAX_TIMEOUT_MS);
+	const maxRetries = Math.min(Math.max(argNumber(args, "maxRetries", CAPTCHA_DEFAULT_RETRIES), 0), CAPTCHA_MAX_RETRIES);
+	let challengeType = challengeTypeHint;
+	let taskKind = challengeTypeHint === "image" ? "image" : "recaptcha_v2";
+	let siteKey = argString(args, "siteKey");
+	const pageUrl = argString(args, "pageUrl", "") || page.url();
+	if (challengeType === "auto") {
+		const detected = await page.evaluate(() => {
+			if (document.querySelector("[data-sitekey]")) {
+				const sk = document.querySelector("[data-sitekey]")?.getAttribute("data-sitekey") || "";
+				if (document.querySelector(".cf-turnstile")) return {
+					challengeType: "widget",
+					taskKind: "turnstile",
+					siteKey: sk
+				};
+				if (document.querySelector(".h-captcha")) return {
+					challengeType: "widget",
+					taskKind: "hcaptcha",
+					siteKey: sk
+				};
+				return {
+					challengeType: "widget",
+					taskKind: "recaptcha_v2",
+					siteKey: sk
+				};
+			}
+			if (document.querySelector("iframe[src*=\"recaptcha\"]")) return {
+				challengeType: "widget",
+				taskKind: "recaptcha_v2",
+				siteKey: ""
+			};
+			if (document.querySelector("iframe[src*=\"hcaptcha\"]")) return {
+				challengeType: "widget",
+				taskKind: "hcaptcha",
+				siteKey: ""
+			};
+			if (document.querySelector(".cf-turnstile")) return {
+				challengeType: "widget",
+				taskKind: "turnstile",
+				siteKey: ""
+			};
+			return {
+				challengeType: "image",
+				taskKind: "image",
+				siteKey: ""
+			};
+		});
+		challengeType = detected.challengeType;
+		taskKind = detected.taskKind;
+		if (!siteKey && detected.siteKey) siteKey = detected.siteKey;
+	} else if (challengeType === "image") taskKind = "image";
+	else taskKind = "recaptcha_v2";
+	if (mode === "manual") return R.ok().build({
+		mode: "manual",
+		challengeType,
+		siteKey: siteKey ?? null,
+		instruction: "Please solve the CAPTCHA manually in the browser, then continue.",
+		hint: "Configure an external solver service and CAPTCHA_API_KEY to automate this flow."
+	});
+	if (!apiKey) return R.fail("External solver credentials are required. Set CAPTCHA_API_KEY.").build();
+	let lastError = null;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		let result;
+		if (externalService === "2captcha") result = await solveWith2Captcha(apiKey, {
+			taskKind,
+			siteKey,
+			pageUrl
+		}, timeoutMs);
+		else if (externalService === "anticaptcha" || externalService === "capsolver") throw new Error("The selected external solver service is not yet implemented. Currently only the configured primary service and manual mode are supported.");
+		else throw new Error("Unsupported external solver service.");
+		return R.ok().build({
+			token: result.token,
+			challengeType: result.challengeType,
+			mode: result.mode,
+			durationMs: result.durationMs,
+			attempt: attempt + 1
+		});
+	} catch (error) {
+		lastError = error instanceof Error ? error : new Error(String(error));
+		logger.warn(`[captcha] Attempt ${attempt + 1} failed: ${lastError.message}`);
+	}
+	return R.fail(lastError ?? /* @__PURE__ */ new Error("All attempts failed")).merge({
+		challengeType,
+		mode,
+		maxRetries,
+		suggestion: "Try manual mode or adjust the external solver configuration."
+	}).build();
+}
+async function handleWidgetChallengeSolve(args, collector) {
+	const page = await collector.getActivePage();
+	if (!page) return R.fail("No active page.").build();
+	const mode = normalizeSolverMode(args.mode ?? args.provider ?? process.env.CAPTCHA_PROVIDER);
+	const externalService = resolveExternalServiceName(args);
+	const apiKey = argString(args, "apiKey", "") || process.env.CAPTCHA_API_KEY || "";
+	const timeoutMs = Math.min(Math.max(argNumber(args, "timeoutMs", 12e4), 5e3), 6e5);
+	const injectToken = argBool(args, "injectToken", true);
+	let siteKey = argString(args, "siteKey");
+	const pageUrl = argString(args, "pageUrl", "") || page.url();
+	if (!siteKey) siteKey = await page.evaluate(() => {
+		return document.querySelector(".cf-turnstile[data-sitekey], [data-sitekey]")?.getAttribute("data-sitekey") ?? "";
+	}) || void 0;
+	if (!siteKey) return R.fail("Could not detect the widget siteKey. Provide it manually or ensure the page exposes a site key.").build();
+	if (mode === "hook") {
+		const hookTimeoutMs = Math.min(timeoutMs, 3e4);
+		const token = await page.evaluate((hookTimeout) => {
+			return new Promise((resolve, reject) => {
+				const timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("Hook timeout")), hookTimeout);
+				const origCallbacks = window.__turnstile_callbacks;
+				if (origCallbacks) for (const [key, cb] of Object.entries(origCallbacks)) origCallbacks[key] = (captchaToken) => {
+					clearTimeout(timeout);
+					resolve(captchaToken);
+					cb(captchaToken);
+				};
+				else {
+					clearTimeout(timeout);
+					reject(/* @__PURE__ */ new Error("No widget callbacks found. Try external_service mode instead."));
+				}
+			});
+		}, hookTimeoutMs).catch(() => null);
+		if (token) return R.ok().build({
+			token,
+			method: "hook",
+			challengeType: "widget",
+			siteKey
+		});
+	}
+	if (mode === "manual") return R.ok().build({
+		mode: "manual",
+		challengeType: "widget",
+		siteKey,
+		pageUrl,
+		instruction: "Please complete the widget challenge manually."
+	});
+	if (externalService !== "2captcha") return R.fail("The selected external solver service is not implemented for this widget flow. Currently only the configured primary service, manual mode, and hook mode are supported.").build();
+	if (!apiKey) return R.fail("External solver credentials are required.").build();
+	try {
+		const result = await solveWith2Captcha(apiKey, {
+			taskKind: "turnstile",
+			siteKey,
+			pageUrl
+		}, timeoutMs);
+		if (injectToken && result.token) await page.evaluate((token) => {
+			document.querySelectorAll("input[name*=\"turnstile\"], input[name*=\"cf-turnstile\"]").forEach((input) => {
+				input.value = token;
+			});
+			if (window.turnstile?.getResponse) {}
+		}, result.token);
+		return R.ok().build({
+			token: result.token,
+			challengeType: result.challengeType,
+			siteKey,
+			mode: result.mode,
+			durationMs: result.durationMs,
+			injected: injectToken
+		});
+	} catch (error) {
+		return R.fail(error).merge({
+			siteKey,
+			mode,
+			suggestion: "Try manual mode or hook mode."
+		}).build();
+	}
+}
+//#endregion
+//#region src/server/domains/browser/handlers/captcha-capabilities.ts
+function getConfiguredProvider() {
+	return (process.env.CAPTCHA_PROVIDER || "").trim().toLowerCase() || "manual";
+}
+function getConfiguredBaseUrl() {
+	return process.env.CAPTCHA_SOLVER_BASE_URL?.trim() || process.env.CAPTCHA_2CAPTCHA_BASE_URL?.trim() || "";
+}
+function getTwoCaptchaCapability() {
+	const configuredProvider = getConfiguredProvider();
+	const baseUrl = getConfiguredBaseUrl();
+	const apiKeyConfigured = Boolean(process.env.CAPTCHA_API_KEY?.trim());
+	const baseUrlConfigured = baseUrl.length > 0;
+	const available = apiKeyConfigured && baseUrlConfigured;
+	return {
+		capability: "captcha_external_service_2captcha",
+		status: available ? "available" : "unavailable",
+		reason: available ? void 0 : "The 2captcha-compatible external path needs both CAPTCHA_API_KEY and CAPTCHA_SOLVER_BASE_URL.",
+		fix: available ? void 0 : "Set CAPTCHA_API_KEY and CAPTCHA_SOLVER_BASE_URL to enable external_service mode.",
+		details: {
+			tools: ["captcha_vision_solve", "widget_challenge_solve"],
+			configuredProvider,
+			defaultExternalProviderSupported: configuredProvider === "2captcha",
+			apiKeyConfigured,
+			baseUrlConfigured,
+			...baseUrlConfigured ? { baseUrl } : {}
+		}
+	};
+}
+async function getWidgetHookCapability(collector) {
+	let page;
+	try {
+		page = await collector.getActivePage();
+	} catch (error) {
+		return {
+			capability: "captcha_widget_hook_current_page",
+			status: "unknown",
+			reason: `Current page probe failed: ${error instanceof Error ? error.message : String(error)}`,
+			fix: "Attach or launch a browser page before using hook mode.",
+			details: {
+				tools: ["widget_challenge_solve"],
+				pageAttached: false
+			}
+		};
+	}
+	if (!page) return {
+		capability: "captcha_widget_hook_current_page",
+		status: "unknown",
+		reason: "No active page is attached.",
+		fix: "Attach or launch a browser page before using hook mode.",
+		details: {
+			tools: ["widget_challenge_solve"],
+			pageAttached: false
+		}
+	};
+	try {
+		const probe = await page.evaluate(() => {
+			const callbacksRaw = window.__turnstile_callbacks;
+			const callbackCount = callbacksRaw && typeof callbacksRaw === "object" && !Array.isArray(callbacksRaw) ? Object.keys(callbacksRaw).length : 0;
+			return {
+				url: location.href,
+				callbackCount
+			};
+		});
+		return {
+			capability: "captcha_widget_hook_current_page",
+			status: probe.callbackCount > 0 ? "available" : "unavailable",
+			reason: probe.callbackCount > 0 ? void 0 : "The current page does not expose window.__turnstile_callbacks for hook mode.",
+			fix: probe.callbackCount > 0 ? void 0 : "Use manual mode, or configure the external 2captcha-compatible service for widget solving.",
+			details: {
+				tools: ["widget_challenge_solve"],
+				pageAttached: true,
+				...probe
+			}
+		};
+	} catch (error) {
+		return {
+			capability: "captcha_widget_hook_current_page",
+			status: "unknown",
+			reason: `Current page probe failed: ${error instanceof Error ? error.message : String(error)}`,
+			fix: "Ensure the attached page is reachable before using hook mode.",
+			details: {
+				tools: ["widget_challenge_solve"],
+				pageAttached: true
+			}
+		};
+	}
+}
+async function handleCaptchaSolverCapabilities(collector) {
+	const configuredProvider = getConfiguredProvider();
+	const widgetHookCapability = await getWidgetHookCapability(collector);
+	return R.raw(capabilityReport("captcha_solver_capabilities", [
+		{
+			capability: "captcha_manual",
+			status: "available",
+			details: { tools: ["captcha_vision_solve", "widget_challenge_solve"] }
+		},
+		getTwoCaptchaCapability(),
+		{
+			capability: "captcha_external_service_anticaptcha",
+			status: "unavailable",
+			reason: "AntiCaptcha integration is not implemented in this build.",
+			fix: "Use manual mode or the configured 2captcha-compatible service instead.",
+			details: {
+				tools: ["captcha_vision_solve", "widget_challenge_solve"],
+				configuredProvider
+			}
+		},
+		{
+			capability: "captcha_external_service_capsolver",
+			status: "unavailable",
+			reason: "CapSolver integration is not implemented in this build.",
+			fix: "Use manual mode or the configured 2captcha-compatible service instead.",
+			details: {
+				tools: ["captcha_vision_solve", "widget_challenge_solve"],
+				configuredProvider
+			}
+		},
+		widgetHookCapability
+	], { configuredProvider }));
+}
+//#endregion
+//#region src/server/domains/browser/handlers/camoufox-flow.ts
+function extractCamoufoxConfig(args) {
+	const addons = argStringArray(args, "addons");
+	const excludeAddons = argStringArray(args, "excludeAddons");
+	const fonts = argStringArray(args, "fonts");
+	return {
+		headless: argBool(args, "headless", true),
+		os: argString(args, "os", "windows"),
+		geoip: argBool(args, "geoip", false),
+		humanize: argBool(args, "humanize", false),
+		proxy: argString(args, "proxy") || void 0,
+		blockImages: argBool(args, "blockImages", false),
+		blockWebrtc: argBool(args, "blockWebrtc", false),
+		blockWebgl: argBool(args, "blockWebgl", false),
+		locale: argString(args, "locale") || void 0,
+		addons: addons.length > 0 ? addons : void 0,
+		fonts: fonts.length > 0 ? fonts : void 0,
+		excludeAddons: excludeAddons.length > 0 ? excludeAddons : void 0,
+		customFontsOnly: argBool(args, "customFontsOnly", false),
+		screen: args.screen,
+		window: args.window,
+		fingerprint: argObject(args, "fingerprint"),
+		webglConfig: argObject(args, "webglConfig"),
+		firefoxUserPrefs: argObject(args, "firefoxUserPrefs"),
+		mainWorldEval: argBool(args, "mainWorldEval", false),
+		enableCache: argBool(args, "enableCache", false)
+	};
+}
+async function handleCamoufoxLaunchFlow(context, args) {
+	try {
+		const config = extractCamoufoxConfig(args);
+		if (argString(args, "mode", "launch") === "connect") {
+			const wsEndpoint = argString(args, "wsEndpoint");
+			if (!wsEndpoint) return R.fail("wsEndpoint is required for connect mode.").build();
+			const manager = new CamoufoxBrowserManager(config);
+			await manager.connectToServer(wsEndpoint);
+			context.setCamoufoxManager(manager);
+			context.setActiveDriver("camoufox");
+			context.clearCamoufoxPage();
+			return R.ok().build({
+				driver: "camoufox",
+				mode: "connect",
+				wsEndpoint,
+				message: "Connected to Camoufox server."
+			});
+		}
+		const manager = new CamoufoxBrowserManager(config);
+		await manager.launch();
+		context.setCamoufoxManager(manager);
+		context.setActiveDriver("camoufox");
+		context.clearCamoufoxPage();
+		return R.ok().build({
+			driver: "camoufox",
+			mode: "launch",
+			config: {
+				os: config.os,
+				headless: config.headless,
+				geoip: config.geoip,
+				humanize: config.humanize,
+				locale: config.locale,
+				blockWebgl: config.blockWebgl,
+				blockImages: config.blockImages,
+				blockWebrtc: config.blockWebrtc
+			},
+			message: "Camoufox (Firefox) browser launched"
+		});
+	} catch (e) {
+		return R.fail(e).build();
+	}
+}
+function normalizeWaitUntil(waitUntil) {
+	if (waitUntil === "networkidle2") return "networkidle";
+	if (waitUntil === "load") return "load";
+	if (waitUntil === "domcontentloaded") return "domcontentloaded";
+	if (waitUntil === "commit") return "commit";
+	return "networkidle";
+}
+async function handleCamoufoxNavigateFlow(context, args) {
+	try {
+		const url = argString(args, "url", "");
+		const rawWaitUntil = argString(args, "waitUntil", "networkidle");
+		const timeout = argNumber(args, "timeout");
+		const page = await context.getCamoufoxPage();
+		await page.goto(url, {
+			waitUntil: normalizeWaitUntil(rawWaitUntil),
+			timeout
+		});
+		context.setConsoleMonitorPage(page);
+		return R.ok().build({
+			driver: "camoufox",
+			url: page.url(),
+			title: await page.title()
+		});
+	} catch (e) {
+		return R.fail(e).build();
+	}
+}
+//#endregion
+//#region src/server/domains/browser/handlers.impl.ts
+var BrowserToolHandlers = class {
+	collector;
+	pageController;
+	scriptManager;
+	consoleMonitor;
+	captchaDetector;
+	detailedDataManager;
+	camoufoxManager = null;
+	activeDriver = "chrome";
+	camoufoxPage = null;
+	autoDetectCaptcha = true;
+	autoSwitchHeadless = true;
+	captchaTimeout = 3e5;
+	browserControl;
+	targetControl;
+	camoufoxBrowser;
+	pageNavigation;
+	pageInteraction;
+	pageEvaluation;
+	targetEvaluation;
+	pageData;
+	consoleHandlers;
+	scriptManagement;
+	captchaHandlers;
+	stealthInjection;
+	frameworkState;
+	indexedDBDump;
+	jsHeapSearch;
+	tabWorkflow;
+	detailedData;
+	jsdomHandlers;
+	tabRegistry;
+	constructor(collector, pageController, scriptManager, consoleMonitor, eventBus) {
+		this.collector = collector;
+		this.pageController = pageController;
+		this.scriptManager = scriptManager;
+		this.consoleMonitor = consoleMonitor;
+		const screenshotDir = resolveOutputDirectory(getConfig().paths.captchaScreenshotDir, "screenshots/captcha");
+		this.captchaDetector = new AICaptchaDetector(screenshotDir);
+		this.detailedDataManager = DetailedDataManager.getInstance();
+		const modules = initializeBrowserHandlerModules({
+			collector: this.collector,
+			pageController: this.pageController,
+			scriptManager: this.scriptManager,
+			consoleMonitor: this.consoleMonitor,
+			eventBus,
+			captchaDetector: this.captchaDetector,
+			detailedDataManager: this.detailedDataManager,
+			getActiveDriver: () => this.activeDriver,
+			getCamoufoxPage: () => this.getCamoufoxPage(),
+			getCamoufoxManager: () => this.camoufoxManager,
+			setCamoufoxManager: (manager) => {
+				this.camoufoxManager = manager;
+			},
+			closeCamoufox: () => this.closeCamoufox(),
+			getAutoDetectCaptcha: () => this.autoDetectCaptcha,
+			getAutoSwitchHeadless: () => this.autoSwitchHeadless,
+			getCaptchaTimeout: () => this.captchaTimeout,
+			setAutoDetectCaptcha: (value) => {
+				this.autoDetectCaptcha = value;
+			},
+			setAutoSwitchHeadless: (value) => {
+				this.autoSwitchHeadless = value;
+			},
+			setCaptchaTimeout: (value) => {
+				this.captchaTimeout = value;
+			}
+		});
+		this.browserControl = modules.browserControl;
+		this.targetControl = modules.targetControl;
+		this.camoufoxBrowser = modules.camoufoxBrowser;
+		this.pageNavigation = modules.pageNavigation;
+		this.pageInteraction = modules.pageInteraction;
+		this.pageEvaluation = modules.pageEvaluation;
+		this.targetEvaluation = modules.targetEvaluation;
+		this.pageData = modules.pageData;
+		this.consoleHandlers = modules.consoleHandlers;
+		this.scriptManagement = modules.scriptManagement;
+		this.captchaHandlers = modules.captchaHandlers;
+		this.stealthInjection = modules.stealthInjection;
+		this.frameworkState = modules.frameworkState;
+		this.indexedDBDump = modules.indexedDBDump;
+		this.jsHeapSearch = modules.jsHeapSearch;
+		this.tabWorkflow = modules.tabWorkflow;
+		this.detailedData = modules.detailedData;
+		this.jsdomHandlers = modules.jsdomHandlers;
+		this.tabRegistry = modules.tabRegistry;
+	}
+	/** Get the shared TabRegistry for context enrichment. */
+	getTabRegistry() {
+		return this.tabRegistry;
+	}
+	/** Get or create camoufox page (Playwright Page). */
+	async getCamoufoxPage() {
+		if (!this.camoufoxManager) throw new Error("Camoufox browser not launched. Call browser_launch(driver=\"camoufox\") first.");
+		if (!this.camoufoxPage) this.camoufoxPage = await this.camoufoxManager.newPage();
+		return this.camoufoxPage;
+	}
+	async closeCamoufox() {
+		try {
+			await this.consoleMonitor.disable();
+		} catch (error) {
+			logger.warn(`Failed to reset console monitor before closing Camoufox: ${String(error)}`);
+		}
+		this.consoleMonitor.clearPlaywrightPage();
+		if (this.camoufoxManager) {
+			await this.camoufoxManager.close();
+			this.camoufoxManager = null;
+			this.camoufoxPage = null;
+		}
+	}
+	async handleBrowserLaunch(args) {
+		if (argString(args, "driver", "chrome") === "camoufox") return this.handleCamoufoxLaunch(args);
+		if (this.activeDriver === "camoufox" && this.camoufoxManager) await this.closeCamoufox();
+		this.activeDriver = "chrome";
+		return this.browserControl.handleBrowserLaunch(args);
+	}
+	async handleBrowserClose(args) {
+		if (this.activeDriver === "camoufox" && this.camoufoxManager) {
+			await this.closeCamoufox();
+			await this.browserControl.handleBrowserClose(args);
+			this.activeDriver = "chrome";
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					message: "Camoufox browser closed"
+				}, null, 2)
+			}] };
+		}
+		return this.browserControl.handleBrowserClose(args);
+	}
+	async handleBrowserStatus(args) {
+		if (this.activeDriver === "camoufox") {
+			const running = !!this.camoufoxManager?.getBrowser();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					driver: "camoufox",
+					running,
+					hasActivePage: !!this.camoufoxPage
+				}, null, 2)
+			}] };
+		}
+		return this.browserControl.handleBrowserStatus(args);
+	}
+	async handleBrowserListTabs(args) {
+		return this.browserControl.handleBrowserListTabs(args);
+	}
+	async handleBrowserListCdpTargets(args) {
+		return this.targetControl.handleBrowserListCdpTargets(args);
+	}
+	async handleBrowserSelectTab(args) {
+		return this.browserControl.handleBrowserSelectTab(args);
+	}
+	async handleBrowserAttachCdpTarget(args) {
+		return this.targetControl.handleBrowserAttachCdpTarget(args);
+	}
+	async handleBrowserDetachCdpTarget(args) {
+		return this.targetControl.handleBrowserDetachCdpTarget(args);
+	}
+	async handleBrowserEvaluateCdpTarget(args) {
+		return this.targetEvaluation.handleBrowserEvaluateCdpTarget(args);
+	}
+	async handleBrowserAttach(args) {
+		if (this.activeDriver === "camoufox" && this.camoufoxManager) await this.closeCamoufox();
+		this.activeDriver = "chrome";
+		return this.browserControl.handleBrowserAttach(args);
+	}
+	async handleCamoufoxServerDispatch(args) {
+		switch (String(args["action"] ?? "")) {
+			case "close": return this.camoufoxBrowser.handleCamoufoxServerClose(args);
+			case "status": return this.camoufoxBrowser.handleCamoufoxServerStatus(args);
+			default: return this.camoufoxBrowser.handleCamoufoxServerLaunch(args);
+		}
+	}
+	async handleCamoufoxServerLaunch(args) {
+		return this.camoufoxBrowser.handleCamoufoxServerLaunch(args);
+	}
+	async handleCamoufoxServerClose(args) {
+		return this.camoufoxBrowser.handleCamoufoxServerClose(args);
+	}
+	async handleCamoufoxServerStatus(args) {
+		return this.camoufoxBrowser.handleCamoufoxServerStatus(args);
+	}
+	async handlePageNavigate(args) {
+		if (this.activeDriver === "camoufox") return this.handleCamoufoxNavigate(args);
+		return this.pageNavigation.handlePageNavigate(args);
+	}
+	async handlePageReload(args) {
+		return this.pageNavigation.handlePageReload(args);
+	}
+	async handlePageBack(args) {
+		return this.pageNavigation.handlePageBack(args);
+	}
+	async handlePageForward(args) {
+		return this.pageNavigation.handlePageForward(args);
+	}
+	async handlePageClick(args) {
+		return this.pageInteraction.handlePageClick(args);
+	}
+	async handlePageType(args) {
+		return this.pageInteraction.handlePageType(args);
+	}
+	async handlePageSelect(args) {
+		return this.pageInteraction.handlePageSelect(args);
+	}
+	async handlePageHover(args) {
+		return this.pageInteraction.handlePageHover(args);
+	}
+	async handlePageScroll(args) {
+		return this.pageInteraction.handlePageScroll(args);
+	}
+	async handlePagePressKey(args) {
+		return this.pageInteraction.handlePagePressKey(args);
+	}
+	async handlePageEvaluate(args) {
+		return this.pageEvaluation.handlePageEvaluate(args);
+	}
+	async handlePageScreenshot(args) {
+		return this.pageEvaluation.handlePageScreenshot(args);
+	}
+	async handlePageInjectScript(args) {
+		return this.pageEvaluation.handlePageInjectScript(args);
+	}
+	async handlePageWaitForSelector(args) {
+		return this.pageEvaluation.handlePageWaitForSelector(args);
+	}
+	async handlePageCookiesDispatch(args) {
+		const action = String(args["action"] ?? "");
+		switch (action) {
+			case "get": return this.pageData.handlePageGetCookies(args);
+			case "set": return this.pageData.handlePageSetCookies(args);
+			case "clear": {
+				const expectedCount = args["expectedCount"];
+				if (typeof expectedCount !== "number" || expectedCount < 0) return {
+					content: [{
+						type: "text",
+						text: "action=clear requires expectedCount (number). Call action=get first to obtain the current cookie count."
+					}],
+					isError: true
+				};
+				const current = await this.pageData.getPageCookieCount();
+				if (current !== expectedCount) return {
+					content: [{
+						type: "text",
+						text: `Cookie count mismatch: expected ${expectedCount} but found ${current}. Call action=get to refresh, then retry with the correct count.`
+					}],
+					isError: true
+				};
+				return this.pageData.handlePageClearCookies(args);
+			}
+			default: return {
+				content: [{
+					type: "text",
+					text: `Invalid action: "${action}". Expected one of: get, set, clear`
+				}],
+				isError: true
+			};
+		}
+	}
+	async handlePageSetViewport(args) {
+		return this.pageData.handlePageSetViewport(args);
+	}
+	async handlePageEmulateDevice(args) {
+		return this.pageData.handlePageEmulateDevice(args);
+	}
+	async handlePageLocalStorageDispatch(args) {
+		const action = String(args["action"] ?? "");
+		switch (action) {
+			case "get": return this.pageData.handlePageGetLocalStorage(args);
+			case "set": return this.pageData.handlePageSetLocalStorage(args);
+			default: return {
+				content: [{
+					type: "text",
+					text: `Invalid action: "${action}". Expected one of: get, set`
+				}],
+				isError: true
+			};
+		}
+	}
+	async handleConsoleMonitor(args) {
+		return this.consoleHandlers.handleConsoleMonitor(args);
+	}
+	async handleConsoleGetLogs(args) {
+		return this.consoleHandlers.handleConsoleGetLogs(args);
+	}
+	async handleConsoleExecute(args) {
+		return this.consoleHandlers.handleConsoleExecute(args);
+	}
+	async handleGetAllScripts(args) {
+		return this.scriptManagement.handleGetAllScripts(args);
+	}
+	async handleGetScriptSource(args) {
+		return this.scriptManagement.handleGetScriptSource(args);
+	}
+	async handleCaptchaDetect(args) {
+		return this.captchaHandlers.handleCaptchaDetect(args);
+	}
+	async handleCaptchaWait(args) {
+		return this.captchaHandlers.handleCaptchaWait(args);
+	}
+	async handleCaptchaConfig(args) {
+		return this.captchaHandlers.handleCaptchaConfig(args);
+	}
+	async handleStealthInject(args) {
+		return this.stealthInjection.handleStealthInject(args);
+	}
+	async handleStealthSetUserAgent(args) {
+		return this.stealthInjection.handleStealthSetUserAgent(args);
+	}
+	async handleStealthConfigureJitter(args) {
+		return this.stealthInjection.handleStealthConfigureJitter(args);
+	}
+	async handleStealthGenerateFingerprint(args) {
+		return this.stealthInjection.handleStealthGenerateFingerprint(args);
+	}
+	async handleStealthVerify(args) {
+		return this.stealthInjection.handleStealthVerify(args);
+	}
+	async handleCamoufoxGeolocation(args) {
+		return this.stealthInjection.handleCamoufoxGeolocation(args);
+	}
+	async handleFrameworkStateExtract(args) {
+		return this.frameworkState.handleFrameworkStateExtract(args);
+	}
+	async handleIndexedDBDump(args) {
+		return this.indexedDBDump.handleIndexedDBDump(args);
+	}
+	async handleJSHeapSearch(args) {
+		return this.jsHeapSearch.handleJSHeapSearch(args);
+	}
+	async handleTabWorkflow(args) {
+		return this.tabWorkflow.handleTabWorkflow(args);
+	}
+	async handleGetDetailedData(args) {
+		return this.detailedData.handleGetDetailedData(args);
+	}
+	async handleCamoufoxLaunch(args) {
+		return handleCamoufoxLaunchFlow({
+			setCamoufoxManager: (manager) => {
+				this.camoufoxManager = manager;
+			},
+			setActiveDriver: (driver) => {
+				this.activeDriver = driver;
+			},
+			clearCamoufoxPage: () => {
+				this.camoufoxPage = null;
+			}
+		}, args);
+	}
+	async handleCamoufoxNavigate(args) {
+		return handleCamoufoxNavigateFlow({
+			getCamoufoxPage: () => this.getCamoufoxPage(),
+			setConsoleMonitorPage: (page) => {
+				this.consoleMonitor.setPlaywrightPage(page);
+			}
+		}, args);
+	}
+	async handleHumanMouse(args) {
+		return handleHumanMouse(args, this.collector);
+	}
+	async handleHumanScroll(args) {
+		return handleHumanScroll(args, this.collector);
+	}
+	async handleHumanTyping(args) {
+		return handleHumanTyping(args, this.collector);
+	}
+	async handleCaptchaVisionSolve(args) {
+		return handleCaptchaVisionSolve(args, this.collector);
+	}
+	async handleWidgetChallengeSolve(args) {
+		return handleWidgetChallengeSolve(args, this.collector);
+	}
+	async handleCaptchaSolverCapabilities() {
+		return handleCaptchaSolverCapabilities(this.collector);
+	}
+	async handleJsdomParse(args) {
+		return this.jsdomHandlers.handleJsdomParse(args);
+	}
+	async handleJsdomQuery(args) {
+		return this.jsdomHandlers.handleJsdomQuery(args);
+	}
+	async handleJsdomExecute(args) {
+		return this.jsdomHandlers.handleJsdomExecute(args);
+	}
+	async handleJsdomSerialize(args) {
+		return this.jsdomHandlers.handleJsdomSerialize(args);
+	}
+	async handleJsdomCookies(args) {
+		return this.jsdomHandlers.handleJsdomCookies(args);
+	}
+};
+//#endregion
+export { BrowserToolHandlers };