@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/{NativeMemoryManager.impl-CB6gJ0NM.mjs → NativeMemoryManager.impl-D9Lkovvn.mjs}

@@ -1,49 +1,10 @@
-import { t as logger } from "./logger-BmWzC2lM.mjs";
-import { a as MemoryProtection, t as createPlatformProvider } from "./factory-CibqTNC8.mjs";
-import { v as isKoffiAvailable, y as isWindows } from "./Win32API-Bc0QnQsN.mjs";
-import { i as parsePattern, t as findPatternInBuffer } from "./NativeMemoryManager.utils-BML4q1ry.mjs";
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { v as isKoffiAvailable, y as isWindows } from "./Win32API-C2kjj0ze.mjs";
+import { n as cpuLimit } from "./concurrency-Drev_Vz9.mjs";
+import { t as createPlatformProvider } from "./factory-C90tBff6.mjs";
+import { i as parsePattern, t as findPatternInBuffer } from "./NativeMemoryManager.utils-BBlAixF5.mjs";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
-//#region src/utils/concurrency.ts
-function pLimit(concurrency) {
-	if (concurrency < 1) throw new RangeError("concurrency must be >= 1");
-	let activeCount = 0;
-	const queue = [];
-	function next() {
-		if (queue.length > 0 && activeCount < concurrency) {
-			activeCount++;
-			queue.shift()();
-		}
-	}
-	function run(fn) {
-		return new Promise((resolve, reject) => {
-			const execute = async () => {
-				try {
-					resolve(await fn());
-				} catch (err) {
-					reject(err);
-				} finally {
-					activeCount--;
-					next();
-				}
-			};
-			if (activeCount < concurrency) {
-				activeCount++;
-				execute();
-			} else queue.push(() => {
-				execute();
-			});
-		});
-	}
-	return run;
-}
-/** External CLI calls, HAR export, large file I/O */
-const ioLimit = pLimit(parseInt(process.env.jshook_IO_CONCURRENCY || "4", 10));
-/** CPU-heavy: AST parsing, deobfuscation, binary decoding */
-const cpuLimit = pLimit(parseInt(process.env.jshook_CPU_CONCURRENCY || "2", 10));
-/** CDP-heavy: heap snapshots, traces, profiling */
-const cdpLimit = pLimit(parseInt(process.env.jshook_CDP_CONCURRENCY || "2", 10));
-//#endregion
 //#region src/native/NativeMemoryManager.availability.ts
 async function checkNativeMemoryAvailability(execAsync) {
 	if (process.platform === "darwin") return checkDarwinAvailability(execAsync);
@@ -135,11 +96,14 @@ function scanRegionInChunks(region, patternBytes, mask, readChunk, chunkSize = S
 * Win32-only methods (injection, debug) are guarded by platform checks.
 */
 var NativeMemoryManager = class {
-	_provider = null;
+	providerCache = null;
 	/** Lazily create the platform memory provider */
 	get provider() {
-		if (!this._provider) this._provider = createPlatformProvider();
-		return this._provider;
+		if (!this.providerCache) this.providerCache = createPlatformProvider();
+		return this.providerCache;
+	}
+	set provider(value) {
+		this.providerCache = value;
 	}
 	async checkAvailability() {
 		return checkNativeMemoryAvailability(execAsync);
@@ -363,7 +327,7 @@ var NativeMemoryManager = class {
 			error: "DLL injection is only supported on Windows"
 		};
 		try {
-			const { openProcessForMemory, CloseHandle, WriteProcessMemory, VirtualAllocEx, CreateRemoteThread, GetModuleHandle, GetProcAddress, PAGE, MEM } = await import("./Win32API-Bc0QnQsN.mjs").then((n) => n.g);
+			const { openProcessForMemory, CloseHandle, WriteProcessMemory, VirtualAllocEx, CreateRemoteThread, GetModuleHandle, GetProcAddress, PAGE, MEM } = await import("./Win32API-C2kjj0ze.mjs").then((n) => n.g);
 			const handle = openProcessForMemory(pid, true);
 			try {
 				const loadLibraryAddr = GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
@@ -413,7 +377,7 @@ var NativeMemoryManager = class {
 			let buffer;
 			if (encoding === "base64") buffer = Buffer.from(shellcode, "base64");
 			else buffer = Buffer.from(shellcode.replace(/\s/g, ""), "hex");
-			const { openProcessForMemory, CloseHandle, WriteProcessMemory, VirtualAllocEx, VirtualProtectEx, CreateRemoteThread, PAGE, MEM } = await import("./Win32API-Bc0QnQsN.mjs").then((n) => n.g);
+			const { openProcessForMemory, CloseHandle, WriteProcessMemory, VirtualAllocEx, VirtualProtectEx, CreateRemoteThread, PAGE, MEM } = await import("./Win32API-C2kjj0ze.mjs").then((n) => n.g);
 			const handle = openProcessForMemory(pid, true);
 			try {
 				const remoteMem = VirtualAllocEx(handle, 0n, buffer.length, MEM.COMMIT | MEM.RESERVE, PAGE.READWRITE);
@@ -460,7 +424,7 @@ var NativeMemoryManager = class {
 			error: "Debug port check is only supported on Windows"
 		};
 		try {
-			const { openProcessForMemory, CloseHandle, NtQueryInformationProcess } = await import("./Win32API-Bc0QnQsN.mjs").then((n) => n.g);
+			const { openProcessForMemory, CloseHandle, NtQueryInformationProcess } = await import("./Win32API-C2kjj0ze.mjs").then((n) => n.g);
 			const handle = openProcessForMemory(pid, false);
 			try {
 				const { status, debugPort } = NtQueryInformationProcess(handle, 7);
@@ -502,12 +466,12 @@ function regionInfoToMemoryRegion(info) {
 }
 /** Convert MemoryProtection flags to human-readable string */
 function protectionToString(prot) {
-	if (prot === MemoryProtection.NoAccess) return "NOACCESS";
+	if (prot === 0) return "NOACCESS";
 	const parts = [];
-	const hasRead = (prot & MemoryProtection.Read) !== 0;
-	const hasWrite = (prot & MemoryProtection.Write) !== 0;
-	const hasExec = (prot & MemoryProtection.Execute) !== 0;
-	const hasGuard = (prot & MemoryProtection.Guard) !== 0;
+	const hasRead = (prot & 1) !== 0;
+	const hasWrite = (prot & 2) !== 0;
+	const hasExec = (prot & 4) !== 0;
+	const hasGuard = (prot & 8) !== 0;
 	if (hasRead && hasWrite && hasExec) parts.push("RWX");
 	else if (hasRead && hasExec) parts.push("RX");
 	else if (hasRead && hasWrite) parts.push("RW");
@@ -518,4 +482,4 @@ function protectionToString(prot) {
 }
 const nativeMemoryManager = new NativeMemoryManager();
 //#endregion
-export { ioLimit as i, cdpLimit as n, cpuLimit as r, nativeMemoryManager as t };
+export { nativeMemoryManager as t };

package/dist/{NativeMemoryManager.utils-BML4q1ry.mjs → NativeMemoryManager.utils-BBlAixF5.mjs}

@@ -1,4 +1,4 @@
-import { u as PAGE, v as isKoffiAvailable$1 } from "./Win32API-Bc0QnQsN.mjs";
+import { u as PAGE, v as isKoffiAvailable$1 } from "./Win32API-C2kjj0ze.mjs";
 //#region src/native/NativeMemoryManager.utils.ts
 function isKoffiAvailable() {
 	return isKoffiAvailable$1();

package/dist/{PEAnalyzer-CK0xe0Fs.mjs → PEAnalyzer-DMQ44gen.mjs}

@@ -1,5 +1,5 @@
-import { t as logger } from "./logger-BmWzC2lM.mjs";
-import { a as GetModuleFileNameEx, b as openProcessForMemory, d as ReadProcessMemory, i as GetModuleBaseName, n as EnumProcessModules, s as GetModuleInformation, t as CloseHandle } from "./Win32API-Bc0QnQsN.mjs";
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { a as GetModuleFileNameEx, b as openProcessForMemory, d as ReadProcessMemory, i as GetModuleBaseName, n as EnumProcessModules, s as GetModuleInformation, t as CloseHandle } from "./Win32API-C2kjj0ze.mjs";
 import { promises } from "node:fs";
 //#region src/native/PEAnalyzer.types.ts
 /** PE section characteristic flags */
@@ -104,7 +104,7 @@ var PEAnalyzer = class {
 		const base = BigInt(moduleBase);
 		const hProcess = openProcessForMemory(pid);
 		try {
-			const headers = await this._readCoreHeaders(hProcess, base);
+			const headers = await this.readCoreHeaders(hProcess, base);
 			const sections = [];
 			for (let i = 0; i < headers.numSections; i++) {
 				const off = headers.firstSectionOffset + i * SECTION_HEADER_SIZE;
@@ -138,7 +138,7 @@ var PEAnalyzer = class {
 		const base = BigInt(moduleBase);
 		const hProcess = openProcessForMemory(pid);
 		try {
-			const headers = await this._readCoreHeaders(hProcess, base);
+			const headers = await this.readCoreHeaders(hProcess, base);
 			const importRva = headers.dataDirectories[IMAGE_DIRECTORY_ENTRY.IMPORT];
 			if (!importRva || importRva.rva === 0) return [];
 			const imports = [];
@@ -151,7 +151,7 @@ var PEAnalyzer = class {
 				const nullIdx = nameData.indexOf(0);
 				const dllName = nameData.subarray(0, nullIdx > 0 ? nullIdx : 256).toString("ascii");
 				const originalFirstThunkRva = desc.readUInt32LE(0) || desc.readUInt32LE(16);
-				const functions = this._readThunkArray(hProcess, base, originalFirstThunkRva, headers.isPE32Plus);
+				const functions = this.readThunkArray(hProcess, base, originalFirstThunkRva, headers.isPE32Plus);
 				imports.push({
 					dllName,
 					functions
@@ -170,7 +170,7 @@ var PEAnalyzer = class {
 		const base = BigInt(moduleBase);
 		const hProcess = openProcessForMemory(pid);
 		try {
-			const exportDir = (await this._readCoreHeaders(hProcess, base)).dataDirectories[IMAGE_DIRECTORY_ENTRY.EXPORT];
+			const exportDir = (await this.readCoreHeaders(hProcess, base)).dataDirectories[IMAGE_DIRECTORY_ENTRY.EXPORT];
 			if (!exportDir || exportDir.rva === 0) return [];
 			const expData = ReadProcessMemory(hProcess, base + BigInt(exportDir.rva), 40);
 			const numberOfNames = expData.readUInt32LE(24);
@@ -213,7 +213,7 @@ var PEAnalyzer = class {
 		const hProcess = openProcessForMemory(pid);
 		const detections = [];
 		try {
-			const modules = this._enumerateModulesInternal(hProcess);
+			const modules = this.enumerateModulesInternal(hProcess);
 			const targets = moduleName ? modules.filter((m) => m.name.toLowerCase().includes(moduleName.toLowerCase())) : modules;
 			for (const mod of targets) try {
 				const diskData = await promises.readFile(mod.path);
@@ -222,12 +222,12 @@ var PEAnalyzer = class {
 					const funcRva = parseInt(exp.rva, 16);
 					if (funcRva === 0 || exp.forwardedTo) continue;
 					const memBytes = ReadProcessMemory(hProcess, BigInt(mod.base) + BigInt(funcRva), COMPARE_BYTES);
-					const diskOffset = this._rvaToFileOffset(diskData, funcRva);
+					const diskOffset = this.rvaToFileOffset(diskData, funcRva);
 					if (diskOffset < 0 || diskOffset + COMPARE_BYTES > diskData.length) continue;
 					const diskBytes = diskData.subarray(diskOffset, diskOffset + COMPARE_BYTES);
 					if (!memBytes.equals(diskBytes)) {
-						const hookType = this._classifyHook(memBytes);
-						const jumpTarget = this._decodeJumpTarget(memBytes, BigInt(mod.base) + BigInt(funcRva));
+						const hookType = this.classifyHook(memBytes);
+						const jumpTarget = this.decodeJumpTarget(memBytes, BigInt(mod.base) + BigInt(funcRva));
 						detections.push({
 							address: `0x${(BigInt(mod.base) + BigInt(funcRva)).toString(16)}`,
 							moduleName: mod.name,
@@ -273,7 +273,7 @@ var PEAnalyzer = class {
 		});
 		return anomalies;
 	}
-	async _readCoreHeaders(hProcess, base) {
+	async readCoreHeaders(hProcess, base) {
 		const e_lfanew = ReadProcessMemory(hProcess, base, 64).readUInt32LE(60);
 		const ntData = ReadProcessMemory(hProcess, base + BigInt(e_lfanew), 264);
 		const numSections = ntData.readUInt16LE(6);
@@ -296,7 +296,7 @@ var PEAnalyzer = class {
 			dataDirectories
 		};
 	}
-	_readThunkArray(hProcess, base, thunkRva, isPE32Plus) {
+	readThunkArray(hProcess, base, thunkRva, isPE32Plus) {
 		const thunkSize = isPE32Plus ? 8 : 4;
 		const functions = [];
 		const IMAGE_ORDINAL_FLAG = isPE32Plus ? 9223372036854775808n : 2147483648n;
@@ -326,7 +326,7 @@ var PEAnalyzer = class {
 		}
 		return functions;
 	}
-	_enumerateModulesInternal(hProcess) {
+	enumerateModulesInternal(hProcess) {
 		const modules = [];
 		try {
 			const { modules: modHandles, count } = EnumProcessModules(hProcess);
@@ -347,7 +347,7 @@ var PEAnalyzer = class {
 		}
 		return modules;
 	}
-	_rvaToFileOffset(peData, rva) {
+	rvaToFileOffset(peData, rva) {
 		const e_lfanew = peData.readUInt32LE(60);
 		const numSections = peData.readUInt16LE(e_lfanew + 6);
 		const sizeOfOptionalHeader = peData.readUInt16LE(e_lfanew + 20);
@@ -362,13 +362,13 @@ var PEAnalyzer = class {
 		}
 		return -1;
 	}
-	_classifyHook(memBytes) {
+	classifyHook(memBytes) {
 		if (memBytes[0] === 233) return "jmp_rel32";
 		if (memBytes[0] === 255 && memBytes[1] === 37) return "jmp_abs64";
 		if (memBytes[0] === 104 && memBytes[5] === 195) return "push_ret";
 		return "unknown";
 	}
-	_decodeJumpTarget(memBytes, funcAddr) {
+	decodeJumpTarget(memBytes, funcAddr) {
 		if (memBytes[0] === 233) {
 			const rel32 = memBytes.readInt32LE(1);
 			return `0x${(funcAddr + 5n + BigInt(rel32)).toString(16)}`;

package/dist/PageController-BPJNqqBN.mjs

@@ -0,0 +1,431 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { Jt as PAGE_NETWORK_IDLE_TIMEOUT_MS, qt as PAGE_FRAME_SELECTOR_TIMEOUT_MS } from "./constants-CDZLOoVv.mjs";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+//#region src/modules/collector/PageController.ts
+var PageController = class {
+	constructor(collector) {
+		this.collector = collector;
+	}
+	async getBrowser() {
+		return this.collector.getBrowser();
+	}
+	hasAttachedTargetSession() {
+		return this.collector.getAttachedTargetSession() !== null;
+	}
+	getAttachedTargetInfo() {
+		return this.collector.getAttachedTargetInfo();
+	}
+	async evaluateAttachedTarget(code, options) {
+		return await this.collector.getBrowserTargetSessionManager().evaluate(code, options);
+	}
+	async addScriptToAttachedTarget(source) {
+		return await this.collector.getBrowserTargetSessionManager().addScriptToEvaluateOnNewDocument(source);
+	}
+	async navigate(url, options) {
+		const page = await this.collector.getActivePage();
+		const startTime = Date.now();
+		await page.goto(url, {
+			waitUntil: options?.waitUntil || "networkidle2",
+			timeout: options?.timeout || 3e4
+		});
+		const loadTime = Date.now() - startTime;
+		const title = await page.title();
+		const currentUrl = page.url();
+		logger.info(`Navigated to: ${url}`);
+		return {
+			url: currentUrl,
+			title,
+			loadTime
+		};
+	}
+	async reload(options) {
+		await (await this.collector.getActivePage()).reload({
+			waitUntil: options?.waitUntil || "networkidle2",
+			timeout: options?.timeout || 3e4
+		});
+		logger.info("Page reloaded");
+	}
+	async goBack(timeout = 1e4) {
+		await (await this.collector.getActivePage()).goBack({
+			waitUntil: "domcontentloaded",
+			timeout
+		});
+		logger.info("Navigated back");
+	}
+	async goForward(timeout = 1e4) {
+		await (await this.collector.getActivePage()).goForward({
+			waitUntil: "domcontentloaded",
+			timeout
+		});
+		logger.info("Navigated forward");
+	}
+	async click(selector, options, frameOptions) {
+		const page = await this.collector.getActivePage();
+		const context = await this.resolveFrame(page, frameOptions);
+		const timeout = options?.timeout;
+		const clickOptions = {
+			button: options?.button || "left",
+			clickCount: options?.clickCount || 1,
+			delay: options?.delay
+		};
+		if (options?.offset) clickOptions.offset = options.offset;
+		if (typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0) {
+			page.setDefaultTimeout(timeout);
+			try {
+				await context.click(selector, clickOptions);
+			} finally {
+				page.setDefaultTimeout(this.collector["config"]?.timeout ?? 3e4);
+			}
+		} else await context.click(selector, clickOptions);
+		logger.info(`Clicked: ${selector}${frameOptions?.frameUrl || frameOptions?.frameSelector ? " (in frame)" : ""}`);
+	}
+	async type(selector, text, options, frameOptions) {
+		const page = await this.collector.getActivePage();
+		await (await this.resolveFrame(page, frameOptions)).type(selector, text, { delay: options?.delay });
+		logger.info(`Typed into ${selector}: ${text.substring(0, 20)}...`);
+	}
+	async select(selector, values, frameOptions) {
+		const page = await this.collector.getActivePage();
+		await (await this.resolveFrame(page, frameOptions)).select(selector, ...values);
+		logger.info(`Selected in ${selector}: ${values.join(", ")}`);
+	}
+	async hover(selector, frameOptions) {
+		const page = await this.collector.getActivePage();
+		await (await this.resolveFrame(page, frameOptions)).hover(selector);
+		logger.info(`Hovered: ${selector}`);
+	}
+	async scroll(options) {
+		await (await this.collector.getActivePage()).evaluate((opts) => {
+			window.scrollTo(opts.x || 0, opts.y || 0);
+		}, options);
+		logger.info(`Scrolled to: x=${options.x || 0}, y=${options.y || 0}`);
+	}
+	async waitForSelector(selector, timeout) {
+		try {
+			const page = await this.collector.getActivePage();
+			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);
+			logger.info(`Selector appeared: ${selector}`);
+			return {
+				success: true,
+				element,
+				message: `Selector appeared: ${selector}`
+			};
+		} catch (error) {
+			logger.error(`waitForSelector timeout for ${selector}:`, error);
+			return {
+				success: false,
+				message: `Timeout waiting for selector: ${selector}`
+			};
+		}
+	}
+	async waitForNavigation(timeout) {
+		await (await this.collector.getActivePage()).waitForNavigation({
+			waitUntil: "networkidle2",
+			timeout: timeout || 3e4
+		});
+		logger.info("Navigation completed");
+	}
+	async evaluate(code, frameOptions) {
+		const page = await this.collector.getActivePage();
+		if (frameOptions?.frameUrl || frameOptions?.frameSelector) {
+			const result = await evaluateOnContextWithTimeout(page, await this.resolveFrame(page, frameOptions), code);
+			logger.info("JavaScript executed (in frame)");
+			return result;
+		}
+		const result = await evaluateWithTimeout(page, code);
+		logger.info("JavaScript executed");
+		return result;
+	}
+	/**
+	* Resolve a child frame from the active page.
+	* When no options are provided (or both fields are undefined), returns page.mainFrame().
+	*/
+	async resolveFrame(page, options) {
+		if (!options) return page.mainFrame();
+		if (options.frameUrl) {
+			const frames = page.frames();
+			const frame = frames.find((f) => f.url().includes(options.frameUrl));
+			if (!frame) {
+				const available = frames.map((f) => f.url()).filter((u) => u && u !== "about:blank");
+				throw new Error(`No frame matching URL substring "${options.frameUrl}". Available frames: ${available.join(", ") || "(none)"}`);
+			}
+			return frame;
+		}
+		if (options.frameSelector) {
+			await page.waitForSelector(options.frameSelector, { timeout: PAGE_FRAME_SELECTOR_TIMEOUT_MS }).catch(() => null);
+			const handle = await page.$(options.frameSelector);
+			if (!handle) throw new Error(`No element found for iframe selector: ${options.frameSelector}`);
+			const frame = await handle.contentFrame();
+			if (!frame) throw new Error(`Element "${options.frameSelector}" exists but has no content frame (not an iframe or not yet loaded).`);
+			return frame;
+		}
+		return page.mainFrame();
+	}
+	/** List all frames in the active page with URL and name info. */
+	async listFrames() {
+		const page = await this.collector.getActivePage();
+		const mainFrame = page.mainFrame();
+		return page.frames().map((frame) => ({
+			url: frame.url(),
+			name: frame.name() || "",
+			id: frame["_id"] || "",
+			isMainFrame: frame === mainFrame
+		}));
+	}
+	async getURL() {
+		return (await this.collector.getActivePage()).url();
+	}
+	async getTitle() {
+		return await (await this.collector.getActivePage()).title();
+	}
+	async getContent() {
+		return await (await this.collector.getActivePage()).content();
+	}
+	async screenshot(options) {
+		const page = await this.collector.getActivePage();
+		const screenshotOpts = {
+			path: options?.path,
+			type: options?.type || "png",
+			quality: options?.quality,
+			fullPage: options?.fullPage || false
+		};
+		if (options?.clip) {
+			screenshotOpts.clip = options.clip;
+			screenshotOpts.fullPage = false;
+		}
+		const buffer = await page.screenshot(screenshotOpts);
+		logger.info(`Screenshot taken${options?.path ? `: ${options.path}` : ""}`);
+		return buffer;
+	}
+	async getPerformanceMetrics() {
+		const metrics = await evaluateWithTimeout(await this.collector.getActivePage(), () => {
+			const perf = performance.getEntriesByType("navigation")[0];
+			return {
+				domContentLoaded: perf.domContentLoadedEventEnd - perf.domContentLoadedEventStart,
+				loadComplete: perf.loadEventEnd - perf.loadEventStart,
+				dns: perf.domainLookupEnd - perf.domainLookupStart,
+				tcp: perf.connectEnd - perf.connectStart,
+				request: perf.responseStart - perf.requestStart,
+				response: perf.responseEnd - perf.responseStart,
+				total: perf.loadEventEnd - perf.fetchStart,
+				resources: performance.getEntriesByType("resource").length
+			};
+		});
+		logger.info("Performance metrics retrieved");
+		return metrics;
+	}
+	async injectScript(scriptContent) {
+		await evaluateWithTimeout(await this.collector.getActivePage(), (script) => {
+			const scriptElement = document.createElement("script");
+			scriptElement.textContent = script;
+			document.head.appendChild(scriptElement);
+		}, scriptContent);
+		logger.info("Script injected into page");
+	}
+	async setCookies(cookies) {
+		await (await this.collector.getActivePage()).setCookie(...cookies);
+		logger.info(`Set ${cookies.length} cookies`);
+	}
+	async getCookies() {
+		const cookies = await (await this.collector.getActivePage()).cookies();
+		logger.info(`Retrieved ${cookies.length} cookies`);
+		return cookies;
+	}
+	async clearCookies() {
+		const page = await this.collector.getActivePage();
+		const cookies = await page.cookies();
+		await page.deleteCookie(...cookies);
+		logger.info("All cookies cleared");
+	}
+	async setViewport(width, height) {
+		await (await this.collector.getActivePage()).setViewport({
+			width,
+			height
+		});
+		logger.info(`Viewport set to ${width}x${height}`);
+	}
+	async emulateDevice(deviceName) {
+		const page = await this.collector.getActivePage();
+		const devices = {
+			iPhone: {
+				viewport: {
+					width: 375,
+					height: 812,
+					isMobile: true
+				},
+				userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15"
+			},
+			iPad: {
+				viewport: {
+					width: 768,
+					height: 1024,
+					isMobile: true
+				},
+				userAgent: "Mozilla/5.0 (iPad; CPU OS 14_0 like Mac OS X) AppleWebKit/605.1.15"
+			},
+			Android: {
+				viewport: {
+					width: 360,
+					height: 640,
+					isMobile: true
+				},
+				userAgent: "Mozilla/5.0 (Linux; Android 10) AppleWebKit/537.36 Chrome/91.0.4472.120"
+			}
+		};
+		const normalized = String(deviceName || "").trim().toLowerCase();
+		let resolvedDevice = null;
+		if (normalized.includes("iphone")) resolvedDevice = "iPhone";
+		else if (normalized.includes("ipad")) resolvedDevice = "iPad";
+		else if (normalized.includes("android") || normalized.includes("pixel")) resolvedDevice = "Android";
+		if (!resolvedDevice) throw new Error(`Unsupported device "${deviceName}". Supported values include: iPhone, iPad, Android (aliases like "iPhone 13" are accepted).`);
+		const device = devices[resolvedDevice];
+		await page.setViewport(device.viewport);
+		await page.setUserAgent(device.userAgent);
+		logger.info(`Emulating ${resolvedDevice} (input: ${deviceName})`);
+		return resolvedDevice;
+	}
+	async waitForNetworkIdle(timeout = PAGE_NETWORK_IDLE_TIMEOUT_MS) {
+		await (await this.collector.getActivePage()).waitForNetworkIdle({ timeout });
+		logger.info("Network is idle");
+	}
+	async getLocalStorage() {
+		const storage = await (await this.collector.getActivePage()).evaluate(() => {
+			const items = {};
+			for (let i = 0; i < localStorage.length; i++) {
+				const key = localStorage.key(i);
+				if (key) items[key] = localStorage.getItem(key) || "";
+			}
+			return items;
+		});
+		logger.info(`Retrieved ${Object.keys(storage).length} localStorage items`);
+		return storage;
+	}
+	async setLocalStorage(key, value) {
+		await (await this.collector.getActivePage()).evaluate((k, v) => {
+			localStorage.setItem(k, v);
+		}, key, value);
+		logger.info(`Set localStorage: ${key}`);
+	}
+	async clearLocalStorage() {
+		await (await this.collector.getActivePage()).evaluate(() => {
+			localStorage.clear();
+		});
+		logger.info("LocalStorage cleared");
+	}
+	async pressKey(key) {
+		await (await this.collector.getActivePage()).keyboard.press(key);
+		logger.info(`Pressed key: ${key}`);
+	}
+	async uploadFile(selector, filePath) {
+		const input = await (await this.collector.getActivePage()).$(selector);
+		if (!input) throw new Error(`File input not found: ${selector}`);
+		await input.uploadFile(filePath);
+		logger.info(`File uploaded: ${filePath}`);
+	}
+	async getAllLinks() {
+		const links = await (await this.collector.getActivePage()).evaluate(() => {
+			const anchors = document.querySelectorAll("a[href]");
+			const result = [];
+			for (let i = 0; i < anchors.length; i++) {
+				const anchor = anchors[i];
+				result.push({
+					text: anchor.textContent?.trim() || "",
+					href: anchor.href
+				});
+			}
+			return result;
+		});
+		logger.info(`Found ${links.length} links`);
+		return links;
+	}
+	async getPage() {
+		return await this.collector.getActivePage();
+	}
+};
+/**
+* Pre-flight CDP health check: verify the page CDP target is responsive.
+* After debugger enable + pause/resume, the Playwright CDP session can enter
+* a zombie state where Runtime.evaluate hangs indefinitely without firing
+* 'disconnected'. Without this check, page.evaluate() blocks for the full 30 s
+* timeout — with this check we fail fast (~3 s) with a clear message.
+*/
+async function checkPageCDPHealth(page, timeoutMs = 500) {
+	const ac = new AbortController();
+	const timer = setTimeout$1(timeoutMs, void 0, { signal: ac.signal }).then(() => {
+		throw new Error("cdp_unreachable");
+	});
+	try {
+		const cdp = await Promise.race([page.createCDPSession(), timer]);
+		await Promise.race([cdp.send("Runtime.evaluate", {
+			expression: "1",
+			returnByValue: true
+		}), timer]);
+	} catch (err) {
+		if ((err instanceof Error ? err.message : String(err)) === "cdp_unreachable") throw new Error("CDP session unresponsive — the debugger may be blocking page evaluation. Call debugger_lifecycle({ action: 'disable' })() before this tool, or run it before debugger_lifecycle({ action: 'enable' })().", { cause: err });
+		throw err;
+	} finally {
+		ac.abort();
+	}
+}
+async function evaluateOnContextWithTimeout(page, context, pageFunction, ...args) {
+	const timeoutMs = 3e4;
+	await checkPageCDPHealth(page);
+	return Promise.race([context.evaluate(pageFunction, ...[...args]), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`page.evaluate timed out after ${timeoutMs}ms`)), timeoutMs))]);
+}
+async function evaluateWithTimeout(page, pageFunction, ...args) {
+	return evaluateOnContextWithTimeout(page, page, pageFunction, ...args);
+}
+/**
+* Wrap a page.evaluateOnNewDocument() call with:
+* 1. A CDP pre-flight health check
+* 2. A hard timeout (30 s) as a backstop
+*/
+async function evaluateOnNewDocumentWithTimeout(page, pageFunction, ...args) {
+	const timeoutMs = 3e4;
+	await checkPageCDPHealth(page);
+	return Promise.race([page.evaluateOnNewDocument(pageFunction, ...[...args]), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`page.evaluateOnNewDocument timed out after ${timeoutMs}ms`)), timeoutMs))]);
+}
+/**
+* Wrap page.coverage.startJSCoverage() with a timeout.
+*/
+async function coverageStartJSWithTimeout(page, options) {
+	const timeoutMs = 3e4;
+	return Promise.race([page.coverage.startJSCoverage(options), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`coverage.startJSCoverage timed out after ${timeoutMs}ms`)), timeoutMs))]);
+}
+/**
+* Wrap page.coverage.startCSSCoverage() with a timeout.
+*/
+async function coverageStartCSSWithTimeout(page, options) {
+	const timeoutMs = 3e4;
+	return Promise.race([page.coverage.startCSSCoverage(options), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`coverage.startCSSCoverage timed out after ${timeoutMs}ms`)), timeoutMs))]);
+}
+/**
+* Wrap page.coverage.stopJSCoverage() with a timeout.
+*/
+async function coverageStopJSWithTimeout(page) {
+	const timeoutMs = 3e4;
+	return Promise.race([page.coverage.stopJSCoverage(), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`coverage.stopJSCoverage timed out after ${timeoutMs}ms`)), timeoutMs))]);
+}
+/**
+* Wrap page.coverage.stopCSSCoverage() with a timeout.
+*/
+async function coverageStopCSSWithTimeout(page) {
+	const timeoutMs = 3e4;
+	return Promise.race([page.coverage.stopCSSCoverage(), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`coverage.stopCSSCoverage timed out after ${timeoutMs}ms`)), timeoutMs))]);
+}
+//#endregion
+export { coverageStopJSWithTimeout as a, coverageStopCSSWithTimeout as i, coverageStartCSSWithTimeout as n, evaluateOnNewDocumentWithTimeout as o, coverageStartJSWithTimeout as r, evaluateWithTimeout as s, PageController as t };