@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/ConsoleMonitor-CPVQW1Y-.mjs

@@ -0,0 +1,2201 @@
+import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { t as PrerequisiteError } from "./PrerequisiteError-Dl33Svkz.mjs";
+import { randomUUID } from "node:crypto";
+//#region src/modules/monitor/NetworkMonitor.interceptors.ts
+function buildXHRInterceptorCode(maxRecords) {
+	return `
+      (function() {
+        if (window.__xhrInterceptorInstalled) {
+          console.log('[XHRInterceptor] Already installed');
+          return;
+        }
+        window.__xhrInterceptorInstalled = true;
+
+        const originalXHR = window.__originalXMLHttpRequestForHook || window.XMLHttpRequest;
+        window.__originalXMLHttpRequestForHook = originalXHR;
+        if (!window.__xhrRequests) {
+          window.__xhrRequests = [];
+        }
+        const xhrRequests = window.__xhrRequests;
+
+        window.XMLHttpRequest = function() {
+          const xhr = new originalXHR();
+          const requestInfo = {
+            method: '',
+            url: '',
+            requestHeaders: {},
+            responseHeaders: {},
+            status: 0,
+            response: null,
+            timestamp: Date.now(),
+          };
+
+          const originalOpen = xhr.open;
+          xhr.open = function(method, url, ...args) {
+            requestInfo.method = method;
+            requestInfo.url = url;
+            console.log('[XHRInterceptor] XHR opened:', method, url);
+            return originalOpen.call(xhr, method, url, ...args);
+          };
+
+          const originalSetRequestHeader = xhr.setRequestHeader;
+          xhr.setRequestHeader = function(header, value) {
+            requestInfo.requestHeaders[header] = value;
+            return originalSetRequestHeader.call(xhr, header, value);
+          };
+
+          const originalSend = xhr.send;
+          xhr.send = function(body) {
+            let bodySize = 0;
+            try {
+              if (typeof body === 'string') bodySize = body.length;
+              else if (body && typeof body.byteLength === 'number') bodySize = body.byteLength;
+              else if (body && typeof body.size === 'number') bodySize = body.size;
+            } catch {}
+            console.log('[XHRInterceptor] XHR sent:', requestInfo.url, 'BodySize:', bodySize);
+
+            xhr.addEventListener('load', function() {
+              requestInfo.status = xhr.status;
+              requestInfo.response = xhr.response;
+              requestInfo.responseHeaders = xhr.getAllResponseHeaders();
+
+              xhrRequests.push(requestInfo);
+              if (xhrRequests.length > ${maxRecords}) {
+                xhrRequests.splice(0, xhrRequests.length - ${maxRecords});
+              }
+              console.log('[XHRInterceptor] XHR completed:', requestInfo.url, 'Status:', xhr.status);
+            });
+
+            return originalSend.call(xhr, body);
+          };
+
+          return xhr;
+        };
+
+        window.__getXHRRequests = function() {
+          return window.__xhrRequests || [];
+        };
+
+        console.log('[XHRInterceptor] XHR interceptor installed');
+      })();
+    `;
+}
+function buildFetchInterceptorCode(maxRecords) {
+	return `
+      (function() {
+        if (window.__fetchInterceptorInstalled) {
+          console.log('[FetchInterceptor] Already installed');
+          return;
+        }
+        window.__fetchInterceptorInstalled = true;
+
+        const originalFetch = window.__originalFetchForHook || window.fetch;
+        window.__originalFetchForHook = originalFetch;
+        if (!window.__fetchRequests) {
+          window.__fetchRequests = [];
+        }
+        const fetchRequests = window.__fetchRequests;
+
+        window.fetch = function(url, options = {}) {
+          const requestInfo = {
+            url: typeof url === 'string' ? url : url.url,
+            method: options.method || 'GET',
+            headers: options.headers || {},
+            body: options.body,
+            timestamp: Date.now(),
+            response: null,
+            status: 0,
+          };
+
+          console.log('[FetchInterceptor] Fetch called:', requestInfo.method, requestInfo.url);
+
+          return originalFetch.call(window, url, options).then(async (response) => {
+            requestInfo.status = response.status;
+
+            const clonedResponse = response.clone();
+            try {
+              requestInfo.response = await clonedResponse.text();
+            } catch (e) {
+              requestInfo.response = '[Unable to read response]';
+            }
+
+            fetchRequests.push(requestInfo);
+            if (fetchRequests.length > ${maxRecords}) {
+              fetchRequests.splice(0, fetchRequests.length - ${maxRecords});
+            }
+            // Auto-persist compact summary to localStorage so data survives context compression
+            try {
+              const summary = { url: requestInfo.url, method: requestInfo.method, status: requestInfo.status, ts: requestInfo.timestamp };
+              const prev = JSON.parse(localStorage.getItem('__capturedAPIs') || '[]');
+              prev.push(summary);
+              if (prev.length > 500) prev.splice(0, prev.length - 500);
+              localStorage.setItem('__capturedAPIs', JSON.stringify(prev));
+            } catch(e) {
+              // best-effort persistence only; ignore quota or serialization failures
+            }
+            console.log('[FetchInterceptor] Fetch completed:', requestInfo.url, 'Status:', response.status);
+
+            return response;
+          }).catch((error) => {
+            console.error('[FetchInterceptor] Fetch failed:', requestInfo.url, error);
+            throw error;
+          });
+        };
+
+        window.__getFetchRequests = function() {
+          return window.__fetchRequests || [];
+        };
+
+        console.log('[FetchInterceptor] Fetch interceptor installed');
+      })();
+    `;
+}
+const CLEAR_INJECTED_BUFFERS_EXPRESSION = `
+          (() => {
+            const xhrStore = Array.isArray(window.__xhrRequests)
+              ? window.__xhrRequests
+              : (typeof window.__getXHRRequests === 'function' ? window.__getXHRRequests() : null);
+            const fetchStore = Array.isArray(window.__fetchRequests)
+              ? window.__fetchRequests
+              : (typeof window.__getFetchRequests === 'function' ? window.__getFetchRequests() : null);
+
+            const xhrCleared = Array.isArray(xhrStore) ? xhrStore.length : 0;
+            const fetchCleared = Array.isArray(fetchStore) ? fetchStore.length : 0;
+
+            if (Array.isArray(xhrStore)) xhrStore.length = 0;
+            if (Array.isArray(fetchStore)) fetchStore.length = 0;
+
+            return { xhrCleared, fetchCleared };
+          })()
+        `;
+const RESET_INJECTED_INTERCEPTORS_EXPRESSION = `
+          (() => {
+            let xhrReset = false;
+            let fetchReset = false;
+
+            if (window.__originalXMLHttpRequestForHook) {
+              window.XMLHttpRequest = window.__originalXMLHttpRequestForHook;
+              xhrReset = true;
+            }
+
+            if (window.__originalFetchForHook) {
+              window.fetch = window.__originalFetchForHook;
+              fetchReset = true;
+            }
+
+            if (Array.isArray(window.__xhrRequests)) window.__xhrRequests.length = 0;
+            if (Array.isArray(window.__fetchRequests)) window.__fetchRequests.length = 0;
+
+            window.__xhrInterceptorInstalled = false;
+            window.__fetchInterceptorInstalled = false;
+            delete window.__getXHRRequests;
+            delete window.__getFetchRequests;
+
+            return { xhrReset, fetchReset };
+          })()
+        `;
+//#endregion
+//#region src/modules/monitor/NetworkMonitor.impl.ts
+const isObjectRecord = (value) => typeof value === "object" && value !== null;
+const isRequestWillBeSentPayload = (value) => {
+	if (!isObjectRecord(value) || typeof value.requestId !== "string") return false;
+	if (!isObjectRecord(value.request)) return false;
+	if (typeof value.request.url !== "string" || typeof value.request.method !== "string") return false;
+	if (value.request.postData !== void 0 && typeof value.request.postData !== "string") return false;
+	return typeof value.timestamp === "number";
+};
+const isResponseReceivedPayload = (value) => {
+	if (!isObjectRecord(value) || typeof value.requestId !== "string") return false;
+	if (!isObjectRecord(value.response)) return false;
+	if (typeof value.response.url !== "string" || typeof value.response.status !== "number" || typeof value.response.statusText !== "string" || typeof value.response.mimeType !== "string") return false;
+	return typeof value.timestamp === "number";
+};
+const isLoadingFinishedPayload = (value) => isObjectRecord(value) && typeof value.requestId === "string";
+const isResponseBodyPayload = (value) => isObjectRecord(value) && typeof value.body === "string" && typeof value.base64Encoded === "boolean";
+const asStringRecord = (value) => isObjectRecord(value) ? value : {};
+const toRuntimeEvaluateValue = (value) => {
+	if (!isObjectRecord(value)) return;
+	const runtimeResult = value.result;
+	if (!isObjectRecord(runtimeResult)) return;
+	return runtimeResult.value;
+};
+const toFiniteNumber = (value, fallback = 0) => typeof value === "number" && Number.isFinite(value) ? value : fallback;
+const toBoolean = (value, fallback) => typeof value === "boolean" ? value : fallback;
+var NetworkMonitor = class {
+	networkEnabled = false;
+	requests = /* @__PURE__ */ new Map();
+	responses = /* @__PURE__ */ new Map();
+	MAX_NETWORK_RECORDS = 500;
+	MAX_INJECTED_RECORDS = 500;
+	JS_RESPONSE_CONCURRENCY = 6;
+	/** LRU cache for response bodies, auto-captured on loadingFinished. */
+	responseBodyCache = /* @__PURE__ */ new Map();
+	MAX_BODY_CACHE_ENTRIES = 200;
+	networkListeners = {};
+	constructor(cdpSession) {
+		this.cdpSession = cdpSession;
+		this.cdpSession.on("disconnected", () => {
+			logger.warn("NetworkMonitor: CDP session disconnected");
+			this.networkEnabled = false;
+			this.networkListeners = {};
+		});
+	}
+	async enable() {
+		if (!this.cdpSession) throw new Error("CDP session not initialized");
+		if (this.networkEnabled) {
+			logger.warn("Network monitoring already enabled");
+			return;
+		}
+		try {
+			await this.cdpSession.send("Network.enable", {
+				maxTotalBufferSize: 1e7,
+				maxResourceBufferSize: 5e6,
+				maxPostDataSize: 65536
+			});
+			logger.info("Network domain enabled");
+			this.networkListeners.requestWillBeSent = (params) => {
+				if (!isRequestWillBeSentPayload(params)) {
+					logger.debug("Skipping malformed Network.requestWillBeSent payload");
+					return;
+				}
+				const request = {
+					requestId: params.requestId,
+					url: params.request.url,
+					method: params.request.method,
+					headers: asStringRecord(params.request.headers),
+					postData: params.request.postData,
+					timestamp: params.timestamp,
+					type: params.type,
+					initiator: params.initiator
+				};
+				this.requests.set(params.requestId, request);
+				if (this.requests.size > this.MAX_NETWORK_RECORDS) {
+					const firstKey = this.requests.keys().next().value;
+					if (firstKey) this.requests.delete(firstKey);
+				}
+				logger.debug(`Network request captured: ${params.request.method} ${params.request.url}`);
+			};
+			this.networkListeners.responseReceived = (params) => {
+				if (!isResponseReceivedPayload(params)) {
+					logger.debug("Skipping malformed Network.responseReceived payload");
+					return;
+				}
+				const response = {
+					requestId: params.requestId,
+					url: params.response.url,
+					status: params.response.status,
+					statusText: params.response.statusText,
+					headers: asStringRecord(params.response.headers),
+					mimeType: params.response.mimeType,
+					timestamp: params.timestamp,
+					fromCache: params.response.fromDiskCache || params.response.fromServiceWorker,
+					timing: params.response.timing
+				};
+				this.responses.set(params.requestId, response);
+				if (this.responses.size > this.MAX_NETWORK_RECORDS) {
+					const firstKey = this.responses.keys().next().value;
+					if (firstKey) this.responses.delete(firstKey);
+				}
+				logger.debug(`Network response captured: ${params.response.status} ${params.response.url}`);
+			};
+			this.networkListeners.loadingFinished = (params) => {
+				if (!isLoadingFinishedPayload(params)) {
+					logger.debug("Skipping malformed Network.loadingFinished payload");
+					return;
+				}
+				logger.debug(`Network loading finished: ${params.requestId}`);
+				this.captureResponseBody(params.requestId).catch((err) => {
+					logger.debug(`[BodyCache] Auto-capture failed for ${params.requestId}: ${err instanceof Error ? err.message : String(err)}`);
+				});
+			};
+			this.cdpSession.on("Network.requestWillBeSent", this.networkListeners.requestWillBeSent);
+			this.cdpSession.on("Network.responseReceived", this.networkListeners.responseReceived);
+			this.cdpSession.on("Network.loadingFinished", this.networkListeners.loadingFinished);
+			this.networkEnabled = true;
+			logger.info(" Network monitoring enabled successfully", {
+				requestListeners: !!this.networkListeners.requestWillBeSent,
+				responseListeners: !!this.networkListeners.responseReceived,
+				loadingListeners: !!this.networkListeners.loadingFinished
+			});
+		} catch (error) {
+			logger.error(" Failed to enable network monitoring:", error);
+			this.networkEnabled = false;
+			throw error;
+		}
+	}
+	/**
+	* Auto-capture a response body into the LRU cache.
+	* Called from the loadingFinished listener so bodies are available
+	* even after Chrome's internal buffer is reclaimed.
+	*/
+	async captureResponseBody(requestId) {
+		if (this.responseBodyCache.has(requestId)) return;
+		const response = this.responses.get(requestId);
+		if (!response) return;
+		if (response.fromCache) return;
+		try {
+			const rawResult = await this.cdpSession.send("Network.getResponseBody", { requestId });
+			if (!isResponseBodyPayload(rawResult)) return;
+			if (rawResult.body.length > 1048576) {
+				logger.debug(`[BodyCache] Skipping oversized body for ${requestId} (${rawResult.body.length} chars)`);
+				return;
+			}
+			if (this.responseBodyCache.size >= this.MAX_BODY_CACHE_ENTRIES) {
+				const oldestKey = this.responseBodyCache.keys().next().value;
+				if (oldestKey) this.responseBodyCache.delete(oldestKey);
+			}
+			this.responseBodyCache.set(requestId, {
+				body: rawResult.body,
+				base64Encoded: rawResult.base64Encoded
+			});
+			logger.debug(`[BodyCache] Cached body for ${requestId} (${rawResult.body.length} chars, url=${response.url})`);
+		} catch (err) {
+			logger.debug(`[BodyCache] Could not capture body for ${requestId}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	async disable() {
+		if (!this.networkEnabled) return;
+		if (this.networkListeners.requestWillBeSent) this.cdpSession.off("Network.requestWillBeSent", this.networkListeners.requestWillBeSent);
+		if (this.networkListeners.responseReceived) this.cdpSession.off("Network.responseReceived", this.networkListeners.responseReceived);
+		if (this.networkListeners.loadingFinished) this.cdpSession.off("Network.loadingFinished", this.networkListeners.loadingFinished);
+		try {
+			await this.cdpSession.send("Network.disable");
+		} catch (error) {
+			logger.warn("Failed to disable Network domain:", error);
+		}
+		this.networkListeners = {};
+		this.networkEnabled = false;
+		logger.info("Network monitoring disabled");
+	}
+	isEnabled() {
+		return this.networkEnabled;
+	}
+	getStatus() {
+		return {
+			enabled: this.networkEnabled,
+			requestCount: this.requests.size,
+			responseCount: this.responses.size,
+			listenerCount: Object.keys(this.networkListeners).filter((key) => this.networkListeners[key] !== void 0).length,
+			cdpSessionActive: true
+		};
+	}
+	getRequests(filter) {
+		let requests = Array.from(this.requests.values());
+		if (filter?.url) requests = requests.filter((req) => req.url.includes(filter.url));
+		if (filter?.method) requests = requests.filter((req) => req.method === filter.method);
+		if (filter?.limit) requests = requests.slice(-filter.limit);
+		return requests;
+	}
+	getResponses(filter) {
+		let responses = Array.from(this.responses.values());
+		if (filter?.url) responses = responses.filter((res) => res.url.includes(filter.url));
+		if (filter?.status) responses = responses.filter((res) => res.status === filter.status);
+		if (filter?.limit) responses = responses.slice(-filter.limit);
+		return responses;
+	}
+	getActivity(requestId) {
+		return {
+			request: this.requests.get(requestId),
+			response: this.responses.get(requestId)
+		};
+	}
+	async getResponseBody(requestId) {
+		if (!this.cdpSession) throw new Error("CDP session not initialized");
+		if (!this.networkEnabled) {
+			logger.error("Network monitoring is not enabled. Call enable() with enableNetwork: true first.");
+			return null;
+		}
+		const cached = this.responseBodyCache.get(requestId);
+		if (cached) {
+			this.responseBodyCache.delete(requestId);
+			this.responseBodyCache.set(requestId, cached);
+			logger.debug(`[BodyCache] Cache hit for ${requestId}`);
+			return cached;
+		}
+		const request = this.requests.get(requestId);
+		const response = this.responses.get(requestId);
+		if (!request) {
+			logger.error(`Request not found: ${requestId}. Make sure network monitoring was enabled before the request.`);
+			return null;
+		}
+		if (!response) {
+			logger.warn(`Response not yet received for request: ${requestId}. The request may still be pending.`);
+			return null;
+		}
+		try {
+			const rawResult = await this.cdpSession.send("Network.getResponseBody", { requestId });
+			if (!isResponseBodyPayload(rawResult)) {
+				logger.error(`Unexpected response body payload for ${requestId}`);
+				return null;
+			}
+			logger.info(`Response body retrieved for request: ${requestId}`, {
+				url: response.url,
+				status: response.status,
+				size: rawResult.body.length,
+				base64: rawResult.base64Encoded
+			});
+			return {
+				body: rawResult.body,
+				base64Encoded: rawResult.base64Encoded
+			};
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			logger.error(`Failed to get response body for ${requestId}:`, {
+				url: response.url,
+				status: response.status,
+				error: errorMessage,
+				hint: "The response body may not be available for this request type (e.g., cached, redirected, or failed requests)"
+			});
+			return null;
+		}
+	}
+	async getAllJavaScriptResponses() {
+		const candidates = Array.from(this.responses.entries()).filter(([, response]) => {
+			return response.mimeType.includes("javascript") || response.url.endsWith(".js") || response.url.includes(".js?");
+		});
+		const jsResponses = [];
+		for (let i = 0; i < candidates.length; i += this.JS_RESPONSE_CONCURRENCY) {
+			const batch = candidates.slice(i, i + this.JS_RESPONSE_CONCURRENCY);
+			const batchResults = await Promise.all(batch.map(async ([requestId, response]) => {
+				const bodyResult = await this.getResponseBody(requestId);
+				if (!bodyResult) return null;
+				const content = bodyResult.base64Encoded ? Buffer.from(bodyResult.body, "base64").toString("utf-8") : bodyResult.body;
+				return {
+					url: response.url,
+					content,
+					size: content.length,
+					requestId
+				};
+			}));
+			jsResponses.push(...batchResults.filter((value) => value !== null));
+		}
+		logger.info(`Collected ${jsResponses.length} JavaScript responses`);
+		return jsResponses;
+	}
+	clearRecords() {
+		this.requests.clear();
+		this.responses.clear();
+		this.responseBodyCache.clear();
+		logger.info("Network records cleared");
+	}
+	getStats() {
+		const byMethod = {};
+		const byStatus = {};
+		const byType = {};
+		for (const request of this.requests.values()) {
+			byMethod[request.method] = (byMethod[request.method] || 0) + 1;
+			if (request.type) byType[request.type] = (byType[request.type] || 0) + 1;
+		}
+		for (const response of this.responses.values()) byStatus[response.status] = (byStatus[response.status] || 0) + 1;
+		return {
+			totalRequests: this.requests.size,
+			totalResponses: this.responses.size,
+			byMethod,
+			byStatus,
+			byType
+		};
+	}
+	async injectXHRInterceptor(options) {
+		if (!this.cdpSession) throw new Error("CDP session not initialized");
+		const interceptorCode = buildXHRInterceptorCode(this.MAX_INJECTED_RECORDS);
+		if (options?.persistent) {
+			await this.cdpSession.send("Page.addScriptToEvaluateOnNewDocument", { source: interceptorCode });
+			logger.info("XHR interceptor injected (persistent)");
+		} else {
+			await this.cdpSession.send("Runtime.evaluate", { expression: interceptorCode });
+			logger.info("XHR interceptor injected");
+		}
+	}
+	async injectFetchInterceptor(options) {
+		if (!this.cdpSession) throw new Error("CDP session not initialized");
+		const interceptorCode = buildFetchInterceptorCode(this.MAX_INJECTED_RECORDS);
+		if (options?.persistent) {
+			await this.cdpSession.send("Page.addScriptToEvaluateOnNewDocument", { source: interceptorCode });
+			logger.info("Fetch interceptor injected (persistent)");
+		} else {
+			await this.cdpSession.send("Runtime.evaluate", { expression: interceptorCode });
+			logger.info("Fetch interceptor injected");
+		}
+	}
+	async getXHRRequests() {
+		if (!this.cdpSession) throw new Error("CDP session not initialized");
+		try {
+			const value = toRuntimeEvaluateValue(await this.cdpSession.send("Runtime.evaluate", {
+				expression: "window.__getXHRRequests ? window.__getXHRRequests() : []",
+				returnByValue: true
+			}));
+			if (!Array.isArray(value)) return [];
+			return value.filter((entry) => isObjectRecord(entry));
+		} catch (error) {
+			logger.error("Failed to get XHR requests:", error);
+			return [];
+		}
+	}
+	async getFetchRequests() {
+		if (!this.cdpSession) throw new Error("CDP session not initialized");
+		try {
+			const value = toRuntimeEvaluateValue(await this.cdpSession.send("Runtime.evaluate", {
+				expression: "window.__getFetchRequests ? window.__getFetchRequests() : []",
+				returnByValue: true
+			}));
+			if (!Array.isArray(value)) return [];
+			return value.filter((entry) => isObjectRecord(entry));
+		} catch (error) {
+			logger.error("Failed to get Fetch requests:", error);
+			return [];
+		}
+	}
+	async clearInjectedBuffers() {
+		if (!this.cdpSession) throw new Error("CDP session not initialized");
+		try {
+			const value = toRuntimeEvaluateValue(await this.cdpSession.send("Runtime.evaluate", {
+				expression: CLEAR_INJECTED_BUFFERS_EXPRESSION,
+				returnByValue: true
+			}));
+			if (!isObjectRecord(value)) return {
+				xhrCleared: 0,
+				fetchCleared: 0
+			};
+			return {
+				xhrCleared: toFiniteNumber(value.xhrCleared),
+				fetchCleared: toFiniteNumber(value.fetchCleared)
+			};
+		} catch (error) {
+			logger.error("Failed to clear injected network buffers:", error);
+			return {
+				xhrCleared: 0,
+				fetchCleared: 0
+			};
+		}
+	}
+	async resetInjectedInterceptors() {
+		if (!this.cdpSession) throw new Error("CDP session not initialized");
+		try {
+			const value = toRuntimeEvaluateValue(await this.cdpSession.send("Runtime.evaluate", {
+				expression: RESET_INJECTED_INTERCEPTORS_EXPRESSION,
+				returnByValue: true
+			}));
+			if (!isObjectRecord(value)) return {
+				xhrReset: false,
+				fetchReset: false
+			};
+			return {
+				xhrReset: toBoolean(value.xhrReset, false),
+				fetchReset: toBoolean(value.fetchReset, false)
+			};
+		} catch (error) {
+			logger.error("Failed to reset injected network interceptors:", error);
+			return {
+				xhrReset: false,
+				fetchReset: false
+			};
+		}
+	}
+};
+//#endregion
+//#region src/modules/monitor/PlaywrightNetworkMonitor.ts
+/**
+* Lightweight network monitor for Playwright-based browsers (Camoufox/Firefox).
+* Uses page.on('request'/'response') instead of CDP Network domain.
+*/
+var PlaywrightNetworkMonitor = class {
+	networkEnabled = false;
+	requests = /* @__PURE__ */ new Map();
+	responses = /* @__PURE__ */ new Map();
+	MAX_NETWORK_RECORDS = 500;
+	MAX_INJECTED_RECORDS = 500;
+	requestCounter = 0;
+	/** LRU cache for response bodies, auto-captured on response event. */
+	responseBodyCache = /* @__PURE__ */ new Map();
+	MAX_BODY_CACHE_ENTRIES = 200;
+	requestIdMap = /* @__PURE__ */ new WeakMap();
+	boundOnRequest = null;
+	boundOnResponse = null;
+	constructor(page) {
+		this.page = page;
+	}
+	setPage(page) {
+		if (this.page === page) return;
+		const previousPage = this.page;
+		const wasEnabled = this.networkEnabled;
+		const onRequest = this.boundOnRequest;
+		const onResponse = this.boundOnResponse;
+		if (wasEnabled && previousPage && onRequest) try {
+			previousPage.off("request", onRequest);
+		} catch {}
+		if (wasEnabled && previousPage && onResponse) try {
+			previousPage.off("response", onResponse);
+		} catch {}
+		this.page = page;
+		if (!wasEnabled || !this.page) {
+			if (!this.page) this.networkEnabled = false;
+			return;
+		}
+		if (onRequest) this.page.on("request", onRequest);
+		if (onResponse) this.page.on("response", onResponse);
+	}
+	getPageOrThrow() {
+		if (!this.page) throw new Error("Playwright page not initialized");
+		return this.page;
+	}
+	async evaluateInPage(pageFunction) {
+		const page = this.getPageOrThrow();
+		if (!page.evaluate) throw new Error("Playwright page.evaluate is not available");
+		return page.evaluate(pageFunction);
+	}
+	async evaluateOnNewDocumentInPage(pageFunction) {
+		const page = this.getPageOrThrow();
+		if (!page.evaluateOnNewDocument) throw new Error("Playwright page.evaluateOnNewDocument is not available");
+		return page.evaluateOnNewDocument(pageFunction);
+	}
+	isUnknownArray(value) {
+		return Array.isArray(value);
+	}
+	isClearedBuffersResult(value) {
+		if (!value || typeof value !== "object") return false;
+		const candidate = value;
+		return typeof candidate.xhrCleared === "number" && typeof candidate.fetchCleared === "number";
+	}
+	isResetInterceptorsResult(value) {
+		if (!value || typeof value !== "object") return false;
+		const candidate = value;
+		return typeof candidate.xhrReset === "boolean" && typeof candidate.fetchReset === "boolean";
+	}
+	isPlaywrightLikeRequest(value) {
+		if (!value || typeof value !== "object") return false;
+		const candidate = value;
+		return typeof candidate.url === "function" && typeof candidate.method === "function" && typeof candidate.headers === "function" && typeof candidate.postData === "function" && typeof candidate.resourceType === "function";
+	}
+	isPlaywrightLikeResponse(value) {
+		if (!value || typeof value !== "object") return false;
+		const candidate = value;
+		return typeof candidate.request === "function" && typeof candidate.url === "function" && typeof candidate.status === "function" && typeof candidate.statusText === "function" && typeof candidate.headers === "function";
+	}
+	async enable() {
+		if (this.networkEnabled) {
+			logger.warn("PlaywrightNetworkMonitor already enabled");
+			return;
+		}
+		this.boundOnRequest = (req) => {
+			if (!this.isPlaywrightLikeRequest(req)) return;
+			const requestId = `pw-${++this.requestCounter}`;
+			this.requestIdMap.set(req, requestId);
+			const request = {
+				requestId,
+				url: req.url(),
+				method: req.method(),
+				headers: req.headers(),
+				postData: req.postData() ?? void 0,
+				timestamp: Date.now(),
+				type: req.resourceType()
+			};
+			this.requests.set(requestId, request);
+			if (this.requests.size > this.MAX_NETWORK_RECORDS) {
+				const firstKey = this.requests.keys().next().value;
+				if (firstKey) this.requests.delete(firstKey);
+			}
+		};
+		this.boundOnResponse = (res) => {
+			if (!this.isPlaywrightLikeResponse(res)) return;
+			const req = res.request();
+			const fallbackRequestId = `pw-res-${Date.now()}-${Math.random()}`;
+			const requestId = this.isPlaywrightLikeRequest(req) ? this.requestIdMap.get(req) ?? fallbackRequestId : fallbackRequestId;
+			const response = {
+				requestId,
+				url: res.url(),
+				status: res.status(),
+				statusText: res.statusText(),
+				headers: res.headers(),
+				mimeType: res.headers()["content-type"] ?? "unknown",
+				timestamp: Date.now()
+			};
+			this.responses.set(requestId, response);
+			if (this.responses.size > this.MAX_NETWORK_RECORDS) {
+				const firstKey = this.responses.keys().next().value;
+				if (firstKey) this.responses.delete(firstKey);
+			}
+			if (typeof res.body === "function") {
+				const captureId = requestId;
+				res.body().then((buf) => {
+					if (buf.length > 1048576) {
+						logger.debug(`[PW-BodyCache] Skipping oversized body for ${captureId} (${buf.length} bytes)`);
+						return;
+					}
+					if (this.responseBodyCache.size >= this.MAX_BODY_CACHE_ENTRIES) {
+						const oldestKey = this.responseBodyCache.keys().next().value;
+						if (oldestKey) this.responseBodyCache.delete(oldestKey);
+					}
+					if (/^(text\/|application\/(json|javascript|xml|x-www-form-urlencoded))/i.test(response.mimeType)) this.responseBodyCache.set(captureId, {
+						body: buf.toString("utf-8"),
+						base64Encoded: false
+					});
+					else this.responseBodyCache.set(captureId, {
+						body: buf.toString("base64"),
+						base64Encoded: true
+					});
+					logger.debug(`[PW-BodyCache] Cached body for ${captureId} (${buf.length} bytes)`);
+				}).catch((err) => {
+					logger.debug(`[PW-BodyCache] Could not capture body for ${captureId}: ${err instanceof Error ? err.message : String(err)}`);
+				});
+			}
+		};
+		const page = this.getPageOrThrow();
+		page.on("request", this.boundOnRequest);
+		page.on("response", this.boundOnResponse);
+		this.networkEnabled = true;
+		logger.info("PlaywrightNetworkMonitor enabled");
+	}
+	async disable() {
+		const page = this.getPageOrThrow();
+		if (this.boundOnRequest) {
+			try {
+				page.off("request", this.boundOnRequest);
+			} catch {}
+			this.boundOnRequest = null;
+		}
+		if (this.boundOnResponse) {
+			try {
+				page.off("response", this.boundOnResponse);
+			} catch {}
+			this.boundOnResponse = null;
+		}
+		this.networkEnabled = false;
+		logger.info("PlaywrightNetworkMonitor disabled");
+	}
+	isEnabled() {
+		return this.networkEnabled;
+	}
+	getRequests(filter) {
+		let requests = Array.from(this.requests.values());
+		if (filter?.url) requests = requests.filter((r) => r.url.includes(filter.url));
+		if (filter?.method) requests = requests.filter((r) => r.method.toUpperCase() === filter.method.toUpperCase());
+		if (filter?.limit) requests = requests.slice(-filter.limit);
+		return requests;
+	}
+	getResponses(filter) {
+		let responses = Array.from(this.responses.values());
+		if (filter?.url) responses = responses.filter((r) => r.url.includes(filter.url));
+		if (filter?.status) responses = responses.filter((r) => r.status === filter.status);
+		if (filter?.limit) responses = responses.slice(-filter.limit);
+		return responses;
+	}
+	getStatus() {
+		return {
+			enabled: this.networkEnabled,
+			requestCount: this.requests.size,
+			responseCount: this.responses.size,
+			listenerCount: this.networkEnabled ? 2 : 0,
+			cdpSessionActive: false
+		};
+	}
+	getActivity(requestId) {
+		return {
+			request: this.requests.get(requestId),
+			response: this.responses.get(requestId)
+		};
+	}
+	clearRecords() {
+		this.requests.clear();
+		this.responses.clear();
+		this.responseBodyCache.clear();
+	}
+	getStats() {
+		const requests = Array.from(this.requests.values());
+		const responses = Array.from(this.responses.values());
+		const byMethod = {};
+		requests.forEach((r) => {
+			byMethod[r.method] = (byMethod[r.method] || 0) + 1;
+		});
+		const byStatus = {};
+		responses.forEach((r) => {
+			byStatus[r.status] = (byStatus[r.status] || 0) + 1;
+		});
+		const byType = {};
+		requests.forEach((r) => {
+			const type = r.type || "unknown";
+			byType[type] = (byType[type] || 0) + 1;
+		});
+		return {
+			totalRequests: requests.length,
+			totalResponses: responses.length,
+			byMethod,
+			byStatus,
+			byType
+		};
+	}
+	/** Response body retrieval from LRU cache. */
+	async getResponseBody(requestId) {
+		const cached = this.responseBodyCache.get(requestId);
+		if (cached) {
+			this.responseBodyCache.delete(requestId);
+			this.responseBodyCache.set(requestId, cached);
+			logger.debug(`[PW-BodyCache] Cache hit for ${requestId}`);
+			return cached;
+		}
+		logger.warn(`getResponseBody: no cached body for ${requestId} in Playwright mode`);
+		return null;
+	}
+	/** Inject a script via page.evaluate (Playwright equivalent of CDP Runtime.evaluate). */
+	async injectScript(script) {
+		await this.evaluateInPage(script);
+	}
+	async injectXHRInterceptor(options) {
+		const script = `
+      (function() {
+        if (window.__xhrInterceptorInjected) return;
+        window.__xhrInterceptorInjected = true;
+        const maxRecords = ${this.MAX_INJECTED_RECORDS};
+        const OrigXHR = window.__pwOriginalXMLHttpRequest || window.XMLHttpRequest;
+        window.__pwOriginalXMLHttpRequest = OrigXHR;
+        if (!window.__xhrRequests) window.__xhrRequests = [];
+        window.XMLHttpRequest = function() {
+          const xhr = new OrigXHR();
+          const origOpen = xhr.open.bind(xhr);
+          const origSend = xhr.send.bind(xhr);
+          xhr.open = function(method, url, ...rest) {
+            xhr.__hookMeta = { method, url, timestamp: Date.now() };
+            return origOpen(method, url, ...rest);
+          };
+          xhr.send = function(body) {
+            xhr.addEventListener('load', function() {
+              window.__xhrRequests.push({
+                ...xhr.__hookMeta, body: body ? String(body).slice(0, 2048) : null,
+                status: xhr.status, response: xhr.responseText.slice(0, 2048),
+              });
+              if (window.__xhrRequests.length > maxRecords) {
+                window.__xhrRequests.splice(0, window.__xhrRequests.length - maxRecords);
+              }
+            });
+            return origSend(body);
+          };
+          return xhr;
+        };
+        console.log('[PlaywrightXHR] XHR interceptor injected');
+      })();
+    `;
+		if (options?.persistent) await this.evaluateOnNewDocumentInPage(script);
+		else await this.evaluateInPage(script);
+	}
+	async injectFetchInterceptor(options) {
+		const script = `
+      (function() {
+        if (window.__fetchInterceptorInjected) return;
+        window.__fetchInterceptorInjected = true;
+        const maxRecords = ${this.MAX_INJECTED_RECORDS};
+        const origFetch = window.__pwOriginalFetch || window.fetch;
+        window.__pwOriginalFetch = origFetch;
+        if (!window.__fetchRequests) window.__fetchRequests = [];
+        window.fetch = function(...args) {
+          const [url, opts] = args;
+          const entry = { url: String(url), method: opts?.method || 'GET', timestamp: Date.now() };
+          return origFetch.apply(this, args).then(res => {
+            entry.status = res.status;
+            window.__fetchRequests.push(entry);
+            if (window.__fetchRequests.length > maxRecords) {
+              window.__fetchRequests.splice(0, window.__fetchRequests.length - maxRecords);
+            }
+            // Auto-persist compact summary so data survives context compression
+            try {
+              const s = { url: entry.url, method: entry.method, status: entry.status, ts: entry.timestamp };
+              const prev = JSON.parse(localStorage.getItem('__capturedAPIs') || '[]');
+              prev.push(s);
+              if (prev.length > 500) prev.splice(0, prev.length - 500);
+              localStorage.setItem('__capturedAPIs', JSON.stringify(prev));
+            } catch(e) {}
+            return res;
+          });
+        };
+        console.log('[PlaywrightFetch] Fetch interceptor injected');
+      })();
+    `;
+		if (options?.persistent) await this.evaluateOnNewDocumentInPage(script);
+		else await this.evaluateInPage(script);
+	}
+	async getXHRRequests() {
+		try {
+			const result = await this.evaluateInPage(() => {
+				return window.__xhrRequests ?? [];
+			});
+			return this.isUnknownArray(result) ? result : [];
+		} catch (err) {
+			logger.warn(`[PW] Failed to get XHR requests: ${err instanceof Error ? err.message : String(err)}`);
+			return [];
+		}
+	}
+	async getFetchRequests() {
+		try {
+			const result = await this.evaluateInPage(() => {
+				return window.__fetchRequests ?? [];
+			});
+			return this.isUnknownArray(result) ? result : [];
+		} catch (err) {
+			logger.warn(`[PW] Failed to get fetch requests: ${err instanceof Error ? err.message : String(err)}`);
+			return [];
+		}
+	}
+	async clearInjectedBuffers() {
+		try {
+			const result = await this.evaluateInPage(() => {
+				const bridgeWindow = window;
+				const xhrRequests = bridgeWindow.__xhrRequests;
+				const fetchRequests = bridgeWindow.__fetchRequests;
+				const xhrCleared = Array.isArray(xhrRequests) ? xhrRequests.length : 0;
+				const fetchCleared = Array.isArray(fetchRequests) ? fetchRequests.length : 0;
+				if (Array.isArray(xhrRequests)) xhrRequests.length = 0;
+				if (Array.isArray(fetchRequests)) fetchRequests.length = 0;
+				return {
+					xhrCleared,
+					fetchCleared
+				};
+			});
+			return this.isClearedBuffersResult(result) ? result : {
+				xhrCleared: 0,
+				fetchCleared: 0
+			};
+		} catch (err) {
+			logger.warn(`[PW] Failed to clear injected buffers: ${err instanceof Error ? err.message : String(err)}`);
+			return {
+				xhrCleared: 0,
+				fetchCleared: 0
+			};
+		}
+	}
+	async resetInjectedInterceptors() {
+		try {
+			const result = await this.evaluateInPage(() => {
+				const bridgeWindow = window;
+				let xhrReset = false;
+				let fetchReset = false;
+				if (bridgeWindow.__pwOriginalXMLHttpRequest) {
+					bridgeWindow.XMLHttpRequest = bridgeWindow.__pwOriginalXMLHttpRequest;
+					xhrReset = true;
+				}
+				if (bridgeWindow.__pwOriginalFetch) {
+					bridgeWindow.fetch = bridgeWindow.__pwOriginalFetch;
+					fetchReset = true;
+				}
+				if (Array.isArray(bridgeWindow.__xhrRequests)) bridgeWindow.__xhrRequests.length = 0;
+				if (Array.isArray(bridgeWindow.__fetchRequests)) bridgeWindow.__fetchRequests.length = 0;
+				bridgeWindow.__xhrInterceptorInjected = false;
+				bridgeWindow.__fetchInterceptorInjected = false;
+				return {
+					xhrReset,
+					fetchReset
+				};
+			});
+			return this.isResetInterceptorsResult(result) ? result : {
+				xhrReset: false,
+				fetchReset: false
+			};
+		} catch (err) {
+			logger.warn(`[PW] Failed to reset interceptors: ${err instanceof Error ? err.message : String(err)}`);
+			return {
+				xhrReset: false,
+				fetchReset: false
+			};
+		}
+	}
+	async getAllJavaScriptResponses() {
+		return Array.from(this.responses.values()).filter((r) => r.mimeType.includes("javascript"));
+	}
+};
+//#endregion
+//#region src/modules/monitor/FetchInterceptor.ts
+var FetchInterceptor = class {
+	rules = /* @__PURE__ */ new Map();
+	enabled = false;
+	eventHandler = null;
+	compiledPatterns = /* @__PURE__ */ new Map();
+	constructor(cdpSession) {
+		this.cdpSession = cdpSession;
+	}
+	/**
+	* Enable Fetch domain interception with the given rules.
+	* If already enabled, merges new rules with existing ones.
+	*/
+	async enable(ruleInputs) {
+		const newRules = [];
+		for (const input of ruleInputs) {
+			const rule = this.createRule(input);
+			this.rules.set(rule.id, rule);
+			this.compiledPatterns.set(rule.id, this.compilePattern(rule));
+			newRules.push(rule);
+		}
+		await this.applyRules();
+		if (!this.eventHandler) {
+			this.eventHandler = (params) => {
+				this.handleRequestPaused(params);
+			};
+			this.cdpSession.on("Fetch.requestPaused", this.eventHandler);
+		}
+		this.enabled = true;
+		logger.info(`FetchInterceptor enabled with ${this.rules.size} rule(s)`);
+		return newRules;
+	}
+	/**
+	* Disable all interception, remove all rules, detach event handler.
+	*/
+	async disable() {
+		const count = this.rules.size;
+		if (this.eventHandler) {
+			try {
+				this.cdpSession.off("Fetch.requestPaused", this.eventHandler);
+			} catch {}
+			this.eventHandler = null;
+		}
+		try {
+			await this.cdpSession.send("Fetch.disable");
+		} catch (error) {
+			logger.warn("Fetch.disable failed:", error);
+		}
+		this.rules.clear();
+		this.compiledPatterns.clear();
+		this.enabled = false;
+		logger.info(`FetchInterceptor disabled, removed ${count} rule(s)`);
+		return { removedRules: count };
+	}
+	/**
+	* Remove a specific rule by ID. If no rules remain, disables Fetch domain.
+	*/
+	async removeRule(ruleId) {
+		const removed = this.rules.delete(ruleId);
+		this.compiledPatterns.delete(ruleId);
+		if (removed) if (this.rules.size === 0) await this.disable();
+		else await this.applyRules();
+		return removed;
+	}
+	/**
+	* List all active rules with hit statistics.
+	*/
+	listRules() {
+		const rules = Array.from(this.rules.values());
+		return {
+			enabled: this.enabled,
+			rules,
+			totalHits: rules.reduce((sum, r) => sum + r.hitCount, 0)
+		};
+	}
+	isEnabled() {
+		return this.enabled;
+	}
+	createRule(input) {
+		const headers = [];
+		if (input.responseHeaders) for (const [name, value] of Object.entries(input.responseHeaders)) headers.push({
+			name,
+			value
+		});
+		return {
+			id: randomUUID().slice(0, 8),
+			urlPattern: input.urlPattern,
+			urlPatternType: input.urlPatternType ?? "glob",
+			stage: input.stage ?? "Response",
+			responseCode: input.responseCode ?? 200,
+			responseHeaders: headers,
+			responseBody: input.responseBody ?? "",
+			hitCount: 0,
+			createdAt: Date.now()
+		};
+	}
+	compilePattern(rule) {
+		if (rule.urlPatternType === "regex") try {
+			return new RegExp(rule.urlPattern, "i");
+		} catch {
+			return new RegExp(rule.urlPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+		}
+		const escaped = rule.urlPattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "⟨GLOBSTAR⟩").replace(/\*/g, "[^/]*").replace(/⟨GLOBSTAR⟩/g, ".*");
+		return new RegExp(escaped, "i");
+	}
+	async applyRules() {
+		const patterns = [];
+		for (const rule of this.rules.values()) patterns.push({
+			urlPattern: rule.urlPatternType === "glob" ? rule.urlPattern : "*",
+			requestStage: rule.stage
+		});
+		if (patterns.length === 0) return;
+		try {
+			try {
+				await this.cdpSession.send("Fetch.disable");
+			} catch {}
+			await this.cdpSession.send("Fetch.enable", {
+				patterns: patterns.length > 0 ? patterns : [{
+					urlPattern: "*",
+					requestStage: "Response"
+				}],
+				handleAuthRequests: false
+			});
+		} catch (error) {
+			logger.error("Failed to apply Fetch interception rules:", error);
+			throw error;
+		}
+	}
+	async handleRequestPaused(params) {
+		const requestUrl = params.request.url;
+		for (const [ruleId, rule] of this.rules) {
+			const pattern = this.compiledPatterns.get(ruleId);
+			if (!pattern) continue;
+			if (pattern.test(requestUrl)) {
+				rule.hitCount++;
+				logger.info(`[FetchInterceptor] Rule "${rule.urlPattern}" matched: ${requestUrl}`);
+				try {
+					const headers = [...rule.responseHeaders];
+					if (!headers.some((h) => h.name.toLowerCase() === "content-type")) {
+						const body = rule.responseBody;
+						if (body.startsWith("{") || body.startsWith("[")) headers.push({
+							name: "Content-Type",
+							value: "application/json"
+						});
+						else headers.push({
+							name: "Content-Type",
+							value: "text/plain"
+						});
+					}
+					if (!headers.some((h) => h.name.toLowerCase() === "access-control-allow-origin")) headers.push({
+						name: "Access-Control-Allow-Origin",
+						value: "*"
+					});
+					await this.cdpSession.send("Fetch.fulfillRequest", {
+						requestId: params.requestId,
+						responseCode: rule.responseCode,
+						responseHeaders: headers,
+						body: Buffer.from(rule.responseBody, "utf-8").toString("base64")
+					});
+					return;
+				} catch (error) {
+					logger.error(`[FetchInterceptor] fulfillRequest failed for ${requestUrl}:`, error);
+				}
+			}
+		}
+		try {
+			if (params.responseStatusCode !== void 0) await this.cdpSession.send("Fetch.continueResponse", { requestId: params.requestId });
+			else await this.cdpSession.send("Fetch.continueRequest", { requestId: params.requestId });
+		} catch (error) {
+			logger.warn(`[FetchInterceptor] continue failed for ${requestUrl}:`, error);
+		}
+	}
+};
+//#endregion
+//#region src/modules/monitor/ConsoleMonitor.impl.core.logs.ts
+function asLogsCoreContext(ctx) {
+	return ctx;
+}
+function getLogsCore(ctx, filter) {
+	const coreCtx = asLogsCoreContext(ctx);
+	if (coreCtx.contextSwitchPending) return [];
+	let logs = coreCtx.messages;
+	if (filter?.type) logs = logs.filter((msg) => msg.type === filter.type);
+	const since = filter?.since;
+	if (since !== void 0) logs = logs.filter((msg) => msg.timestamp >= since);
+	if (filter?.limit) logs = logs.slice(-filter.limit);
+	logger.debug(`getLogs: ${logs.length} messages`);
+	return logs;
+}
+function clearLogsCore(ctx) {
+	const coreCtx = asLogsCoreContext(ctx);
+	coreCtx.messages = [];
+	logger.info("Console logs cleared");
+}
+function getStatsCore(ctx) {
+	const coreCtx = asLogsCoreContext(ctx);
+	if (coreCtx.contextSwitchPending) return {
+		totalMessages: 0,
+		byType: {}
+	};
+	const byType = {};
+	for (const msg of coreCtx.messages) byType[msg.type] = (byType[msg.type] || 0) + 1;
+	return {
+		totalMessages: coreCtx.messages.length,
+		byType
+	};
+}
+function getExceptionsCore(ctx, filter) {
+	const coreCtx = asLogsCoreContext(ctx);
+	if (coreCtx.contextSwitchPending) return [];
+	let exceptions = coreCtx.exceptions;
+	if (filter?.url) exceptions = exceptions.filter((ex) => ex.url?.includes(filter.url));
+	const since = filter?.since;
+	if (since !== void 0) exceptions = exceptions.filter((ex) => ex.timestamp >= since);
+	if (filter?.limit) exceptions = exceptions.slice(-filter.limit);
+	return exceptions;
+}
+function clearExceptionsCore(ctx) {
+	const coreCtx = asLogsCoreContext(ctx);
+	coreCtx.exceptions = [];
+	logger.info("Exceptions cleared");
+}
+//#endregion
+//#region src/modules/monitor/ConsoleMonitor.impl.core.network.ts
+function asNetworkCoreContext(ctx) {
+	return ctx;
+}
+function hasStaleContext(ctx) {
+	return ctx.contextSwitchPending === true;
+}
+function isNetworkEnabledCore(ctx) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) return false;
+	return (coreCtx.networkMonitor?.isEnabled() ?? false) || (coreCtx.playwrightNetworkMonitor?.isEnabled() ?? false);
+}
+function getNetworkStatusCore(ctx) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) return {
+		enabled: false,
+		requestCount: 0,
+		responseCount: 0,
+		listenerCount: 0,
+		cdpSessionActive: false
+	};
+	if (coreCtx.playwrightNetworkMonitor) return coreCtx.playwrightNetworkMonitor.getStatus();
+	if (!coreCtx.networkMonitor) return {
+		enabled: false,
+		requestCount: 0,
+		responseCount: 0,
+		listenerCount: 0,
+		cdpSessionActive: coreCtx.cdpSession !== null
+	};
+	return coreCtx.networkMonitor.getStatus();
+}
+function getNetworkRequestsCore(ctx, filter) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) return [];
+	if (coreCtx.playwrightNetworkMonitor) return coreCtx.playwrightNetworkMonitor.getRequests(filter);
+	return coreCtx.networkMonitor?.getRequests(filter) ?? [];
+}
+function getNetworkResponsesCore(ctx, filter) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) return [];
+	if (coreCtx.playwrightNetworkMonitor) return coreCtx.playwrightNetworkMonitor.getResponses(filter);
+	return coreCtx.networkMonitor?.getResponses(filter) ?? [];
+}
+function getNetworkActivityCore(ctx, requestId) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) return {};
+	if (coreCtx.playwrightNetworkMonitor) return coreCtx.playwrightNetworkMonitor.getActivity(requestId);
+	return coreCtx.networkMonitor?.getActivity(requestId) ?? {};
+}
+async function getResponseBodyCore(ctx, requestId) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) return null;
+	if (coreCtx.playwrightNetworkMonitor) return coreCtx.playwrightNetworkMonitor.getResponseBody(requestId);
+	if (!coreCtx.networkMonitor) {
+		logger.error("Network monitoring is not enabled. Call enable() with enableNetwork: true first.");
+		return null;
+	}
+	return coreCtx.networkMonitor.getResponseBody(requestId);
+}
+async function getAllJavaScriptResponsesCore(ctx) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) return [];
+	if (coreCtx.playwrightNetworkMonitor) return coreCtx.playwrightNetworkMonitor.getAllJavaScriptResponses();
+	if (!coreCtx.networkMonitor) return [];
+	return coreCtx.networkMonitor.getAllJavaScriptResponses();
+}
+function clearNetworkRecordsCore(ctx) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	coreCtx.networkMonitor?.clearRecords();
+	coreCtx.playwrightNetworkMonitor?.clearRecords();
+}
+async function clearInjectedBuffersCore(ctx) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (coreCtx.playwrightNetworkMonitor) return {
+		...await coreCtx.playwrightNetworkMonitor.clearInjectedBuffers(),
+		dynamicScriptsCleared: 0
+	};
+	const networkResult = coreCtx.networkMonitor ? await coreCtx.networkMonitor.clearInjectedBuffers() : {
+		xhrCleared: 0,
+		fetchCleared: 0
+	};
+	const dynamicResult = await coreCtx.clearDynamicScriptBuffer();
+	return {
+		...networkResult,
+		...dynamicResult
+	};
+}
+async function resetInjectedInterceptorsCore(ctx) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (coreCtx.playwrightNetworkMonitor) return {
+		...await coreCtx.playwrightNetworkMonitor.resetInjectedInterceptors(),
+		scriptMonitorReset: false
+	};
+	const networkResult = coreCtx.networkMonitor ? await coreCtx.networkMonitor.resetInjectedInterceptors() : {
+		xhrReset: false,
+		fetchReset: false
+	};
+	const scriptResult = await coreCtx.resetDynamicScriptMonitoring();
+	return {
+		...networkResult,
+		...scriptResult
+	};
+}
+function getNetworkStatsCore(ctx) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) return {
+		totalRequests: 0,
+		totalResponses: 0,
+		byMethod: {},
+		byStatus: {},
+		byType: {}
+	};
+	if (coreCtx.playwrightNetworkMonitor) return coreCtx.playwrightNetworkMonitor.getStats();
+	return coreCtx.networkMonitor?.getStats() ?? {
+		totalRequests: 0,
+		totalResponses: 0,
+		byMethod: {},
+		byStatus: {},
+		byType: {}
+	};
+}
+async function injectXHRInterceptorCore(ctx, options) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) throw new PrerequisiteError("Network monitoring is not enabled. Call enable() with enableNetwork: true first.");
+	if (coreCtx.playwrightNetworkMonitor) return coreCtx.playwrightNetworkMonitor.injectXHRInterceptor(options);
+	if (!coreCtx.networkMonitor) throw new PrerequisiteError("Network monitoring is not enabled. Call enable() with enableNetwork: true first.");
+	return coreCtx.networkMonitor.injectXHRInterceptor(options);
+}
+async function injectFetchInterceptorCore(ctx, options) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) throw new PrerequisiteError("Network monitoring is not enabled. Call enable() with enableNetwork: true first.");
+	if (coreCtx.playwrightNetworkMonitor) return coreCtx.playwrightNetworkMonitor.injectFetchInterceptor(options);
+	if (!coreCtx.networkMonitor) throw new PrerequisiteError("Network monitoring is not enabled. Call enable() with enableNetwork: true first.");
+	return coreCtx.networkMonitor.injectFetchInterceptor(options);
+}
+async function getXHRRequestsCore(ctx) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) return [];
+	if (coreCtx.playwrightNetworkMonitor) return coreCtx.playwrightNetworkMonitor.getXHRRequests();
+	if (!coreCtx.networkMonitor) return [];
+	return coreCtx.networkMonitor.getXHRRequests();
+}
+async function getFetchRequestsCore(ctx) {
+	const coreCtx = asNetworkCoreContext(ctx);
+	if (hasStaleContext(coreCtx)) return [];
+	if (coreCtx.playwrightNetworkMonitor) return coreCtx.playwrightNetworkMonitor.getFetchRequests();
+	if (!coreCtx.networkMonitor) return [];
+	return coreCtx.networkMonitor.getFetchRequests();
+}
+//#endregion
+//#region src/modules/monitor/ConsoleMonitor.impl.core.object-cache.ts
+async function inspectObjectCore(ctx, objectId) {
+	const context = ctx;
+	await context.ensureSession();
+	if (!context.cdpSession) throw new Error("CDP session not available after reconnect attempt");
+	if (context.objectCache.has(objectId)) {
+		const cached = context.objectCache.get(objectId);
+		if (cached !== void 0) return cached;
+	}
+	try {
+		const result = await context.cdpSession.send("Runtime.getProperties", {
+			objectId,
+			ownProperties: true,
+			accessorPropertiesOnly: false,
+			generatePreview: true
+		});
+		const properties = {};
+		for (const prop of result.result) {
+			if (!prop.value) continue;
+			const valueObj = prop.value;
+			properties[prop.name] = {
+				value: context.extractValue(valueObj),
+				type: valueObj.type,
+				objectId: valueObj.objectId,
+				description: valueObj.description
+			};
+		}
+		if (!context.objectCache.has(objectId)) while (context.objectCache.size >= context.MAX_OBJECT_CACHE_SIZE) {
+			const oldestKey = context.objectCache.keys().next().value;
+			if (oldestKey === void 0) break;
+			context.objectCache.delete(oldestKey);
+		}
+		context.objectCache.set(objectId, properties);
+		logger.info(`Object inspected: ${objectId}`, { propertyCount: Object.keys(properties).length });
+		return properties;
+	} catch (error) {
+		logger.error("Failed to inspect object:", error);
+		throw error;
+	}
+}
+function clearObjectCacheCore(ctx) {
+	ctx.objectCache.clear();
+	logger.info("Object cache cleared");
+}
+//#endregion
+//#region src/modules/monitor/ConsoleMonitor.impl.core.dynamic.ts
+function asDynamicCoreContext(ctx) {
+	return ctx;
+}
+async function enableDynamicScriptMonitoringCore(ctx, options) {
+	const coreCtx = asDynamicCoreContext(ctx);
+	await coreCtx.ensureSession();
+	if (!coreCtx.cdpSession) throw new PrerequisiteError("CDP session not available after reconnect attempt");
+	const monitorCode = `
+      (function() {
+        if (window.__dynamicScriptMonitorInstalled) {
+          console.log('[ScriptMonitor] Already installed');
+          return;
+        }
+        window.__dynamicScriptMonitorInstalled = true;
+
+        const maxRecords = ${coreCtx.MAX_INJECTED_DYNAMIC_SCRIPTS};
+        if (!window.__dynamicScripts) {
+          window.__dynamicScripts = [];
+        }
+        const dynamicScripts = window.__dynamicScripts;
+        const state = window.__dynamicScriptMonitorState || {};
+        if (!state.originalCreateElement) state.originalCreateElement = document.createElement;
+        if (!state.originalEval) state.originalEval = window.eval;
+        if (!state.originalFunction) state.originalFunction = window.Function;
+        window.__dynamicScriptMonitorState = state;
+
+        const observer = new MutationObserver((mutations) => {
+          mutations.forEach((mutation) => {
+            mutation.addedNodes.forEach((node) => {
+              if (node.nodeName === 'SCRIPT') {
+                const script = node;
+                const info = {
+                  type: 'dynamic',
+                  src: script.src || '(inline)',
+                  content: script.src ? null : script.textContent,
+                  timestamp: Date.now(),
+                  async: script.async,
+                  defer: script.defer,
+                };
+
+                dynamicScripts.push(info);
+                if (dynamicScripts.length > maxRecords) {
+                  dynamicScripts.splice(0, dynamicScripts.length - maxRecords);
+                }
+                console.log('[ScriptMonitor] Dynamic script added:', info);
+              }
+            });
+          });
+        });
+
+        observer.observe(document.documentElement, {
+          childList: true,
+          subtree: true,
+        });
+        state.observer = observer;
+
+        const originalCreateElement = state.originalCreateElement;
+        document.createElement = function(tagName) {
+          const element = originalCreateElement.call(document, tagName);
+
+          if (tagName.toLowerCase() === 'script') {
+            console.log('[ScriptMonitor] Script element created via createElement');
+
+            const originalSetAttribute = element.setAttribute;
+            element.setAttribute = function(name, value) {
+              if (name === 'src') {
+                console.log('[ScriptMonitor] Script src set to:', value);
+              }
+              return originalSetAttribute.call(element, name, value);
+            };
+          }
+
+          return element;
+        };
+
+        const originalEval = state.originalEval;
+        window.eval = function(code) {
+          console.log('[ScriptMonitor] eval() called with code:',
+            typeof code === 'string' ? code.substring(0, 100) + '...' : code);
+          return originalEval.call(window, code);
+        };
+
+        const originalFunction = state.originalFunction;
+        window.Function = function(...args) {
+          console.log('[ScriptMonitor] Function() constructor called with args:', args);
+          return originalFunction.apply(this, args);
+        };
+
+        window.__getDynamicScripts = function() {
+          return dynamicScripts;
+        };
+
+        console.log('[ScriptMonitor] Dynamic script monitoring enabled');
+      })();
+    `;
+	if (options?.persistent) {
+		await coreCtx.cdpSession.send("Page.addScriptToEvaluateOnNewDocument", { source: monitorCode });
+		logger.info("Dynamic script monitoring enabled (persistent)");
+	} else {
+		await coreCtx.cdpSession.send("Runtime.evaluate", { expression: monitorCode });
+		logger.info("Dynamic script monitoring enabled");
+	}
+}
+async function clearDynamicScriptBufferCore(ctx) {
+	const coreCtx = asDynamicCoreContext(ctx);
+	if (!coreCtx.cdpSession) return { dynamicScriptsCleared: 0 };
+	try {
+		const value = (await coreCtx.cdpSession.send("Runtime.evaluate", {
+			expression: `
+          (() => {
+            const store = Array.isArray(window.__dynamicScripts)
+              ? window.__dynamicScripts
+              : (typeof window.__getDynamicScripts === 'function'
+                ? window.__getDynamicScripts()
+                : null);
+            const dynamicScriptsCleared = Array.isArray(store) ? store.length : 0;
+            if (Array.isArray(store)) {
+              store.length = 0;
+            }
+            return { dynamicScriptsCleared };
+          })()
+        `,
+			returnByValue: true
+		})).result?.value;
+		if (typeof value === "object" && value !== null && "dynamicScriptsCleared" in value && typeof value.dynamicScriptsCleared === "number") return value;
+		return { dynamicScriptsCleared: 0 };
+	} catch (error) {
+		logger.error("Failed to clear dynamic script buffer:", error);
+		return { dynamicScriptsCleared: 0 };
+	}
+}
+async function resetDynamicScriptMonitoringCore(ctx) {
+	const coreCtx = asDynamicCoreContext(ctx);
+	if (!coreCtx.cdpSession) return { scriptMonitorReset: false };
+	try {
+		const value = (await coreCtx.cdpSession.send("Runtime.evaluate", {
+			expression: `
+          (() => {
+            const state = window.__dynamicScriptMonitorState;
+            let scriptMonitorReset = false;
+
+            try {
+              if (state && state.observer && typeof state.observer.disconnect === 'function') {
+                state.observer.disconnect();
+                state.observer = null;
+                scriptMonitorReset = true;
+              }
+            } catch (_) {}
+
+            try {
+              if (state && state.originalCreateElement) {
+                document.createElement = state.originalCreateElement;
+                scriptMonitorReset = true;
+              }
+            } catch (_) {}
+
+            try {
+              if (state && state.originalEval) {
+                window.eval = state.originalEval;
+                scriptMonitorReset = true;
+              }
+            } catch (_) {}
+
+            try {
+              if (state && state.originalFunction) {
+                window.Function = state.originalFunction;
+                scriptMonitorReset = true;
+              }
+            } catch (_) {}
+
+            if (Array.isArray(window.__dynamicScripts)) {
+              window.__dynamicScripts.length = 0;
+            }
+            delete window.__getDynamicScripts;
+            window.__dynamicScriptMonitorInstalled = false;
+
+            return { scriptMonitorReset };
+          })()
+        `,
+			returnByValue: true
+		})).result?.value;
+		if (typeof value === "object" && value !== null && "scriptMonitorReset" in value && typeof value.scriptMonitorReset === "boolean") return value;
+		return { scriptMonitorReset: false };
+	} catch (error) {
+		logger.error("Failed to reset dynamic script monitoring:", error);
+		return { scriptMonitorReset: false };
+	}
+}
+async function getDynamicScriptsCore(ctx) {
+	const coreCtx = asDynamicCoreContext(ctx);
+	if (!coreCtx.cdpSession) throw new PrerequisiteError("CDP session not initialized");
+	try {
+		const value = (await coreCtx.cdpSession.send("Runtime.evaluate", {
+			expression: "window.__getDynamicScripts ? window.__getDynamicScripts() : []",
+			returnByValue: true
+		})).result?.value;
+		return Array.isArray(value) ? value : [];
+	} catch (error) {
+		logger.error("Failed to get dynamic scripts:", error);
+		return [];
+	}
+}
+async function injectFunctionTracerCore(ctx, functionName, options) {
+	const coreCtx = asDynamicCoreContext(ctx);
+	if (!coreCtx.cdpSession) throw new PrerequisiteError("CDP session not initialized");
+	const tracerCode = `
+      (function() {
+        const originalFunc = window.${functionName};
+        if (typeof originalFunc !== 'function') {
+          console.error('[Tracer] ${functionName} is not a function');
+          return;
+        }
+
+        window.${functionName} = new Proxy(originalFunc, {
+          apply: function(target, thisArg, args) {
+            console.log('[Tracer] ${functionName} called with args:', args);
+            const startTime = performance.now();
+
+            try {
+              const result = target.apply(thisArg, args);
+              const endTime = performance.now();
+              console.log('[Tracer] ${functionName} returned:', result, 'Time:', (endTime - startTime).toFixed(2), 'ms');
+              return result;
+            } catch (error) {
+              console.error('[Tracer] ${functionName} threw error:', error);
+              throw error;
+            }
+          }
+        });
+
+        console.log('[Tracer] ${functionName} is now being traced');
+      })();
+    `;
+	if (options?.persistent) {
+		await coreCtx.cdpSession.send("Page.addScriptToEvaluateOnNewDocument", { source: tracerCode });
+		logger.info(`Function tracer injected for: ${functionName} (persistent)`);
+	} else {
+		await coreCtx.cdpSession.send("Runtime.evaluate", { expression: tracerCode });
+		logger.info(`Function tracer injected for: ${functionName}`);
+	}
+}
+async function injectPropertyWatcherCore(ctx, objectPath, propertyName, options) {
+	const coreCtx = asDynamicCoreContext(ctx);
+	if (!coreCtx.cdpSession) throw new PrerequisiteError("CDP session not initialized");
+	const watcherCode = `
+      (function() {
+        const obj = ${objectPath};
+        if (!obj) {
+          console.error('[Watcher] Object not found: ${objectPath}');
+          return;
+        }
+
+        let value = obj.${propertyName};
+
+        Object.defineProperty(obj, '${propertyName}', {
+          get: function() {
+            console.log('[Watcher] ${objectPath}.${propertyName} accessed, value:', value);
+            return value;
+          },
+          set: function(newValue) {
+            console.log('[Watcher] ${objectPath}.${propertyName} changed from', value, 'to', newValue);
+            value = newValue;
+          },
+          enumerable: true,
+          configurable: true
+        });
+
+        console.log('[Watcher] Property watcher installed for ${objectPath}.${propertyName}');
+      })();
+    `;
+	if (options?.persistent) {
+		await coreCtx.cdpSession.send("Page.addScriptToEvaluateOnNewDocument", { source: watcherCode });
+		logger.info(`Property watcher injected for: ${objectPath}.${propertyName} (persistent)`);
+	} else {
+		await coreCtx.cdpSession.send("Runtime.evaluate", { expression: watcherCode });
+		logger.info(`Property watcher injected for: ${objectPath}.${propertyName}`);
+	}
+}
+//#endregion
+//#region src/modules/monitor/ConsoleMonitor.impl.core.session.ts
+function asSessionCtx(ctx) {
+	return ctx;
+}
+async function doEnableCdpCore(ctx, session, managed, options) {
+	const state = asSessionCtx(ctx);
+	state.cdpSession = session;
+	state.usingManagedTargetSession = managed;
+	state.lastEnableOptions = { ...options };
+	state.cdpSession.on("disconnected", () => {
+		logger.warn("ConsoleMonitor CDP session disconnected");
+		state.cdpSession = null;
+		state.networkMonitor = null;
+		state.usingManagedTargetSession = false;
+	});
+	await cdpSendWithTimeout(state.cdpSession, "Runtime.enable", {}, 5e3);
+	await cdpSendWithTimeout(state.cdpSession, "Console.enable", {}, 5e3);
+	state.cdpSession.on("Runtime.consoleAPICalled", (params) => {
+		const stackTrace = params.stackTrace?.callFrames?.map((frame) => ({
+			functionName: frame.functionName || "(anonymous)",
+			url: frame.url,
+			lineNumber: frame.lineNumber,
+			columnNumber: frame.columnNumber
+		})) || [];
+		const message = {
+			type: params.type,
+			text: params.args.map((arg) => state.formatRemoteObject(arg)).join(" "),
+			args: params.args.map((arg) => state.extractValue(arg)),
+			timestamp: params.timestamp,
+			stackTrace,
+			url: stackTrace[0]?.url,
+			lineNumber: stackTrace[0]?.lineNumber,
+			columnNumber: stackTrace[0]?.columnNumber
+		};
+		state.messages.push(message);
+		if (state.messages.length > state.MAX_MESSAGES) state.messages = state.messages.slice(-Math.floor(state.MAX_MESSAGES / 2));
+		logger.debug(`Console ${params.type}: ${message.text}`);
+	});
+	state.cdpSession.on("Console.messageAdded", (params) => {
+		const msg = params.message;
+		const message = {
+			type: msg.level || "log",
+			text: msg.text,
+			timestamp: Date.now(),
+			url: msg.url,
+			lineNumber: msg.line,
+			columnNumber: msg.column
+		};
+		state.messages.push(message);
+		if (state.messages.length > state.MAX_MESSAGES) state.messages = state.messages.slice(-Math.floor(state.MAX_MESSAGES / 2));
+	});
+	if (options?.enableExceptions !== false) state.cdpSession.on("Runtime.exceptionThrown", (params) => {
+		const exception = params.exceptionDetails;
+		const stackTrace = exception.stackTrace?.callFrames?.map((frame) => ({
+			functionName: frame.functionName || "(anonymous)",
+			url: frame.url,
+			lineNumber: frame.lineNumber,
+			columnNumber: frame.columnNumber
+		})) || [];
+		const exceptionInfo = {
+			text: exception.exception?.description || exception.text,
+			exceptionId: exception.exceptionId,
+			timestamp: Date.now(),
+			stackTrace,
+			url: exception.url,
+			lineNumber: exception.lineNumber,
+			columnNumber: exception.columnNumber,
+			scriptId: exception.scriptId
+		};
+		state.exceptions.push(exceptionInfo);
+		if (state.exceptions.length > state.MAX_EXCEPTIONS) state.exceptions = state.exceptions.slice(-Math.floor(state.MAX_EXCEPTIONS / 2));
+		logger.error(`Exception thrown: ${exceptionInfo.text}`, {
+			url: exceptionInfo.url,
+			line: exceptionInfo.lineNumber
+		});
+	});
+	if (options?.enableNetwork) {
+		state.networkMonitor = new NetworkMonitor(state.cdpSession);
+		await state.networkMonitor.enable();
+	}
+	logger.info("ConsoleMonitor enabled", {
+		network: options?.enableNetwork || false,
+		exceptions: options?.enableExceptions !== false
+	});
+}
+async function enablePlaywrightCore(ctx, options) {
+	const state = asSessionCtx(ctx);
+	if (state.playwrightConsoleHandler) {
+		if (options?.enableNetwork && !state.playwrightNetworkMonitor) {
+			state.playwrightNetworkMonitor = new PlaywrightNetworkMonitor(state.playwrightPage);
+			await state.playwrightNetworkMonitor.enable();
+			logger.info("Network monitoring added to existing ConsoleMonitor Playwright session");
+		}
+		return;
+	}
+	const page = state.playwrightPage;
+	state.playwrightConsoleHandler = (msg) => {
+		const message = {
+			type: msg.type() || "log",
+			text: msg.text(),
+			timestamp: Date.now()
+		};
+		state.messages.push(message);
+		if (state.messages.length > state.MAX_MESSAGES) state.messages = state.messages.slice(-Math.floor(state.MAX_MESSAGES / 2));
+	};
+	page.on("console", state.playwrightConsoleHandler);
+	if (options?.enableExceptions !== false) {
+		state.playwrightErrorHandler = (error) => {
+			const exceptionInfo = {
+				text: error.message,
+				exceptionId: Date.now(),
+				timestamp: Date.now()
+			};
+			state.exceptions.push(exceptionInfo);
+			if (state.exceptions.length > state.MAX_EXCEPTIONS) state.exceptions = state.exceptions.slice(-Math.floor(state.MAX_EXCEPTIONS / 2));
+		};
+		page.on("pageerror", state.playwrightErrorHandler);
+	}
+	if (options?.enableNetwork) {
+		state.playwrightNetworkMonitor = new PlaywrightNetworkMonitor(state.playwrightPage);
+		await state.playwrightNetworkMonitor.enable();
+	}
+	logger.info("ConsoleMonitor enabled (Playwright/camoufox mode)", { network: options?.enableNetwork || false });
+}
+async function disableCore(ctx) {
+	const state = asSessionCtx(ctx);
+	if (state.playwrightPage) {
+		const page = state.playwrightPage;
+		if (state.playwrightConsoleHandler) {
+			try {
+				page.off("console", state.playwrightConsoleHandler);
+			} catch {}
+			state.playwrightConsoleHandler = null;
+		}
+		if (state.playwrightErrorHandler) {
+			try {
+				page.off("pageerror", state.playwrightErrorHandler);
+			} catch {}
+			state.playwrightErrorHandler = null;
+		}
+	}
+	if (state.playwrightNetworkMonitor) {
+		await state.playwrightNetworkMonitor.disable();
+		state.playwrightNetworkMonitor = null;
+	}
+	if (state.cdpSession) {
+		if (state.networkMonitor) {
+			await state.networkMonitor.disable();
+			state.networkMonitor = null;
+		}
+		try {
+			await state.cdpSession.send("Console.disable");
+		} catch (error) {
+			logger.warn("Failed to disable Console domain:", error);
+		}
+		try {
+			await state.cdpSession.send("Runtime.disable");
+		} catch (error) {
+			logger.warn("Failed to disable Runtime domain:", error);
+		}
+		if (!state.usingManagedTargetSession) try {
+			await state.cdpSession.detach();
+		} catch (error) {
+			logger.warn("Failed to detach ConsoleMonitor CDP session:", error);
+		}
+		else logger.debug("ConsoleMonitor released managed target session without detaching target");
+		state.cdpSession = null;
+		state.usingManagedTargetSession = false;
+		logger.info("ConsoleMonitor disabled");
+	}
+}
+async function cdpSendWithTimeout(session, method, params, timeoutMs = 3e4) {
+	return Promise.race([session.send(method, params), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`CDP ${method} timed out after ${timeoutMs}ms`)), timeoutMs))]);
+}
+//#endregion
+//#region src/modules/monitor/ConsoleMonitor.impl.core.class.ts
+var ConsoleMonitor = class {
+	cdpSession = null;
+	networkMonitor = null;
+	fetchInterceptor = null;
+	playwrightNetworkMonitor = null;
+	playwrightPage = null;
+	usingManagedTargetSession = false;
+	contextSwitchPending = false;
+	playwrightConsoleHandler = null;
+	playwrightErrorHandler = null;
+	messages = [];
+	MAX_MESSAGES = 1e3;
+	exceptions = [];
+	MAX_EXCEPTIONS = 500;
+	MAX_INJECTED_DYNAMIC_SCRIPTS = 500;
+	MAX_OBJECT_CACHE_SIZE = 1e3;
+	objectCache = /* @__PURE__ */ new Map();
+	initPromise;
+	lastEnableOptions = {};
+	constructor(collector) {
+		this.collector = collector;
+		this.touchSplitMembersForTypeCheck();
+	}
+	touchSplitMembersForTypeCheck() {
+		this.MAX_INJECTED_DYNAMIC_SCRIPTS;
+		this.MAX_OBJECT_CACHE_SIZE;
+		this.clearDynamicScriptBuffer;
+		this.resetDynamicScriptMonitoring;
+		this.usingManagedTargetSession;
+		this.playwrightErrorHandler;
+		this.messages;
+		this.MAX_MESSAGES;
+		this.exceptions;
+		this.MAX_EXCEPTIONS;
+		this.formatRemoteObject;
+		this.extractValue;
+	}
+	setPlaywrightPage(page) {
+		this.playwrightPage = page;
+		this.playwrightNetworkMonitor?.setPage(page);
+	}
+	clearPlaywrightPage() {
+		this.playwrightPage = null;
+		this.contextSwitchPending = false;
+		this.playwrightConsoleHandler = null;
+		this.playwrightErrorHandler = null;
+		this.playwrightNetworkMonitor?.setPage(null);
+		this.playwrightNetworkMonitor = null;
+	}
+	getManagedTargetSession() {
+		return this.collector.getAttachedTargetSession?.() ?? null;
+	}
+	async createCdpSession() {
+		const managedSession = this.getManagedTargetSession();
+		if (managedSession) return {
+			session: managedSession,
+			managed: true
+		};
+		const page = await this.collector.getActivePage();
+		return {
+			session: await Promise.race([page.createCDPSession(), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("cdp_session_timeout")), 500))]),
+			managed: false
+		};
+	}
+	markContextChanged() {
+		if (!this.cdpSession && !this.playwrightPage && !this.networkMonitor && !this.playwrightNetworkMonitor && !this.fetchInterceptor) return;
+		this.contextSwitchPending = true;
+		this.clearLogs();
+		this.clearExceptions();
+		this.clearNetworkRecords();
+		this.clearObjectCache();
+		logger.info("ConsoleMonitor marked stale after active context switch");
+	}
+	async enable(options) {
+		if (this.contextSwitchPending) await this.disable();
+		if (this.initPromise) {
+			await this.initPromise;
+			await this.applyPostEnableOptions(options);
+			return;
+		}
+		this.initPromise = this.doEnable(options);
+		try {
+			await this.initPromise;
+		} finally {
+			this.initPromise = void 0;
+		}
+	}
+	async doEnable(options) {
+		if (this.playwrightPage) {
+			this.lastEnableOptions = { ...options };
+			return enablePlaywrightCore(this, options);
+		}
+		if (this.cdpSession) {
+			if (options?.enableNetwork && !this.networkMonitor) {
+				this.networkMonitor = new NetworkMonitor(this.cdpSession);
+				await this.networkMonitor.enable();
+				logger.info("Network monitoring added to existing ConsoleMonitor session");
+			}
+			return;
+		}
+		const { session, managed } = await this.createCdpSession();
+		await doEnableCdpCore(this, session, managed, options);
+	}
+	async applyPostEnableOptions(options) {
+		if (!options?.enableNetwork) return;
+		this.lastEnableOptions = {
+			...this.lastEnableOptions,
+			...options
+		};
+		if (this.playwrightPage && this.playwrightConsoleHandler && !this.playwrightNetworkMonitor) {
+			await enablePlaywrightCore(this, options);
+			return;
+		}
+		if (this.cdpSession && !this.networkMonitor) {
+			this.networkMonitor = new NetworkMonitor(this.cdpSession);
+			await this.networkMonitor.enable();
+			logger.info("Network monitoring added to existing ConsoleMonitor session");
+		}
+	}
+	async disable() {
+		try {
+			if (this.cdpSession && this.fetchInterceptor) {
+				await this.fetchInterceptor.disable();
+				this.fetchInterceptor = null;
+			}
+			await disableCore(this);
+		} finally {
+			this.fetchInterceptor = null;
+			this.initPromise = void 0;
+			this.contextSwitchPending = false;
+			this.objectCache.clear();
+		}
+	}
+	async ensureSession() {
+		if (this.contextSwitchPending) {
+			logger.info("ConsoleMonitor context switched, rebinding on demand...");
+			const rebindOptions = { ...this.lastEnableOptions };
+			await this.disable();
+			await this.enable(rebindOptions);
+			return;
+		}
+		if (!this.cdpSession && !this.playwrightPage) {
+			logger.info("ConsoleMonitor CDP session lost, reinitializing...");
+			await this.enable(this.lastEnableOptions);
+			return;
+		}
+		if (this.cdpSession) try {
+			await Promise.race([this.cdpSession.send("Runtime.evaluate", {
+				expression: "1",
+				returnByValue: true
+			}), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("session_unreachable")), 3e3))]);
+			return;
+		} catch {
+			logger.warn("ConsoleMonitor CDP session unresponsive (zombie), reinitializing...");
+			this.cdpSession = null;
+			this.networkMonitor = null;
+			this.fetchInterceptor = null;
+			this.usingManagedTargetSession = false;
+			await this.enable(this.lastEnableOptions);
+		}
+	}
+	isSessionActive() {
+		return !this.contextSwitchPending && (this.cdpSession !== null || this.playwrightPage !== null);
+	}
+	getLogs(filter) {
+		return getLogsCore(this, filter);
+	}
+	async execute(expression) {
+		await this.ensureSession();
+		try {
+			const result = await cdpSendWithTimeout(this.cdpSession, "Runtime.evaluate", {
+				expression,
+				returnByValue: true
+			});
+			if (result.exceptionDetails) {
+				logger.error("Console execute error:", result.exceptionDetails);
+				throw new Error(result.exceptionDetails.text);
+			}
+			logger.info("Console expression executed");
+			return result.result.value;
+		} catch (error) {
+			logger.error("Console execute failed:", error);
+			throw error;
+		}
+	}
+	clearLogs() {
+		clearLogsCore(this);
+	}
+	getStats() {
+		return getStatsCore(this);
+	}
+	async close() {
+		try {
+			await this.disable();
+		} finally {
+			this.initPromise = void 0;
+			this.objectCache.clear();
+		}
+	}
+	isNetworkEnabled() {
+		return isNetworkEnabledCore(this);
+	}
+	getNetworkStatus() {
+		return getNetworkStatusCore(this);
+	}
+	getNetworkRequests(filter) {
+		return getNetworkRequestsCore(this, filter);
+	}
+	getNetworkResponses(filter) {
+		return getNetworkResponsesCore(this, filter);
+	}
+	getNetworkActivity(requestId) {
+		return getNetworkActivityCore(this, requestId);
+	}
+	async getResponseBody(requestId) {
+		return getResponseBodyCore(this, requestId);
+	}
+	async getAllJavaScriptResponses() {
+		return getAllJavaScriptResponsesCore(this);
+	}
+	clearNetworkRecords() {
+		clearNetworkRecordsCore(this);
+	}
+	async clearInjectedBuffers() {
+		return clearInjectedBuffersCore(this);
+	}
+	async resetInjectedInterceptors() {
+		return resetInjectedInterceptorsCore(this);
+	}
+	getNetworkStats() {
+		return getNetworkStatsCore(this);
+	}
+	async injectXHRInterceptor(options) {
+		return injectXHRInterceptorCore(this, options);
+	}
+	async injectFetchInterceptor(options) {
+		return injectFetchInterceptorCore(this, options);
+	}
+	async getXHRRequests() {
+		return getXHRRequestsCore(this);
+	}
+	async getFetchRequests() {
+		return getFetchRequestsCore(this);
+	}
+	getExceptions(filter) {
+		return getExceptionsCore(this, filter);
+	}
+	clearExceptions() {
+		clearExceptionsCore(this);
+	}
+	async inspectObject(objectId) {
+		return inspectObjectCore(this, objectId);
+	}
+	clearObjectCache() {
+		clearObjectCacheCore(this);
+	}
+	async enableDynamicScriptMonitoring(options) {
+		return enableDynamicScriptMonitoringCore(this, options);
+	}
+	async clearDynamicScriptBuffer() {
+		return clearDynamicScriptBufferCore(this);
+	}
+	async resetDynamicScriptMonitoring() {
+		return resetDynamicScriptMonitoringCore(this);
+	}
+	async getDynamicScripts() {
+		return getDynamicScriptsCore(this);
+	}
+	async injectFunctionTracer(functionName, options) {
+		return injectFunctionTracerCore(this, functionName, options);
+	}
+	async injectPropertyWatcher(objectPath, propertyName, options) {
+		return injectPropertyWatcherCore(this, objectPath, propertyName, options);
+	}
+	async enableFetchIntercept(rules) {
+		await this.ensureSession();
+		if (!this.cdpSession) throw new Error("No CDP session available for Fetch interception");
+		if (!this.fetchInterceptor) this.fetchInterceptor = new FetchInterceptor(this.cdpSession);
+		return this.fetchInterceptor.enable(rules);
+	}
+	async disableFetchIntercept() {
+		if (!this.fetchInterceptor) return { removedRules: 0 };
+		const result = await this.fetchInterceptor.disable();
+		this.fetchInterceptor = null;
+		return result;
+	}
+	async removeFetchInterceptRule(ruleId) {
+		if (!this.fetchInterceptor) return false;
+		const removed = await this.fetchInterceptor.removeRule(ruleId);
+		if (!this.fetchInterceptor.isEnabled()) this.fetchInterceptor = null;
+		return removed;
+	}
+	getFetchInterceptStatus() {
+		if (!this.fetchInterceptor) return {
+			enabled: false,
+			rules: [],
+			totalHits: 0
+		};
+		return this.fetchInterceptor.listRules();
+	}
+	formatRemoteObject(obj) {
+		if (obj.value !== void 0) return String(obj.value);
+		if (obj.description) return obj.description;
+		if (obj.type === "undefined") return "undefined";
+		if (obj.type === "object" && obj.subtype === "null") return "null";
+		return `[${obj.type}]`;
+	}
+	extractValue(obj) {
+		if (obj.value !== void 0) return obj.value;
+		if (obj.type === "undefined") return;
+		if (obj.type === "object" && obj.subtype === "null") return null;
+		if (obj.objectId) return {
+			__objectId: obj.objectId,
+			__type: obj.type,
+			__description: obj.description
+		};
+		return obj.description || `[${obj.type}]`;
+	}
+};
+//#endregion
+//#region src/modules/monitor/ConsoleMonitor.ts
+var ConsoleMonitor_exports = /* @__PURE__ */ __exportAll({ ConsoleMonitor: () => ConsoleMonitor });
+//#endregion
+export { ConsoleMonitor_exports as t };