@jshookmcp/jshook 0.2.8 → 0.2.9

package/dist/ScriptManager-aHHq0X7U.mjs

@@ -0,0 +1,3000 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { B as DOM_WAIT_ELEMENT_TIMEOUT_MS, z as DOM_QUERY_DEFAULT_LIMIT } from "./constants-B0OANIBL.mjs";
+import { t as getCodeCacheDir } from "./outputPaths-B1uGmrWZ.mjs";
+import { t as PrerequisiteError } from "./PrerequisiteError-Dl33Svkz.mjs";
+import { createRequire } from "node:module";
+import { existsSync } from "fs";
+import path, { join } from "path";
+import crypto, { createHash } from "crypto";
+import { dirname, join as join$1 } from "node:path";
+import { promisify } from "util";
+import { connect, executablePath, launch } from "rebrowser-puppeteer-core";
+import fs, { readFile } from "fs/promises";
+import { gunzip, gzip } from "zlib";
+import { EventEmitter } from "node:events";
+import { homedir } from "os";
+import { setImmediate } from "node:timers/promises";
+//#region src/modules/collector/CodeCache.ts
+var CodeCache = class CodeCache {
+	cacheDir;
+	maxAge;
+	maxSize;
+	memoryCache = /* @__PURE__ */ new Map();
+	MAX_MEMORY_CACHE_SIZE = 100;
+	writesSinceCleanup = 0;
+	static CLEANUP_INTERVAL = 20;
+	constructor(options = {}) {
+		this.cacheDir = options.cacheDir || getCodeCacheDir();
+		this.maxAge = options.maxAge || 1440 * 60 * 1e3;
+		this.maxSize = options.maxSize || 100 * 1024 * 1024;
+	}
+	async init() {
+		try {
+			await fs.mkdir(this.cacheDir, { recursive: true });
+			logger.debug(`Cache directory initialized: ${this.cacheDir}`);
+		} catch (error) {
+			logger.error("Failed to initialize cache directory:", error);
+		}
+	}
+	generateKey(url, options) {
+		const data = JSON.stringify({
+			url,
+			options
+		});
+		return crypto.createHash("md5").update(data).digest("hex");
+	}
+	getCachePath(key) {
+		return path.join(this.cacheDir, `${key}.json`);
+	}
+	getDependenciesOrEmpty(dependencies) {
+		return dependencies ?? {
+			nodes: [],
+			edges: []
+		};
+	}
+	isExpired(entry) {
+		return Date.now() - entry.timestamp > this.maxAge;
+	}
+	async get(url, options) {
+		const key = this.generateKey(url, options);
+		if (this.memoryCache.has(key)) {
+			const entry = this.memoryCache.get(key);
+			if (!this.isExpired(entry)) {
+				logger.debug(`Cache hit (memory): ${url}`);
+				return {
+					files: entry.files,
+					dependencies: this.getDependenciesOrEmpty(entry.dependencies),
+					totalSize: entry.totalSize,
+					collectTime: entry.collectTime,
+					summaries: entry.summaries
+				};
+			} else this.memoryCache.delete(key);
+		}
+		try {
+			const cachePath = this.getCachePath(key);
+			const data = await fs.readFile(cachePath, "utf-8");
+			const entry = JSON.parse(data);
+			if (this.isExpired(entry)) {
+				logger.debug(`Cache expired: ${url}`);
+				await fs.unlink(cachePath);
+				return null;
+			}
+			this.memoryCache.set(key, entry);
+			logger.debug(`Cache hit (disk): ${url}`);
+			return {
+				files: entry.files,
+				dependencies: this.getDependenciesOrEmpty(entry.dependencies),
+				totalSize: entry.totalSize,
+				collectTime: entry.collectTime,
+				summaries: entry.summaries
+			};
+		} catch (err) {
+			logger.warn(`Cache read failed for ${url}: ${err instanceof Error ? err.message : String(err)}`);
+			return null;
+		}
+	}
+	async set(url, result, options) {
+		const key = this.generateKey(url, options);
+		const hash = crypto.createHash("md5").update(JSON.stringify(result.files)).digest("hex");
+		const entry = {
+			url,
+			files: result.files,
+			dependencies: result.dependencies,
+			totalSize: result.totalSize,
+			collectTime: result.collectTime,
+			summaries: result.summaries,
+			timestamp: Date.now(),
+			hash
+		};
+		this.memoryCache.set(key, entry);
+		if (this.memoryCache.size > this.MAX_MEMORY_CACHE_SIZE) {
+			const firstKey = this.memoryCache.keys().next().value;
+			if (firstKey) {
+				this.memoryCache.delete(firstKey);
+				logger.debug(`Memory cache evicted: ${firstKey}`);
+			}
+		}
+		try {
+			const cachePath = this.getCachePath(key);
+			await fs.mkdir(this.cacheDir, { recursive: true });
+			await fs.writeFile(cachePath, JSON.stringify(entry, null, 2), "utf-8");
+			logger.debug(`Cache saved: ${url} (${(result.totalSize / 1024).toFixed(2)} KB)`);
+		} catch (error) {
+			logger.error("Failed to save cache:", error);
+		}
+		if (++this.writesSinceCleanup >= CodeCache.CLEANUP_INTERVAL) {
+			this.writesSinceCleanup = 0;
+			this.cleanup();
+		}
+	}
+	async cleanup() {
+		try {
+			const files = await fs.readdir(this.cacheDir);
+			let totalSize = 0;
+			const entries = [];
+			for (const file of files) {
+				if (!file.endsWith(".json")) continue;
+				const filePath = path.join(this.cacheDir, file);
+				const stats = await fs.stat(filePath);
+				totalSize += stats.size;
+				entries.push({
+					file: filePath,
+					mtime: stats.mtime,
+					size: stats.size
+				});
+			}
+			if (totalSize > this.maxSize) {
+				entries.sort((a, b) => a.mtime.getTime() - b.mtime.getTime());
+				let removedSize = 0;
+				for (const entry of entries) {
+					if (totalSize - removedSize <= this.maxSize * .8) break;
+					await fs.unlink(entry.file);
+					removedSize += entry.size;
+					logger.debug(`Removed old cache: ${entry.file}`);
+				}
+				logger.info(`Cache cleanup: removed ${removedSize} bytes`);
+			}
+		} catch (error) {
+			logger.error("Failed to cleanup cache:", error);
+		}
+	}
+	async clear() {
+		try {
+			this.memoryCache.clear();
+			const files = await fs.readdir(this.cacheDir);
+			for (const file of files) if (file.endsWith(".json")) await fs.unlink(path.join(this.cacheDir, file));
+			logger.info("All cache cleared");
+		} catch (error) {
+			if (error.code === "ENOENT") return;
+			logger.error("Failed to clear cache:", error);
+		}
+	}
+	async getStats() {
+		try {
+			const files = await fs.readdir(this.cacheDir);
+			let totalSize = 0;
+			let diskEntries = 0;
+			for (const file of files) {
+				if (!file.endsWith(".json")) continue;
+				const filePath = path.join(this.cacheDir, file);
+				const stats = await fs.stat(filePath);
+				totalSize += stats.size;
+				diskEntries++;
+			}
+			return {
+				memoryEntries: this.memoryCache.size,
+				diskEntries,
+				totalSize
+			};
+		} catch (error) {
+			logger.error("Failed to get cache stats:", error);
+			return {
+				memoryEntries: this.memoryCache.size,
+				diskEntries: 0,
+				totalSize: 0
+			};
+		}
+	}
+	async warmup(urls) {
+		logger.info(`Warming up cache for ${urls.length} URLs...`);
+		for (const url of urls) await this.get(url);
+		logger.info("Cache warmup completed");
+	}
+};
+//#endregion
+//#region src/modules/collector/SmartCodeCollector.ts
+var SmartCodeCollector = class {
+	DEFAULT_MAX_TOTAL_SIZE = 512 * 1024;
+	DEFAULT_MAX_FILE_SIZE = 100 * 1024;
+	PREVIEW_LINES = 50;
+	async smartCollect(_page, files, options) {
+		logger.info(`Smart code collection mode: ${options.mode}`);
+		switch (options.mode) {
+			case "summary": return this.collectSummaries(files);
+			case "priority": return this.collectByPriority(files, options);
+			case "incremental": return this.collectIncremental(files, options);
+			default: return this.collectWithLimit(files, options);
+		}
+	}
+	async collectSummaries(files) {
+		logger.info("Generating code summaries...");
+		return files.map((file) => {
+			const preview = file.content.split("\n").slice(0, this.PREVIEW_LINES).join("\n");
+			return {
+				url: file.url,
+				size: file.size,
+				type: file.type,
+				hasEncryption: this.detectEncryption(file.content),
+				hasAPI: this.detectAPI(file.content),
+				hasObfuscation: this.detectObfuscation(file.content),
+				functions: this.extractFunctions(file.content),
+				imports: this.extractImports(file.content),
+				preview
+			};
+		});
+	}
+	collectByPriority(files, options) {
+		const maxTotalSize = options.maxTotalSize || this.DEFAULT_MAX_TOTAL_SIZE;
+		const maxFileSize = options.maxFileSize || this.DEFAULT_MAX_FILE_SIZE;
+		const scoredFiles = files.map((file) => ({
+			file,
+			score: this.calculatePriority(file, options.priorities || [])
+		}));
+		scoredFiles.sort((a, b) => b.score - a.score);
+		const result = [];
+		let currentSize = 0;
+		for (const { file } of scoredFiles) {
+			let content = file.content;
+			let truncated = false;
+			if (file.size > maxFileSize) {
+				content = content.substring(0, maxFileSize);
+				truncated = true;
+			}
+			if (currentSize + content.length > maxTotalSize) {
+				logger.warn(`Reached max total size limit (${maxTotalSize} bytes), stopping collection`);
+				break;
+			}
+			result.push({
+				...file,
+				content,
+				size: content.length,
+				metadata: {
+					...file.metadata,
+					truncated,
+					originalSize: file.size,
+					priorityScore: this.calculatePriority(file, options.priorities || [])
+				}
+			});
+			currentSize += content.length;
+		}
+		logger.info(`Collected ${result.length}/${files.length} files by priority (${(currentSize / 1024).toFixed(2)} KB)`);
+		return result;
+	}
+	collectIncremental(files, options) {
+		const includePatterns = options.includePatterns || [];
+		const excludePatterns = options.excludePatterns || [];
+		const filtered = files.filter((file) => {
+			if (excludePatterns.some((pattern) => new RegExp(pattern).test(file.url))) return false;
+			if (includePatterns.length === 0) return true;
+			return includePatterns.some((pattern) => new RegExp(pattern).test(file.url));
+		});
+		logger.info(`Incremental collection: ${filtered.length}/${files.length} files matched`);
+		return this.collectWithLimit(filtered, options);
+	}
+	collectWithLimit(files, options) {
+		const maxTotalSize = options.maxTotalSize || this.DEFAULT_MAX_TOTAL_SIZE;
+		const maxFileSize = options.maxFileSize || this.DEFAULT_MAX_FILE_SIZE;
+		const result = [];
+		let currentSize = 0;
+		for (const file of files) {
+			let content = file.content;
+			let truncated = false;
+			if (file.size > maxFileSize) {
+				content = content.substring(0, maxFileSize);
+				truncated = true;
+			}
+			if (currentSize + content.length > maxTotalSize) {
+				logger.warn(`Reached max total size limit, collected ${result.length}/${files.length} files`);
+				break;
+			}
+			result.push({
+				...file,
+				content,
+				size: content.length,
+				metadata: {
+					...file.metadata,
+					truncated,
+					originalSize: file.size
+				}
+			});
+			currentSize += content.length;
+		}
+		return result;
+	}
+	calculatePriority(file, priorities) {
+		let score = 0;
+		if (file.type === "inline") score += 10;
+		if (file.type === "external") score += 5;
+		for (let i = 0; i < priorities.length; i++) {
+			const pattern = priorities[i];
+			if (pattern && new RegExp(pattern).test(file.url)) score += (priorities.length - i) * 20;
+		}
+		if (this.detectEncryption(file.content)) score += 50;
+		if (this.detectAPI(file.content)) score += 30;
+		if (this.detectObfuscation(file.content)) score += 20;
+		if (file.size < 10 * 1024) score += 10;
+		else if (file.size > 500 * 1024) score -= 20;
+		return score;
+	}
+	detectEncryption(content) {
+		return [
+			/crypto|encrypt|decrypt|cipher|aes|rsa|md5|sha/i,
+			/CryptoJS|forge|sjcl/i,
+			/btoa|atob/i
+		].some((pattern) => pattern.test(content));
+	}
+	detectAPI(content) {
+		return [
+			/fetch\s*\(/,
+			/XMLHttpRequest/,
+			/axios|request|ajax/i,
+			/\.get\(|\.post\(/
+		].some((pattern) => pattern.test(content));
+	}
+	detectObfuscation(content) {
+		const lines = content.split("\n");
+		if (content.length / lines.length > 200) return true;
+		if (/\\x[0-9a-f]{2}/i.test(content)) return true;
+		if (/\\u[0-9a-f]{4}/i.test(content)) return true;
+		if (/eval\s*\(/i.test(content)) return true;
+		return false;
+	}
+	extractFunctions(content) {
+		const functions = [];
+		for (const pattern of [
+			/function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
+			/const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*function/g,
+			/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:\s*function/g
+		]) {
+			let match;
+			while ((match = pattern.exec(content)) !== null) if (match[1] && !functions.includes(match[1])) functions.push(match[1]);
+		}
+		return functions.slice(0, 20);
+	}
+	extractImports(content) {
+		const imports = [];
+		for (const pattern of [/import\s+.*?from\s+['"]([^'"]+)['"]/g, /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g]) {
+			let match;
+			while ((match = pattern.exec(content)) !== null) if (match[1] && !imports.includes(match[1])) imports.push(match[1]);
+		}
+		return imports;
+	}
+};
+//#endregion
+//#region src/modules/collector/CodeCompressor.ts
+const gzipAsync = promisify(gzip);
+const gunzipAsync = promisify(gunzip);
+var CodeCompressor = class {
+	DEFAULT_LEVEL = 6;
+	DEFAULT_CHUNK_SIZE = 100 * 1024;
+	DEFAULT_CONCURRENCY = 5;
+	DEFAULT_MAX_RETRIES = 3;
+	CACHE_MAX_SIZE = 100;
+	CACHE_TTL = 3600 * 1e3;
+	cache = /* @__PURE__ */ new Map();
+	stats = {
+		totalCompressed: 0,
+		totalOriginalSize: 0,
+		totalCompressedSize: 0,
+		averageRatio: 0,
+		cacheHits: 0,
+		cacheMisses: 0,
+		totalTime: 0
+	};
+	async compress(code, options = {}) {
+		const startTime = Date.now();
+		const level = options.level ?? this.DEFAULT_LEVEL;
+		const useCache = options.useCache ?? true;
+		const maxRetries = options.maxRetries ?? this.DEFAULT_MAX_RETRIES;
+		const cacheKey = this.generateCacheKey(code, level);
+		if (useCache && this.cache.has(cacheKey)) {
+			const cached = this.cache.get(cacheKey);
+			if (Date.now() - cached.timestamp < this.CACHE_TTL) {
+				this.stats.cacheHits++;
+				logger.debug(`Cache hit for compression (${code.length} bytes)`);
+				return {
+					compressed: cached.compressed,
+					originalSize: cached.originalSize,
+					compressedSize: cached.compressedSize,
+					compressionRatio: cached.compressionRatio,
+					level
+				};
+			} else this.cache.delete(cacheKey);
+		}
+		this.stats.cacheMisses++;
+		let lastError = null;
+		for (let attempt = 0; attempt < maxRetries; attempt++) try {
+			const buffer = Buffer.from(code, "utf-8");
+			const compressed = await gzipAsync(buffer, { level });
+			const base64 = compressed.toString("base64");
+			const originalSize = buffer.length;
+			const compressedSize = compressed.length;
+			const compressionRatio = (1 - compressedSize / originalSize) * 100;
+			const compressionTime = Date.now() - startTime;
+			this.stats.totalCompressed++;
+			this.stats.totalOriginalSize += originalSize;
+			this.stats.totalCompressedSize += compressedSize;
+			this.stats.averageRatio = (1 - this.stats.totalCompressedSize / this.stats.totalOriginalSize) * 100;
+			this.stats.totalTime += compressionTime;
+			const result = {
+				compressed: base64,
+				originalSize,
+				compressedSize,
+				compressionRatio,
+				level,
+				metadata: {
+					hash: cacheKey,
+					timestamp: Date.now(),
+					compressionTime
+				}
+			};
+			if (useCache) this.addToCache(cacheKey, {
+				compressed: base64,
+				originalSize,
+				compressedSize,
+				compressionRatio,
+				timestamp: Date.now()
+			});
+			logger.debug(`Compressed code: ${originalSize} -> ${compressedSize} bytes (${compressionRatio.toFixed(1)}% reduction, level ${level}, ${compressionTime}ms)`);
+			return result;
+		} catch (error) {
+			lastError = error;
+			logger.warn(`Compression attempt ${attempt + 1}/${maxRetries} failed:`, error);
+			if (attempt < maxRetries - 1) await new Promise((resolve) => setTimeout(resolve, 100 * (attempt + 1)));
+		}
+		logger.error("Failed to compress code after retries:", lastError);
+		throw lastError || /* @__PURE__ */ new Error("Compression failed");
+	}
+	async decompress(compressed, maxRetries = 3) {
+		let lastError = null;
+		for (let attempt = 0; attempt < maxRetries; attempt++) try {
+			return (await gunzipAsync(Buffer.from(compressed, "base64"))).toString("utf-8");
+		} catch (error) {
+			lastError = error;
+			logger.warn(`Decompression attempt ${attempt + 1}/${maxRetries} failed:`, error);
+			if (attempt < maxRetries - 1) await new Promise((resolve) => setTimeout(resolve, 100 * (attempt + 1)));
+		}
+		logger.error("Failed to decompress code after retries:", lastError);
+		throw lastError || /* @__PURE__ */ new Error("Decompression failed");
+	}
+	async compressBatch(files, options = {}) {
+		const concurrency = options.concurrency ?? this.DEFAULT_CONCURRENCY;
+		const results = [];
+		for (let i = 0; i < files.length; i += concurrency) {
+			const batch = files.slice(i, i + concurrency);
+			const batchResults = await Promise.all(batch.map(async (file) => {
+				try {
+					const result = await this.compress(file.content, options);
+					if (options.onFileProgress) options.onFileProgress(file.url, 100);
+					return {
+						url: file.url,
+						compressed: result.compressed,
+						originalSize: result.originalSize,
+						compressedSize: result.compressedSize,
+						compressionRatio: result.compressionRatio
+					};
+				} catch (error) {
+					logger.error(`Failed to compress ${file.url}:`, error);
+					return {
+						url: file.url,
+						compressed: Buffer.from(file.content).toString("base64"),
+						originalSize: file.content.length,
+						compressedSize: file.content.length,
+						compressionRatio: 0
+					};
+				}
+			}));
+			results.push(...batchResults);
+			if (options.onProgress) options.onProgress(results.length / files.length * 100);
+		}
+		const totalOriginal = results.reduce((sum, r) => sum + r.originalSize, 0);
+		const totalCompressed = results.reduce((sum, r) => sum + r.compressedSize, 0);
+		const totalRatio = totalOriginal > 0 ? (1 - totalCompressed / totalOriginal) * 100 : 0;
+		logger.info(`Batch compression: ${results.length} files, ${(totalOriginal / 1024).toFixed(2)} KB -> ${(totalCompressed / 1024).toFixed(2)} KB (${totalRatio.toFixed(1)}% reduction)`);
+		return results;
+	}
+	shouldCompress(code, threshold = 1024) {
+		return code.length > threshold;
+	}
+	selectCompressionLevel(size) {
+		if (size < 10 * 1024) return 1;
+		else if (size < 100 * 1024) return 6;
+		else if (size < 1024 * 1024) return 9;
+		else return 6;
+	}
+	async compressStream(code, options = {}) {
+		const chunkSize = options.chunkSize ?? this.DEFAULT_CHUNK_SIZE;
+		if (code.length <= chunkSize) return this.compress(code, options);
+		const startTime = Date.now();
+		const chunks = [];
+		for (let i = 0; i < code.length; i += chunkSize) {
+			const chunk = code.substring(i, i + chunkSize);
+			const compressed = await this.compress(chunk, {
+				...options,
+				useCache: false
+			});
+			chunks.push(compressed.compressed);
+			if (options.onProgress) options.onProgress(i / code.length * 100);
+		}
+		const combined = JSON.stringify(chunks);
+		const finalCompressed = Buffer.from(combined).toString("base64");
+		const originalSize = code.length;
+		const compressedSize = finalCompressed.length;
+		const compressionRatio = (1 - compressedSize / originalSize) * 100;
+		const compressionTime = Date.now() - startTime;
+		logger.info(`Stream compression: ${chunks.length} chunks, ${(originalSize / 1024).toFixed(2)} KB -> ${(compressedSize / 1024).toFixed(2)} KB (${compressionRatio.toFixed(1)}% reduction, ${compressionTime}ms)`);
+		return {
+			compressed: finalCompressed,
+			originalSize,
+			compressedSize,
+			compressionRatio,
+			chunks: chunks.length,
+			metadata: {
+				hash: this.generateCacheKey(code, options.level ?? this.DEFAULT_LEVEL),
+				timestamp: Date.now(),
+				compressionTime
+			}
+		};
+	}
+	getStats() {
+		return { ...this.stats };
+	}
+	resetStats() {
+		this.stats = {
+			totalCompressed: 0,
+			totalOriginalSize: 0,
+			totalCompressedSize: 0,
+			averageRatio: 0,
+			cacheHits: 0,
+			cacheMisses: 0,
+			totalTime: 0
+		};
+	}
+	clearCache() {
+		this.cache.clear();
+		logger.info("Compression cache cleared");
+	}
+	getCacheSize() {
+		return this.cache.size;
+	}
+	generateCacheKey(code, level) {
+		return `${createHash("md5").update(code).digest("hex")}-${level}`;
+	}
+	addToCache(key, entry) {
+		if (this.cache.size >= this.CACHE_MAX_SIZE) {
+			const firstKey = this.cache.keys().next().value;
+			if (firstKey) this.cache.delete(firstKey);
+		}
+		this.cache.set(key, entry);
+	}
+};
+//#endregion
+//#region src/modules/browser/AttachedTargetSession.ts
+var AttachedTargetSession = class {
+	emitter = new EventEmitter();
+	pending = /* @__PURE__ */ new Map();
+	nextCommandId = 1;
+	detached = false;
+	constructor(parentSession, sessionId) {
+		this.parentSession = parentSession;
+		this.sessionId = sessionId;
+		this.parentSession.on("Target.receivedMessageFromTarget", this.handleReceivedMessage);
+		this.parentSession.on("Target.detachedFromTarget", this.handleDetachedFromTarget);
+	}
+	id() {
+		return this.sessionId;
+	}
+	on(event, listener) {
+		this.emitter.on(event, listener);
+		return this;
+	}
+	off(event, listener) {
+		this.emitter.off(event, listener);
+		return this;
+	}
+	async send(method, params = {}) {
+		if (this.detached) throw new Error(`CDP target session ${this.sessionId} is detached`);
+		const commandId = this.nextCommandId++;
+		const message = JSON.stringify({
+			id: commandId,
+			method,
+			params
+		});
+		return await new Promise((resolve, reject) => {
+			this.pending.set(commandId, {
+				resolve,
+				reject
+			});
+			this.parentSession.send("Target.sendMessageToTarget", {
+				sessionId: this.sessionId,
+				message
+			}).catch((error) => {
+				this.pending.delete(commandId);
+				reject(error);
+			});
+		});
+	}
+	async detach() {
+		if (this.detached) return;
+		try {
+			await this.parentSession.send("Target.detachFromTarget", { sessionId: this.sessionId });
+		} finally {
+			this.dispose(/* @__PURE__ */ new Error(`CDP target session ${this.sessionId} detached`));
+		}
+	}
+	handleReceivedMessage = (payload) => {
+		if (!this.matchesSession(payload)) return;
+		const rawMessage = this.readString(payload, "message");
+		if (!rawMessage) return;
+		let parsed;
+		try {
+			parsed = JSON.parse(rawMessage);
+		} catch (error) {
+			logger.debug(`[AttachedTargetSession] Failed to parse incoming target message for ${this.sessionId}: ${String(error)}`);
+			return;
+		}
+		if (!this.isRecord(parsed)) return;
+		const commandId = typeof parsed.id === "number" ? parsed.id : null;
+		if (commandId !== null) {
+			const pending = this.pending.get(commandId);
+			if (!pending) return;
+			this.pending.delete(commandId);
+			if (parsed.error) pending.reject(this.normalizeError(parsed.error));
+			else pending.resolve(parsed.result ?? null);
+			return;
+		}
+		const method = typeof parsed.method === "string" ? parsed.method : null;
+		if (!method) return;
+		this.emitter.emit(method, parsed.params ?? {});
+	};
+	handleDetachedFromTarget = (payload) => {
+		if (!this.matchesSession(payload)) return;
+		this.dispose(/* @__PURE__ */ new Error(`CDP target session ${this.sessionId} detached by browser`));
+	};
+	matchesSession(payload) {
+		return this.readString(payload, "sessionId") === this.sessionId;
+	}
+	dispose(reason) {
+		if (this.detached) return;
+		this.detached = true;
+		this.parentSession.off("Target.receivedMessageFromTarget", this.handleReceivedMessage);
+		this.parentSession.off("Target.detachedFromTarget", this.handleDetachedFromTarget);
+		for (const pending of this.pending.values()) pending.reject(reason);
+		this.pending.clear();
+		this.emitter.emit("disconnected", {
+			sessionId: this.sessionId,
+			reason: reason.message
+		});
+		this.emitter.removeAllListeners();
+	}
+	normalizeError(error) {
+		if (error instanceof Error) return error;
+		if (this.isRecord(error)) {
+			const message = typeof error.message === "string" && error.message || typeof error.data === "string" && error.data || JSON.stringify(error);
+			return new Error(message || "CDP target command failed");
+		}
+		return new Error(String(error));
+	}
+	isRecord(value) {
+		return typeof value === "object" && value !== null;
+	}
+	readString(payload, key) {
+		if (!this.isRecord(payload)) return null;
+		const value = payload[key];
+		return typeof value === "string" ? value : null;
+	}
+};
+//#endregion
+//#region src/modules/browser/BrowserTargetSessionManager.ts
+var BrowserTargetSessionManager = class {
+	browserSession = null;
+	attachedTargetSession = null;
+	attachedTargetInfo = null;
+	autoAttachEnabled = false;
+	constructor(getBrowser) {
+		this.getBrowser = getBrowser;
+	}
+	async listTargets(filters = {}) {
+		const session = await this.ensureBrowserSession();
+		if (filters.discoverOOPIF !== false && !this.autoAttachEnabled) try {
+			await session.send("Target.setAutoAttach", {
+				autoAttach: true,
+				waitForDebuggerOnStart: false,
+				flatten: true
+			});
+			await session.send("Target.setDiscoverTargets", { discover: true });
+			this.autoAttachEnabled = true;
+		} catch {}
+		const response = await session.send("Target.getTargets");
+		return (Array.isArray(response.targetInfos) ? response.targetInfos.map((target) => this.normalizeTargetInfo(target)).filter((target) => target !== null) : []).filter((target) => this.matchesFilters(target, filters));
+	}
+	async attach(targetId) {
+		const current = this.attachedTargetInfo;
+		if (current?.targetId === targetId && this.attachedTargetSession) return current;
+		const target = (await this.listTargets()).find((entry) => entry.targetId === targetId);
+		if (!target) throw new Error(`CDP target not found: ${targetId}`);
+		await this.detach();
+		const session = await this.ensureBrowserSession();
+		const response = await session.send("Target.attachToTarget", {
+			targetId,
+			flatten: true
+		});
+		if (!response.sessionId) throw new Error(`Target.attachToTarget did not return sessionId for ${targetId}`);
+		this.attachedTargetSession = new AttachedTargetSession(session, response.sessionId);
+		this.attachedTargetInfo = target;
+		return target;
+	}
+	async detach() {
+		if (!this.attachedTargetSession) {
+			this.attachedTargetInfo = null;
+			return false;
+		}
+		const session = this.attachedTargetSession;
+		this.attachedTargetSession = null;
+		this.attachedTargetInfo = null;
+		await session.detach();
+		return true;
+	}
+	getAttachedTargetSession() {
+		return this.attachedTargetSession;
+	}
+	getAttachedTargetInfo() {
+		return this.attachedTargetInfo;
+	}
+	async evaluate(expression, options = {}) {
+		const response = await this.requireAttachedTargetSession().send("Runtime.evaluate", {
+			expression,
+			returnByValue: options.returnByValue ?? true,
+			awaitPromise: options.awaitPromise ?? true
+		});
+		if (response.exceptionDetails) {
+			const details = response.exceptionDetails;
+			throw new Error(details.exception?.description || details.text || "Runtime.evaluate failed in attached target");
+		}
+		return options.returnByValue === false ? response.result ?? null : response.result?.value ?? null;
+	}
+	async addScriptToEvaluateOnNewDocument(source) {
+		return await this.requireAttachedTargetSession().send("Page.addScriptToEvaluateOnNewDocument", { source });
+	}
+	async dispose() {
+		await this.detach();
+		this.autoAttachEnabled = false;
+		if (this.browserSession) try {
+			await this.browserSession.detach();
+		} catch {} finally {
+			this.browserSession = null;
+		}
+	}
+	requireAttachedTargetSession() {
+		if (!this.attachedTargetSession) throw new Error("No CDP target is currently attached");
+		return this.attachedTargetSession;
+	}
+	async ensureBrowserSession() {
+		if (this.browserSession) return this.browserSession;
+		const browser = this.getBrowser();
+		if (!browser) throw new Error("Browser not connected");
+		this.browserSession = await browser.target().createCDPSession();
+		return this.browserSession;
+	}
+	matchesFilters(target, filters) {
+		if (filters.type && target.type !== filters.type) return false;
+		if (filters.types && filters.types.length > 0 && !filters.types.includes(target.type)) return false;
+		if (filters.targetId && target.targetId !== filters.targetId) return false;
+		if (filters.urlPattern && !target.url.includes(filters.urlPattern)) return false;
+		if (filters.titlePattern && !target.title.includes(filters.titlePattern)) return false;
+		if (filters.attachedOnly && !target.attached) return false;
+		return true;
+	}
+	normalizeTargetInfo(target) {
+		const targetId = typeof target.targetId === "string" ? target.targetId : null;
+		const type = typeof target.type === "string" ? target.type : null;
+		const title = typeof target.title === "string" ? target.title : "";
+		const url = typeof target.url === "string" ? target.url : "";
+		const attached = typeof target.attached === "boolean" ? target.attached : false;
+		if (!targetId || !type) return null;
+		return {
+			targetId,
+			type,
+			title,
+			url,
+			attached,
+			openerId: typeof target.openerId === "string" ? target.openerId : void 0,
+			canAccessOpener: typeof target.canAccessOpener === "boolean" ? target.canAccessOpener : void 0,
+			openerFrameId: typeof target.openerFrameId === "string" ? target.openerFrameId : void 0,
+			browserContextId: typeof target.browserContextId === "string" ? target.browserContextId : void 0,
+			subtype: typeof target.subtype === "string" ? target.subtype : void 0
+		};
+	}
+};
+//#endregion
+//#region src/utils/browserExecutable.ts
+/**
+* Browser executable resolution policy:
+* - Never scan host-installed browsers.
+* - Only honor explicit overrides from environment variables.
+* - Otherwise let Puppeteer handle browser resolution internally.
+*/
+const ENV_KEYS = [
+	"CHROME_PATH",
+	"PUPPETEER_EXECUTABLE_PATH",
+	"BROWSER_EXECUTABLE_PATH"
+];
+let cachedBrowserPath = null;
+function resolveFromEnvironment() {
+	for (const key of ENV_KEYS) {
+		const candidate = process.env[key]?.trim();
+		if (candidate && existsSync(candidate)) return candidate;
+	}
+}
+function resolveFromPuppeteer() {
+	try {
+		const candidate = executablePath("chrome");
+		if (candidate && existsSync(candidate)) return candidate;
+	} catch {}
+}
+/**
+* Resolve explicit browser executable path.
+*
+* Returns undefined when no explicit path is configured so callers can
+* fall back to Puppeteer's managed browser behavior.
+*/
+function findBrowserExecutable() {
+	if (cachedBrowserPath !== null) {
+		if (!cachedBrowserPath || existsSync(cachedBrowserPath)) return cachedBrowserPath;
+		cachedBrowserPath = null;
+	}
+	cachedBrowserPath = resolveFromEnvironment() ?? resolveFromPuppeteer();
+	return cachedBrowserPath;
+}
+//#endregion
+//#region src/modules/collector/PageScriptCollectors.ts
+async function setupWebWorkerTracking(page) {
+	await page.evaluateOnNewDocument(() => {
+		const workerWindow = window;
+		const originalWorker = workerWindow.Worker;
+		if (typeof originalWorker !== "function") return;
+		const workerUrls = Array.isArray(workerWindow.__workerUrls) ? workerWindow.__workerUrls : [];
+		workerWindow.Worker = new Proxy(originalWorker, { construct(target, args, newTarget) {
+			const worker = Reflect.construct(target, args, newTarget);
+			const [scriptURL] = args;
+			if (typeof scriptURL === "string") {
+				workerUrls.push(scriptURL);
+				workerWindow.__workerUrls = workerUrls;
+			} else if (scriptURL instanceof URL) {
+				workerUrls.push(scriptURL.toString());
+				workerWindow.__workerUrls = workerUrls;
+			}
+			return worker;
+		} });
+	});
+}
+async function collectInlineScripts(page, maxSingleSize, maxFilesPerCollect) {
+	const scripts = await page.evaluate((limit) => {
+		return Array.from(document.querySelectorAll("script")).filter((script) => !script.src && script.textContent).map((script, index) => {
+			let content = script.textContent || "";
+			const originalSize = content.length;
+			let truncated = false;
+			if (content.length > limit) {
+				content = content.substring(0, limit);
+				truncated = true;
+			}
+			return {
+				url: `inline-script-${index}`,
+				content,
+				size: content.length,
+				type: "inline",
+				metadata: {
+					scriptType: script.type || "text/javascript",
+					async: script.async,
+					defer: script.defer,
+					integrity: script.integrity || void 0,
+					truncated,
+					originalSize: truncated ? originalSize : void 0
+				}
+			};
+		});
+	}, maxSingleSize);
+	const limitedScripts = scripts.slice(0, maxFilesPerCollect);
+	if (scripts.length > limitedScripts.length) logger.warn(`Found ${scripts.length} inline scripts, limiting to ${maxFilesPerCollect}`);
+	const truncatedCount = limitedScripts.filter((s) => s.metadata?.truncated).length;
+	if (truncatedCount > 0) logger.warn(`${truncatedCount} inline scripts were truncated due to size limits`);
+	logger.debug(`Collected ${limitedScripts.length} inline scripts`);
+	return limitedScripts;
+}
+async function collectServiceWorkers(page, shouldCollectUrl = () => true) {
+	try {
+		const serviceWorkers = await page.evaluate(async () => {
+			if (!("serviceWorker" in navigator)) return [];
+			const registrations = await navigator.serviceWorker.getRegistrations();
+			const workers = [];
+			for (const registration of registrations) {
+				const worker = registration.active || registration.installing || registration.waiting;
+				if (worker && worker.scriptURL) workers.push({
+					url: worker.scriptURL,
+					scope: registration.scope,
+					state: worker.state
+				});
+			}
+			return workers;
+		});
+		const files = [];
+		for (const worker of serviceWorkers) {
+			if (!shouldCollectUrl(worker.url)) continue;
+			try {
+				const content = await page.evaluate(async (url) => {
+					return await (await fetch(url)).text();
+				}, worker.url);
+				if (content) {
+					files.push({
+						url: worker.url,
+						content,
+						size: content.length,
+						type: "service-worker"
+					});
+					logger.debug(`Collected Service Worker: ${worker.url}`);
+				}
+			} catch (error) {
+				logger.warn(`Failed to collect Service Worker: ${worker.url}`, error);
+			}
+		}
+		return files;
+	} catch (error) {
+		logger.warn("Service Worker collection failed", error);
+		return [];
+	}
+}
+async function collectWebWorkers(page, shouldCollectUrl = () => true) {
+	try {
+		const workerUrls = await page.evaluate(() => {
+			const workerWindow = window;
+			return Array.isArray(workerWindow.__workerUrls) ? workerWindow.__workerUrls : [];
+		});
+		const files = [];
+		for (const url of workerUrls) try {
+			const absoluteUrl = new URL(url, page.url()).href;
+			if (!shouldCollectUrl(absoluteUrl)) continue;
+			const content = await page.evaluate(async (workerUrl) => {
+				return await (await fetch(workerUrl)).text();
+			}, absoluteUrl);
+			if (content) {
+				files.push({
+					url: absoluteUrl,
+					content,
+					size: content.length,
+					type: "web-worker"
+				});
+				logger.debug(`Collected Web Worker: ${absoluteUrl}`);
+			}
+		} catch (error) {
+			logger.warn(`Failed to collect Web Worker: ${url}`, error);
+		}
+		return files;
+	} catch (error) {
+		logger.warn("Web Worker collection failed", error);
+		return [];
+	}
+}
+function analyzeDependencies(files) {
+	const nodes = [];
+	const edges = [];
+	files.forEach((file) => {
+		nodes.push({
+			id: file.url,
+			url: file.url,
+			type: file.type
+		});
+	});
+	files.forEach((file) => {
+		extractDependencies(file.content).forEach((dep) => {
+			const targetFile = files.find((f) => f.url.includes(dep) || f.url.endsWith(dep) || f.url.endsWith(`${dep}.js`));
+			if (targetFile) edges.push({
+				from: file.url,
+				to: targetFile.url,
+				type: "import"
+			});
+		});
+	});
+	logger.debug(`Dependency graph: ${nodes.length} nodes, ${edges.length} edges`);
+	return {
+		nodes,
+		edges
+	};
+}
+function extractDependencies(code) {
+	const dependencies = [];
+	const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+	let match;
+	while ((match = importRegex.exec(code)) !== null) if (match[1]) dependencies.push(match[1]);
+	const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+	while ((match = requireRegex.exec(code)) !== null) if (match[1]) dependencies.push(match[1]);
+	const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+	while ((match = dynamicImportRegex.exec(code)) !== null) if (match[1]) dependencies.push(match[1]);
+	return [...new Set(dependencies)];
+}
+function calculatePriorityScore(file) {
+	let score = 0;
+	if (file.type === "inline") score += 10;
+	else if (file.type === "external") score += 5;
+	if (file.size < 10 * 1024) score += 15;
+	else if (file.size < 50 * 1024) score += 10;
+	else if (file.size > 200 * 1024) score -= 10;
+	const url = file.url.toLowerCase();
+	if (url.includes("main") || url.includes("index") || url.includes("app")) score += 20;
+	if (url.includes("crypto") || url.includes("encrypt") || url.includes("sign")) score += 30;
+	if (url.includes("api") || url.includes("request") || url.includes("ajax")) score += 25;
+	if (url.includes("core") || url.includes("common") || url.includes("util")) score += 15;
+	if (url.includes("vendor") || url.includes("lib") || url.includes("jquery") || url.includes("react")) score -= 20;
+	if (url.includes("node_modules") || url.includes("bundle")) score -= 30;
+	return score;
+}
+//#endregion
+//#region src/modules/collector/CodeCollectorCollectInternal.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function toRecord(value) {
+	return isRecord(value) ? value : void 0;
+}
+function isCDPResponseReceivedParams(value) {
+	if (!isRecord(value) || !isRecord(value.response)) return false;
+	return typeof value.response.url === "string" && typeof value.requestId === "string";
+}
+function isCodeSummary(value) {
+	if (!isRecord(value)) return false;
+	return typeof value.url === "string" && typeof value.size === "number" && typeof value.type === "string" && typeof value.hasEncryption === "boolean" && typeof value.hasAPI === "boolean" && typeof value.hasObfuscation === "boolean" && Array.isArray(value.functions) && Array.isArray(value.imports) && typeof value.preview === "string";
+}
+function isCodeFile(value) {
+	if (!isRecord(value)) return false;
+	return typeof value.url === "string" && typeof value.content === "string" && typeof value.size === "number" && typeof value.type === "string";
+}
+function assertCollectorInternals(value) {
+	if (!isRecord(value)) throw new Error("Invalid collector context");
+	if (typeof value.init !== "function" || typeof value.applyAntiDetection !== "function" || typeof value.shouldCollectUrl !== "function") throw new Error("Invalid collector context");
+}
+async function collectInnerImpl(self, options) {
+	assertCollectorInternals(self);
+	const startTime = Date.now();
+	logger.info(`Collecting code from: ${options.url}`);
+	const cacheOptions = toRecord(options);
+	if (self.cacheEnabled) {
+		const cached = await self.cache.get(options.url, cacheOptions);
+		if (cached) {
+			logger.info(` Cache hit for: ${options.url}`);
+			return cached;
+		}
+	}
+	await self.init();
+	if (!self.browser) throw new Error("Browser not initialized");
+	const page = await self.browser.newPage();
+	try {
+		const timeoutMs = options.timeout ?? self.config.timeout ?? 3e4;
+		page.setDefaultTimeout(timeoutMs);
+		await page.setUserAgent(self.userAgent);
+		await self.applyAntiDetection(page);
+		if (options.includeWebWorker !== false) await setupWebWorkerTracking(page);
+		const files = [];
+		const appendFilesWithinLimit = (incoming, label) => {
+			const remaining = self.MAX_FILES_PER_COLLECT - files.length;
+			if (remaining <= 0) {
+				logger.warn(`Reached max files limit (${self.MAX_FILES_PER_COLLECT}), skipping ${label}`);
+				return;
+			}
+			if (incoming.length > remaining) logger.warn(`Collected ${incoming.length} ${label}, limiting to remaining ${remaining} files`);
+			files.push(...incoming.slice(0, remaining));
+		};
+		self.cdpSession = await page.createCDPSession();
+		await self.cdpSession.send("Network.enable");
+		await self.cdpSession.send("Runtime.enable");
+		self.cdpListeners.responseReceived = async (params) => {
+			if (!isCDPResponseReceivedParams(params)) return;
+			const { response, requestId, type } = params;
+			const url = response.url;
+			if (files.length >= self.MAX_FILES_PER_COLLECT) {
+				if (files.length === self.MAX_FILES_PER_COLLECT) logger.warn(`Reached max files limit (${self.MAX_FILES_PER_COLLECT}), will skip remaining files`);
+				return;
+			}
+			self.cleanupCollectedUrls();
+			if (type === "Script" || response.mimeType?.includes("javascript") || url.endsWith(".js")) {
+				if (options.includeExternal === false) return;
+				if (!self.shouldCollectUrl(url, options.filterRules)) return;
+				try {
+					const responseBody = await self.cdpSession.send("Network.getResponseBody", { requestId });
+					if (typeof responseBody.body !== "string") return;
+					const content = responseBody.base64Encoded ? Buffer.from(responseBody.body, "base64").toString("utf-8") : responseBody.body;
+					const contentSize = content.length;
+					let finalContent = content;
+					let truncated = false;
+					if (contentSize > self.MAX_SINGLE_FILE_SIZE) {
+						finalContent = content.substring(0, self.MAX_SINGLE_FILE_SIZE);
+						truncated = true;
+						logger.warn(`[CDP] Large file truncated: ${url} (${(contentSize / 1024).toFixed(2)} KB -> ${(self.MAX_SINGLE_FILE_SIZE / 1024).toFixed(2)} KB)`);
+					}
+					if (!self.collectedUrls.has(url)) {
+						self.collectedUrls.add(url);
+						const file = {
+							url,
+							content: finalContent,
+							size: finalContent.length,
+							type: "external",
+							metadata: truncated ? {
+								truncated: true,
+								originalSize: contentSize,
+								truncatedSize: finalContent.length
+							} : void 0
+						};
+						const fileCountBeforeAppend = files.length;
+						appendFilesWithinLimit([file], "external scripts");
+						if (files.length > fileCountBeforeAppend) {
+							self.collectedFilesCache.set(url, file);
+							logger.debug(`[CDP] Collected (${files.length}/${self.MAX_FILES_PER_COLLECT}): ${url} (${(finalContent.length / 1024).toFixed(2)} KB)${truncated ? " [TRUNCATED]" : ""}`);
+						}
+					}
+				} catch (error) {
+					logger.warn(`[CDP] Failed to get response body for: ${url}`, error);
+				}
+			}
+		};
+		self.cdpSession.on("Network.responseReceived", self.cdpListeners.responseReceived);
+		logger.info(`Navigating to: ${options.url}`);
+		await page.goto(options.url, {
+			waitUntil: "networkidle2",
+			timeout: options.timeout || self.config.timeout
+		});
+		if (options.includeInline !== false) {
+			logger.info("Collecting inline scripts...");
+			appendFilesWithinLimit(await collectInlineScripts(page, self.MAX_SINGLE_FILE_SIZE, self.MAX_FILES_PER_COLLECT), "inline scripts");
+		}
+		if (options.includeServiceWorker !== false) {
+			logger.info("Collecting Service Workers...");
+			appendFilesWithinLimit(await collectServiceWorkers(page, (url) => self.shouldCollectUrl(url, options.filterRules)), "service workers");
+		}
+		if (options.includeWebWorker !== false) {
+			logger.info("Collecting Web Workers...");
+			appendFilesWithinLimit(await collectWebWorkers(page, (url) => self.shouldCollectUrl(url, options.filterRules)), "web workers");
+		}
+		if (options.includeDynamic) {
+			logger.info("Waiting for dynamic scripts...");
+			await new Promise((resolve) => setTimeout(resolve, 3e3));
+		}
+		if (self.cdpSession) {
+			if (self.cdpListeners.responseReceived) self.cdpSession.off("Network.responseReceived", self.cdpListeners.responseReceived);
+			await self.cdpSession.detach();
+			self.cdpSession = null;
+			self.cdpListeners = {};
+		}
+		const collectTime = Date.now() - startTime;
+		const truncatedFiles = files.filter((f) => f.metadata?.truncated);
+		if (truncatedFiles.length > 0) {
+			logger.warn(`${truncatedFiles.length} files were truncated due to size limits`);
+			truncatedFiles.forEach((f) => {
+				const originalSize = typeof f.metadata?.originalSize === "number" ? f.metadata.originalSize : f.size;
+				logger.warn(`  - ${f.url}: ${(originalSize / 1024).toFixed(2)} KB -> ${(f.size / 1024).toFixed(2)} KB`);
+			});
+		}
+		let processedFiles = files;
+		if (options.smartMode && options.smartMode !== "full") try {
+			logger.info(` Applying smart collection mode: ${options.smartMode}`);
+			const smartOptions = {
+				mode: options.smartMode,
+				maxTotalSize: options.maxTotalSize,
+				maxFileSize: options.maxFileSize,
+				priorities: options.priorities
+			};
+			const smartResult = await self.smartCollector.smartCollect(page, files, smartOptions);
+			if (options.smartMode === "summary") {
+				logger.info(` Returning ${smartResult.length} code summaries`);
+				if (Array.isArray(smartResult) && smartResult.every((item) => isCodeSummary(item))) return {
+					files: [],
+					summaries: smartResult,
+					dependencies: {
+						nodes: [],
+						edges: []
+					},
+					totalSize: 0,
+					collectTime: Date.now() - startTime
+				};
+			}
+			if (Array.isArray(smartResult) && smartResult.every((item) => isCodeFile(item))) processedFiles = smartResult;
+			else {
+				logger.warn("Smart collection returned unexpected type, using original files");
+				processedFiles = files;
+			}
+		} catch (error) {
+			logger.error("Smart collection failed, using original files:", error);
+			processedFiles = files;
+		}
+		if (options.compress) try {
+			logger.info(`Compressing ${processedFiles.length} files with enhanced compressor...`);
+			const filesToCompress = processedFiles.filter((file) => self.compressor.shouldCompress(file.content)).map((file) => ({
+				url: file.url,
+				content: file.content
+			}));
+			if (filesToCompress.length === 0) logger.info("No files need compression (all below threshold)");
+			else {
+				const compressedResults = await self.compressor.compressBatch(filesToCompress, {
+					level: void 0,
+					useCache: true,
+					maxRetries: 3,
+					concurrency: 5,
+					onProgress: (progress) => {
+						if (progress % 25 === 0) logger.debug(`Compression progress: ${progress.toFixed(0)}%`);
+					}
+				});
+				const compressedMap = new Map(compressedResults.map((r) => [r.url, r]));
+				for (const file of processedFiles) {
+					const compressed = compressedMap.get(file.url);
+					if (compressed) file.metadata = {
+						...file.metadata,
+						compressed: true,
+						originalSize: compressed.originalSize,
+						compressedSize: compressed.compressedSize,
+						compressionRatio: compressed.compressionRatio
+					};
+				}
+				const stats = self.compressor.getStats();
+				logger.info(` Compressed ${compressedResults.length}/${processedFiles.length} files`);
+				logger.info(` Compression stats: ${(stats.totalOriginalSize / 1024).toFixed(2)} KB -> ${(stats.totalCompressedSize / 1024).toFixed(2)} KB (${stats.averageRatio.toFixed(1)}% reduction)`);
+				logger.info(` Cache: ${stats.cacheHits} hits, ${stats.cacheMisses} misses (${stats.cacheHits > 0 ? (stats.cacheHits / (stats.cacheHits + stats.cacheMisses) * 100).toFixed(1) : 0}% hit rate)`);
+			}
+		} catch (error) {
+			logger.error("Compression failed:", error);
+		}
+		const dependencies = analyzeDependencies(processedFiles);
+		const totalSize = processedFiles.reduce((sum, file) => sum + file.size, 0);
+		logger.success(`Collected ${processedFiles.length} files (${(totalSize / 1024).toFixed(2)} KB) in ${collectTime}ms`);
+		const result = {
+			files: processedFiles,
+			dependencies,
+			totalSize,
+			collectTime
+		};
+		if (self.cacheEnabled) {
+			await self.cache.set(options.url, result, cacheOptions);
+			logger.debug(` Saved to cache: ${options.url}`);
+		}
+		return result;
+	} catch (error) {
+		logger.error("Code collection failed", error);
+		throw error;
+	} finally {
+		if (self.cdpSession) {
+			try {
+				if (self.cdpListeners.responseReceived) self.cdpSession.off("Network.responseReceived", self.cdpListeners.responseReceived);
+				await self.cdpSession.detach();
+			} catch {}
+			self.cdpSession = null;
+			self.cdpListeners = {};
+		}
+		await page.close();
+	}
+}
+//#endregion
+//#region src/modules/collector/CodeCollectorUtilsInternal.ts
+function shouldCollectUrlImpl(url, filterRules) {
+	if (!filterRules || filterRules.length === 0) return true;
+	for (const rule of filterRules) if (new RegExp(rule.replace(/\*/g, ".*")).test(url)) return true;
+	return false;
+}
+async function navigateWithRetryImpl(page, url, options, maxRetries = 3) {
+	let lastError = null;
+	for (let i = 0; i < maxRetries; i++) try {
+		await page.goto(url, options);
+		return;
+	} catch (error) {
+		lastError = error;
+		logger.warn(`Navigation attempt ${i + 1}/${maxRetries} failed: ${error}`);
+		if (i < maxRetries - 1) await new Promise((resolve) => setTimeout(resolve, 1e3 * (i + 1)));
+	}
+	throw lastError || /* @__PURE__ */ new Error("Navigation failed after retries");
+}
+async function getPerformanceMetricsImpl(page) {
+	try {
+		return await page.evaluate(() => {
+			const perf = performance.getEntriesByType("navigation")[0];
+			return {
+				domContentLoaded: perf.domContentLoadedEventEnd - perf.domContentLoadedEventStart,
+				loadComplete: perf.loadEventEnd - perf.loadEventStart,
+				domInteractive: perf.domInteractive - perf.fetchStart,
+				totalTime: perf.loadEventEnd - perf.fetchStart
+			};
+		});
+	} catch (error) {
+		logger.warn("Failed to get performance metrics", error);
+		return {};
+	}
+}
+async function collectPageMetadataImpl(page) {
+	try {
+		return await page.evaluate(() => {
+			return {
+				title: document.title,
+				url: window.location.href,
+				userAgent: navigator.userAgent,
+				viewport: {
+					width: window.innerWidth,
+					height: window.innerHeight
+				},
+				cookies: document.cookie,
+				localStorage: Object.keys(localStorage).length,
+				sessionStorage: Object.keys(sessionStorage).length
+			};
+		});
+	} catch (error) {
+		logger.warn("Failed to collect page metadata", error);
+		return {};
+	}
+}
+//#endregion
+//#region src/modules/collector/playwright-cdp-fallback.ts
+let electronCompatPatched = false;
+function resolvePlaywrightInternalPaths() {
+	const packageRoot = dirname(createRequire(import.meta.url).resolve("playwright-core/package.json"));
+	return {
+		playwrightServerPath: join$1(packageRoot, "lib/server/playwright.js"),
+		crBrowserPath: join$1(packageRoot, "lib/server/chromium/crBrowser.js")
+	};
+}
+function ensureElectronDownloadBehaviorCompatPatch() {
+	if (electronCompatPatched) return;
+	const require = createRequire(import.meta.url);
+	const { playwrightServerPath, crBrowserPath } = resolvePlaywrightInternalPaths();
+	const { createPlaywright } = require(playwrightServerPath);
+	createPlaywright({
+		sdkLanguage: "javascript",
+		isInternalPlaywright: true
+	});
+	const { CRBrowserContext } = require(crBrowserPath);
+	if (CRBrowserContext.prototype.__jshookElectronCompatPatched) {
+		electronCompatPatched = true;
+		return;
+	}
+	const originalInitialize = CRBrowserContext.prototype._initialize;
+	CRBrowserContext.prototype._initialize = async function patchedInitialize(...args) {
+		try {
+			return await originalInitialize.apply(this, args);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (message.includes("Browser.setDownloadBehavior") && message.includes("Browser context management is not supported")) {
+				logger.warn("[playwright-cdp-fallback] Swallowed Browser.setDownloadBehavior for legacy Electron CDP endpoint.");
+				return;
+			}
+			throw error;
+		}
+	};
+	Object.defineProperty(CRBrowserContext.prototype, "__jshookElectronCompatPatched", {
+		value: true,
+		configurable: false,
+		enumerable: false,
+		writable: false
+	});
+	electronCompatPatched = true;
+}
+function normalizePlaywrightConnectEndpoint(endpoint) {
+	return endpoint;
+}
+function mapWaitUntil(waitUntil) {
+	if (waitUntil === "networkidle0" || waitUntil === "networkidle2") return "networkidle";
+	return waitUntil;
+}
+function getDefaultContext(browser) {
+	const context = browser.contexts()[0];
+	if (!context) throw new Error("Connected Playwright CDP browser exposes no default context. Cannot create or resolve pages.");
+	return context;
+}
+function createPageAdapter(playwrightPage, pageCache) {
+	const cached = pageCache.get(playwrightPage);
+	if (cached) return cached;
+	const proxiedPage = new Proxy({
+		async goto(url, options) {
+			return await playwrightPage.goto(url, {
+				...options,
+				waitUntil: mapWaitUntil(options?.waitUntil)
+			});
+		},
+		async reload(options) {
+			return await playwrightPage.reload({
+				...options,
+				waitUntil: mapWaitUntil(options?.waitUntil)
+			});
+		},
+		async waitForNavigation(options) {
+			const mappedWaitUntil = mapWaitUntil(options?.waitUntil);
+			if (typeof playwrightPage.waitForNavigation === "function") return await playwrightPage.waitForNavigation({
+				...options,
+				waitUntil: mappedWaitUntil
+			});
+			return await playwrightPage.waitForLoadState(mappedWaitUntil ?? "load", { timeout: options?.timeout });
+		},
+		async select(selector, ...values) {
+			return await playwrightPage.selectOption(selector, values);
+		},
+		async evaluateOnNewDocument(pageFunction, ...args) {
+			return await playwrightPage.addInitScript(pageFunction, ...[...args]);
+		},
+		async createCDPSession() {
+			const context = playwrightPage.context();
+			if (typeof context.newCDPSession !== "function") throw new Error("Playwright BrowserContext does not expose newCDPSession() for the attached page.");
+			return await context.newCDPSession(playwrightPage);
+		},
+		async setUserAgent(_userAgent) {
+			logger.debug("[playwright-cdp-fallback] Ignoring page.setUserAgent() for attached Playwright CDP page.");
+		}
+	}, { get(target, prop, receiver) {
+		if (Reflect.has(target, prop)) {
+			const value = Reflect.get(target, prop, receiver);
+			return typeof value === "function" ? value.bind(target) : value;
+		}
+		const value = Reflect.get(playwrightPage, prop);
+		return typeof value === "function" ? value.bind(playwrightPage) : value;
+	} });
+	pageCache.set(playwrightPage, proxiedPage);
+	return proxiedPage;
+}
+function createTargetAdapter(playwrightPage, pageCache) {
+	return {
+		type: () => "page",
+		url: () => playwrightPage.url(),
+		page: async () => createPageAdapter(playwrightPage, pageCache)
+	};
+}
+function createBrowserAdapter(playwrightBrowser) {
+	const pageCache = /* @__PURE__ */ new WeakMap();
+	return new Proxy({
+		targets() {
+			return playwrightBrowser.contexts().flatMap((context) => context.pages()).map((page) => createTargetAdapter(page, pageCache));
+		},
+		async pages() {
+			return playwrightBrowser.contexts().flatMap((context) => context.pages()).map((page) => createPageAdapter(page, pageCache));
+		},
+		async newPage() {
+			return createPageAdapter(await getDefaultContext(playwrightBrowser).newPage(), pageCache);
+		},
+		async disconnect() {
+			await playwrightBrowser.close();
+		},
+		async close() {
+			await playwrightBrowser.close();
+		}
+	}, { get(target, prop, receiver) {
+		if (Reflect.has(target, prop)) {
+			const value = Reflect.get(target, prop, receiver);
+			return typeof value === "function" ? value.bind(target) : value;
+		}
+		const value = Reflect.get(playwrightBrowser, prop);
+		return typeof value === "function" ? value.bind(playwrightBrowser) : value;
+	} });
+}
+async function connectPlaywrightCdpFallback(endpoint, timeoutMs) {
+	ensureElectronDownloadBehaviorCompatPatch();
+	const { chromium } = await import("playwright-core");
+	return createBrowserAdapter(await chromium.connectOverCDP(normalizePlaywrightConnectEndpoint(endpoint), { timeout: timeoutMs }));
+}
+//#endregion
+//#region src/modules/collector/CodeCollectorConnectionInternal.ts
+function resolveDefaultChromeUserDataDir(channel = "stable") {
+	const home = homedir();
+	if (process.platform === "win32") {
+		const localAppData = process.env.LOCALAPPDATA ?? join(home, "AppData", "Local");
+		switch (channel) {
+			case "beta": return join(localAppData, "Google", "Chrome Beta", "User Data");
+			case "dev": return join(localAppData, "Google", "Chrome Dev", "User Data");
+			case "canary": return join(localAppData, "Google", "Chrome SxS", "User Data");
+			default: return join(localAppData, "Google", "Chrome", "User Data");
+		}
+	}
+	if (process.platform === "darwin") {
+		const appSupport = join(home, "Library", "Application Support");
+		switch (channel) {
+			case "beta": return join(appSupport, "Google", "Chrome Beta");
+			case "dev": return join(appSupport, "Google", "Chrome Dev");
+			case "canary": return join(appSupport, "Google", "Chrome Canary");
+			default: return join(appSupport, "Google", "Chrome");
+		}
+	}
+	const configHome = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
+	switch (channel) {
+		case "beta": return join(configHome, "google-chrome-beta");
+		case "dev": return join(configHome, "google-chrome-unstable");
+		case "canary": return join(configHome, "google-chrome-canary");
+		default: return join(configHome, "google-chrome");
+	}
+}
+async function resolveAutoConnectWsEndpointImpl(options) {
+	const channel = options.channel ?? "stable";
+	const devToolsActivePortPath = join(options.userDataDir ?? resolveDefaultChromeUserDataDir(channel), "DevToolsActivePort");
+	let fileContent;
+	try {
+		fileContent = await readFile(devToolsActivePortPath, "utf8");
+	} catch (error) {
+		throw new Error(`Could not read DevToolsActivePort from "${devToolsActivePortPath}". Check if Chrome is running from this profile and remote debugging is enabled at chrome://inspect/#remote-debugging.`, { cause: error });
+	}
+	const [rawPort, rawPath] = fileContent.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+	if (!rawPort || !rawPath) throw new Error(`Invalid DevToolsActivePort contents found in "${devToolsActivePortPath}".`);
+	const port = Number.parseInt(rawPort, 10);
+	if (!Number.isInteger(port) || port <= 0 || port > 65535) throw new Error(`Invalid remote debugging port "${rawPort}" in "${devToolsActivePortPath}".`);
+	return `ws://127.0.0.1:${port}${rawPath}`;
+}
+async function resolveConnectOptionsImpl(endpointOrOptions) {
+	if (typeof endpointOrOptions === "string") {
+		const endpoint = endpointOrOptions.trim();
+		if (!endpoint) throw new Error("Connection endpoint cannot be empty.");
+		return endpoint.startsWith("ws://") || endpoint.startsWith("wss://") ? { browserWSEndpoint: endpoint } : { browserURL: endpoint };
+	}
+	if (endpointOrOptions.wsEndpoint) return { browserWSEndpoint: endpointOrOptions.wsEndpoint };
+	if (endpointOrOptions.browserURL) return { browserURL: endpointOrOptions.browserURL };
+	if (endpointOrOptions.autoConnect || endpointOrOptions.userDataDir || endpointOrOptions.channel) return { browserWSEndpoint: await resolveAutoConnectWsEndpointImpl(endpointOrOptions) };
+	throw new Error("browserURL, wsEndpoint, autoConnect, userDataDir, or channel is required to connect to an existing browser.");
+}
+function isAutoConnectRequest(endpointOrOptions) {
+	return typeof endpointOrOptions !== "string" && Boolean(endpointOrOptions.autoConnect || endpointOrOptions.userDataDir || endpointOrOptions.channel);
+}
+function getUnknownErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null) {
+		const directMessage = "message" in error && typeof error.message === "string" ? error.message.trim() : "";
+		if (directMessage) return directMessage;
+		const nestedError = "error" in error ? error.error : void 0;
+		if (nestedError instanceof Error && nestedError.message) return nestedError.message;
+		if (typeof nestedError === "object" && nestedError !== null) {
+			const nestedMessage = "message" in nestedError && typeof nestedError.message === "string" ? nestedError.message.trim() : "";
+			if (nestedMessage) return nestedMessage;
+		}
+		const serialized = JSON.stringify(error);
+		if (serialized && serialized !== "{}") return serialized;
+	}
+	return String(error);
+}
+function normalizeConnectError(error, target, endpointOrOptions) {
+	const message = getUnknownErrorMessage(error);
+	if (isAutoConnectRequest(endpointOrOptions) && /ECONNREFUSED/i.test(message)) return /* @__PURE__ */ new Error(`Failed to connect to existing browser: ${message}. Chrome is not currently listening at ${target}. DevToolsActivePort may be stale after a browser restart. Re-open Chrome, confirm remote debugging is enabled at chrome://inspect/#remote-debugging, click Allow if prompted, and retry.`);
+	return error instanceof Error ? error : /* @__PURE__ */ new Error(`Failed to connect to existing browser: ${message}`);
+}
+function buildConnectTimeoutError(target, endpointOrOptions, timeoutMs) {
+	const baseMessage = `Timed out after ${timeoutMs}ms while connecting to existing browser: ${target}. The CDP handshake did not complete in time.`;
+	if (isAutoConnectRequest(endpointOrOptions)) return /* @__PURE__ */ new Error(`${baseMessage} If Chrome prompted for remote debugging approval, click Allow in Chrome and then retry the tool call.`);
+	return /* @__PURE__ */ new Error(`${baseMessage} Verify that the browser debugging endpoint is reachable and retry.`);
+}
+function shouldAttemptPlaywrightFallback(error) {
+	const message = getUnknownErrorMessage(error);
+	if (/ECONNREFUSED|ENOTFOUND|404|stale/i.test(message)) return false;
+	return /timed out|handshake|Protocol error|Target closed|ECONNRESET|socket hang up|WebSocket/i.test(message);
+}
+async function connectWithPlaywrightFallbackImpl(connectOptions, primaryError, timeoutMs) {
+	const endpoint = connectOptions.browserWSEndpoint ?? connectOptions.browserURL;
+	if (!endpoint) throw primaryError instanceof Error ? primaryError : new Error(String(primaryError));
+	logger.warn(`[connect-fallback] Rebrowser connect failed. Falling back to Playwright CDP compatibility mode for ${endpoint}.`);
+	try {
+		return await connectPlaywrightCdpFallback(endpoint, timeoutMs);
+	} catch (fallbackError) {
+		const primaryMessage = getUnknownErrorMessage(primaryError);
+		const fallbackMessage = getUnknownErrorMessage(fallbackError);
+		throw new Error(`Failed to connect to existing browser via both rebrowser-puppeteer and Playwright CDP compatibility fallback. Primary error: ${primaryMessage}. Fallback error: ${fallbackMessage}.`, { cause: fallbackError });
+	}
+}
+async function connectWithTimeoutImpl(connectOptions, target, endpointOrOptions, timeoutMs, connectAttemptRef) {
+	const attemptId = ++connectAttemptRef.current;
+	try {
+		return await new Promise((resolve, reject) => {
+			let settled = false;
+			const timer = setTimeout(() => {
+				settled = true;
+				if (connectAttemptRef.current === attemptId) connectAttemptRef.current += 1;
+				reject(buildConnectTimeoutError(target, endpointOrOptions, timeoutMs));
+			}, timeoutMs);
+			connect({
+				...connectOptions,
+				defaultViewport: null
+			}).then(async (browser) => {
+				if (settled || connectAttemptRef.current !== attemptId) {
+					try {
+						await browser.disconnect();
+					} catch {}
+					return;
+				}
+				settled = true;
+				clearTimeout(timer);
+				resolve(browser);
+			}).catch((error) => {
+				if (settled || connectAttemptRef.current !== attemptId) return;
+				settled = true;
+				clearTimeout(timer);
+				reject(normalizeConnectError(error, target, endpointOrOptions));
+			});
+		});
+	} catch (error) {
+		if (!shouldAttemptPlaywrightFallback(error)) throw error;
+		return await connectWithPlaywrightFallbackImpl(connectOptions, error, timeoutMs);
+	}
+}
+//#endregion
+//#region src/modules/collector/CodeCollectorFileQueryInternal.ts
+function getCollectedFilesSummaryImpl(collectedFilesCache) {
+	const summaries = Array.from(collectedFilesCache.values()).map((file) => ({
+		url: file.url,
+		size: file.size,
+		type: file.type,
+		truncated: typeof file.metadata?.truncated === "boolean" ? file.metadata.truncated : void 0,
+		originalSize: typeof file.metadata?.originalSize === "number" ? file.metadata.originalSize : void 0
+	}));
+	logger.info(`Returning summary of ${summaries.length} collected files`);
+	return summaries;
+}
+function getFileByUrlImpl(collectedFilesCache, url) {
+	const file = collectedFilesCache.get(url);
+	if (file) {
+		logger.info(`Returning file: ${url} (${(file.size / 1024).toFixed(2)} KB)`);
+		return file;
+	}
+	logger.warn(`File not found: ${url}`);
+	return null;
+}
+function getFilesByPatternImpl(collectedFilesCache, pattern, limit, maxTotalSize) {
+	const regex = new RegExp(pattern);
+	const matched = [];
+	for (const file of collectedFilesCache.values()) if (regex.test(file.url)) matched.push(file);
+	const returned = [];
+	let totalSize = 0;
+	let truncated = false;
+	for (let i = 0; i < matched.length && i < limit; i++) {
+		const file = matched[i];
+		if (file && totalSize + file.size <= maxTotalSize) {
+			returned.push(file);
+			totalSize += file.size;
+		} else {
+			truncated = true;
+			break;
+		}
+	}
+	if (truncated || matched.length > limit) logger.warn(`Pattern "${pattern}" matched ${matched.length} files, returning ${returned.length} (limited by size/count)`);
+	logger.info(` Pattern "${pattern}": matched ${matched.length}, returning ${returned.length} files (${(totalSize / 1024).toFixed(2)} KB)`);
+	return {
+		files: returned,
+		totalSize,
+		matched: matched.length,
+		returned: returned.length,
+		truncated
+	};
+}
+function getTopPriorityFilesImpl(collectedFilesCache, topN, maxTotalSize) {
+	const allFiles = Array.from(collectedFilesCache.values());
+	const scoredFiles = allFiles.map((file) => ({
+		file,
+		score: calculatePriorityScore(file)
+	}));
+	scoredFiles.sort((a, b) => b.score - a.score);
+	const selected = [];
+	let totalSize = 0;
+	for (let i = 0; i < Math.min(topN, scoredFiles.length); i++) {
+		const item = scoredFiles[i];
+		if (item?.file && totalSize + item.file.size <= maxTotalSize) {
+			selected.push(item.file);
+			totalSize += item.file.size;
+		} else break;
+	}
+	logger.info(`Returning top ${selected.length}/${allFiles.length} priority files (${(totalSize / 1024).toFixed(2)} KB)`);
+	return {
+		files: selected,
+		totalSize,
+		totalFiles: allFiles.length
+	};
+}
+//#endregion
+//#region src/modules/collector/CodeCollector.ts
+var CodeCollector = class CodeCollector {
+	config;
+	browser = null;
+	collectedUrls = /* @__PURE__ */ new Set();
+	initPromise = null;
+	collectLock = null;
+	connectAttemptRef = { current: 0 };
+	MAX_COLLECTED_URLS;
+	MAX_FILES_PER_COLLECT;
+	MAX_RESPONSE_SIZE;
+	MAX_SINGLE_FILE_SIZE;
+	CONNECT_TIMEOUT_MS;
+	viewport;
+	userAgent;
+	collectedFilesCache = /* @__PURE__ */ new Map();
+	cache;
+	cacheEnabled = true;
+	smartCollector;
+	compressor;
+	cdpSession = null;
+	browserTargetSessionManager = null;
+	cdpListeners = {};
+	activePageIndex = null;
+	currentHeadless = null;
+	explicitlyClosed = false;
+	connectedToExistingBrowser = false;
+	/** PID of the Chrome child process launched by puppeteer, used for force-kill fallback. */
+	chromePid = null;
+	static BROWSER_CLOSE_TIMEOUT_MS = 5e3;
+	constructor(config) {
+		this.config = config;
+		this.MAX_COLLECTED_URLS = config.maxCollectedUrls ?? 1e4;
+		this.MAX_FILES_PER_COLLECT = config.maxFilesPerCollect ?? 200;
+		this.MAX_RESPONSE_SIZE = config.maxTotalContentSize ?? 512 * 1024;
+		this.MAX_SINGLE_FILE_SIZE = config.maxSingleFileSize ?? 200 * 1024;
+		this.CONNECT_TIMEOUT_MS = Number(process.env.JSHOOK_CONNECT_TIMEOUT_MS) || 6e4;
+		this.viewport = config.viewport ?? {
+			width: 1920,
+			height: 1080
+		};
+		this.userAgent = config.userAgent ?? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+		this.cache = new CodeCache();
+		this.smartCollector = new SmartCodeCollector();
+		this.compressor = new CodeCompressor();
+		logger.info(` CodeCollector limits: maxCollect=${this.MAX_FILES_PER_COLLECT} files, maxResponse=${(this.MAX_RESPONSE_SIZE / 1024).toFixed(0)}KB, maxSingle=${(this.MAX_SINGLE_FILE_SIZE / 1024).toFixed(0)}KB`);
+		logger.info(` Strategy: Collect ALL files -> Cache -> Return summary/partial data to fit MCP limits`);
+	}
+	setCacheEnabled(enabled) {
+		this.cacheEnabled = enabled;
+		logger.info(`Code cache ${enabled ? "enabled" : "disabled"}`);
+	}
+	async clearFileCache() {
+		await this.cache.clear();
+	}
+	async getFileCacheStats() {
+		return await this.cache.getStats();
+	}
+	async clearAllData() {
+		logger.info("Clearing all collected data...");
+		await this.cache.clear();
+		this.compressor.clearCache();
+		this.compressor.resetStats();
+		this.collectedUrls.clear();
+		this.collectedFilesCache.clear();
+		logger.success("All data cleared");
+	}
+	async getAllStats() {
+		return {
+			cache: await this.cache.getStats(),
+			compression: {
+				...this.compressor.getStats(),
+				cacheSize: this.compressor.getCacheSize()
+			},
+			collector: {
+				collectedUrls: this.collectedUrls.size,
+				maxCollectedUrls: this.MAX_COLLECTED_URLS
+			}
+		};
+	}
+	getCache() {
+		return this.cache;
+	}
+	getCompressor() {
+		return this.compressor;
+	}
+	cleanupCollectedUrls() {
+		if (this.collectedUrls.size > this.MAX_COLLECTED_URLS) {
+			logger.warn(`Collected URLs exceeded ${this.MAX_COLLECTED_URLS}, clearing...`);
+			const urls = Array.from(this.collectedUrls);
+			this.collectedUrls.clear();
+			urls.slice(-Math.floor(this.MAX_COLLECTED_URLS / 2)).forEach((url) => this.collectedUrls.add(url));
+		}
+	}
+	async init(headless) {
+		if (this.browser) return;
+		this.explicitlyClosed = false;
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this.initInner(headless);
+		try {
+			await this.initPromise;
+		} finally {
+			this.initPromise = null;
+		}
+	}
+	async initInner(headless) {
+		const useHeadless = headless ?? this.config.headless;
+		const executablePath = this.resolveExecutablePath();
+		const launchOptions = {
+			headless: useHeadless,
+			args: [
+				...this.config.args || [],
+				"--no-sandbox",
+				"--disable-setuid-sandbox",
+				"--disable-dev-shm-usage",
+				"--disable-blink-features=AutomationControlled",
+				"--disable-extensions",
+				"--disable-component-extensions-with-background-pages",
+				"--disable-web-security",
+				"--disable-features=IsolateOrigins,site-per-process",
+				`--window-size=${this.viewport.width},${this.viewport.height}`,
+				"--ignore-certificate-errors"
+			],
+			defaultViewport: this.viewport,
+			protocolTimeout: 6e4
+		};
+		if (executablePath) launchOptions.executablePath = executablePath;
+		logger.info("Initializing browser with anti-detection...");
+		this.browser = await launch(launchOptions);
+		this.connectedToExistingBrowser = false;
+		this.chromePid = this.browser.process()?.pid ?? null;
+		if (this.chromePid) logger.debug(`Chrome child process PID: ${this.chromePid}`);
+		this.currentHeadless = useHeadless === void 0 ? true : useHeadless !== false;
+		this.browser.on("disconnected", () => {
+			logger.warn("Browser disconnected");
+			this.browser = null;
+			this.currentHeadless = null;
+			this.connectedToExistingBrowser = false;
+			this.chromePid = null;
+			this.browserTargetSessionManager?.dispose();
+			this.browserTargetSessionManager = null;
+			if (this.cdpSession) {
+				this.cdpSession = null;
+				this.cdpListeners = {};
+			}
+		});
+		logger.success("Browser initialized with enhanced anti-detection");
+	}
+	resolveExecutablePath() {
+		const configuredPath = this.config.executablePath?.trim();
+		if (configuredPath) {
+			if (existsSync(configuredPath)) return configuredPath;
+			throw new Error(`Configured browser executable was not found: ${configuredPath}. Set a valid executablePath or configure CHROME_PATH / PUPPETEER_EXECUTABLE_PATH / BROWSER_EXECUTABLE_PATH.`);
+		}
+		const detectedPath = findBrowserExecutable();
+		if (detectedPath) return detectedPath;
+		logger.info("No explicit browser executable configured. Falling back to Puppeteer-managed browser resolution.");
+	}
+	async close() {
+		await this.clearAllData();
+		this.explicitlyClosed = true;
+		this.activePageIndex = null;
+		const browser = this.browser;
+		const disconnectOnly = this.connectedToExistingBrowser;
+		const pid = this.chromePid;
+		this.browser = null;
+		this.currentHeadless = null;
+		this.connectedToExistingBrowser = false;
+		this.chromePid = null;
+		await this.browserTargetSessionManager?.dispose();
+		this.browserTargetSessionManager = null;
+		if (this.cdpSession) {
+			this.cdpSession = null;
+			this.cdpListeners = {};
+		}
+		if (browser) if (disconnectOnly) await browser.disconnect();
+		else await this.closeBrowserWithForceKill(browser, pid);
+		logger.info("Browser closed and all data cleared");
+	}
+	/**
+	* Close browser with a timeout guard. If browser.close() hangs or fails,
+	* force-kill the Chrome child process by PID to prevent zombie processes.
+	*/
+	async closeBrowserWithForceKill(browser, pid) {
+		try {
+			await Promise.race([browser.close(), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("browser.close() timed out")), CodeCollector.BROWSER_CLOSE_TIMEOUT_MS))]);
+		} catch (error) {
+			logger.warn("browser.close() failed or timed out, attempting force-kill:", error);
+			CodeCollector.forceKillPid(pid);
+		}
+	}
+	/** Force-kill a process by PID. Safe to call with null/invalid PIDs. */
+	static forceKillPid(pid) {
+		if (!pid) return;
+		try {
+			process.kill(pid, "SIGKILL");
+			logger.info(`Force-killed Chrome process PID ${pid}`);
+		} catch (error) {
+			if (error.code !== "ESRCH") logger.warn(`Failed to force-kill Chrome PID ${pid}:`, error);
+		}
+	}
+	/** Get the tracked Chrome child process PID (null if not launched or already closed). */
+	getChromePid() {
+		return this.chromePid;
+	}
+	getPageTargets() {
+		if (!this.browser) return [];
+		return this.browser.targets().filter((target) => target.type() === "page");
+	}
+	async resolvePageTargetHandle(target, timeoutMs = 5e3) {
+		const page = await Promise.race([target.page(), new Promise((_, reject) => {
+			setTimeout(() => {
+				reject(new PrerequisiteError(`Timed out after ${timeoutMs}ms while resolving a Puppeteer Page handle from the attached Chrome target.`));
+			}, timeoutMs);
+		})]);
+		if (!page) throw new PrerequisiteError("Attached browser target does not expose a Puppeteer Page handle in the current Chrome remote debugging mode.");
+		return page;
+	}
+	isExistingBrowserConnection() {
+		return this.connectedToExistingBrowser;
+	}
+	async getActivePage() {
+		if (!this.browser) {
+			if (this.explicitlyClosed) throw new PrerequisiteError("Browser was explicitly closed. Call browser_launch or browser_attach first.");
+			try {
+				await this.init();
+			} catch (error) {
+				throw new PrerequisiteError(`Browser not available: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		const pageTargets = this.getPageTargets();
+		if (pageTargets.length === 0) return await this.browser.newPage();
+		if (this.activePageIndex !== null && this.activePageIndex < pageTargets.length) return await this.resolvePageTargetHandle(pageTargets[this.activePageIndex]);
+		const lastTarget = pageTargets[pageTargets.length - 1];
+		if (!lastTarget) throw new Error("Failed to get active page");
+		return await this.resolvePageTargetHandle(lastTarget);
+	}
+	async listPages() {
+		if (!this.browser) return [];
+		return this.getPageTargets().map((target, index) => ({
+			index,
+			url: target.url(),
+			title: ""
+		}));
+	}
+	async listResolvedPages(timeoutMs = 1500) {
+		if (!this.browser) return [];
+		const targets = this.getPageTargets();
+		return (await Promise.all(targets.map(async (target, index) => {
+			try {
+				const page = await this.resolvePageTargetHandle(target, timeoutMs);
+				let title = "";
+				try {
+					title = await Promise.race([page.title(), new Promise((resolve) => {
+						setTimeout(() => resolve(""), timeoutMs);
+					})]);
+				} catch {
+					title = "";
+				}
+				return {
+					index,
+					url: target.url(),
+					title,
+					page
+				};
+			} catch {
+				return null;
+			}
+		}))).filter((page) => page !== null);
+	}
+	async selectPage(index) {
+		if (!this.browser) throw new Error("Browser not connected");
+		const pages = await this.listPages();
+		if (index < 0 || index >= pages.length) throw new Error(`Page index ${index} out of range (0-${pages.length - 1})`);
+		this.activePageIndex = index;
+		logger.info(`Active page set to index ${index}: ${pages[index].url}`);
+	}
+	async createPage(url) {
+		if (!this.browser) await this.init();
+		const page = await this.browser.newPage();
+		await page.setUserAgent(this.userAgent);
+		await this.applyAntiDetection(page);
+		if (url) await page.goto(url, {
+			waitUntil: "networkidle2",
+			timeout: this.config.timeout
+		});
+		logger.info(`New page created${url ? `: ${url}` : ""}`);
+		return page;
+	}
+	async applyAntiDetection(page) {
+		await page.evaluateOnNewDocument(() => {
+			Object.defineProperty(navigator, "webdriver", { get: () => false });
+			Object.defineProperty(navigator, "plugins", { get: () => [
+				1,
+				2,
+				3,
+				4,
+				5
+			] });
+			Object.defineProperty(navigator, "languages", { get: () => ["en-US", "en"] });
+			const win = window;
+			if (!win.chrome) win.chrome = {
+				runtime: {},
+				loadTimes: function() {},
+				csi: function() {},
+				app: {}
+			};
+			const originalQuery = window.navigator.permissions.query;
+			window.navigator.permissions.query = (parameters) => {
+				if (parameters.name === "notifications") return Promise.resolve({ state: "denied" });
+				return originalQuery(parameters);
+			};
+		});
+	}
+	async getStatus() {
+		if (!this.browser) return {
+			running: false,
+			pagesCount: 0
+		};
+		try {
+			const version = await this.browser.version();
+			return {
+				running: true,
+				pagesCount: this.getPageTargets().length,
+				version,
+				effectiveHeadless: this.currentHeadless ?? void 0
+			};
+		} catch (error) {
+			logger.debug("Browser not running or disconnected:", error);
+			return {
+				running: false,
+				pagesCount: 0
+			};
+		}
+	}
+	async collect(options) {
+		while (this.collectLock) try {
+			await this.collectLock;
+		} catch {}
+		let resolve;
+		let reject;
+		this.collectLock = new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		});
+		try {
+			const result = await this.collectInner(options);
+			resolve(result);
+			return result;
+		} catch (e) {
+			reject(e);
+			throw e;
+		} finally {
+			this.collectLock = null;
+		}
+	}
+	async collectInner(options) {
+		return collectInnerImpl(this, options);
+	}
+	shouldCollectUrl(url, filterRules) {
+		return shouldCollectUrlImpl(url, filterRules);
+	}
+	async navigateWithRetry(page, url, options, maxRetries = 3) {
+		return navigateWithRetryImpl(page, url, options, maxRetries);
+	}
+	async getPerformanceMetrics(page) {
+		return getPerformanceMetricsImpl(page);
+	}
+	async collectPageMetadata(page) {
+		return collectPageMetadataImpl(page);
+	}
+	async resolveConnectOptions(endpointOrOptions) {
+		return resolveConnectOptionsImpl(endpointOrOptions);
+	}
+	async connectWithTimeout(connectOptions, target, endpointOrOptions) {
+		return connectWithTimeoutImpl(connectOptions, target, endpointOrOptions, this.CONNECT_TIMEOUT_MS, this.connectAttemptRef);
+	}
+	async connect(endpointOrOptions) {
+		this.explicitlyClosed = false;
+		await this.browserTargetSessionManager?.dispose();
+		this.browserTargetSessionManager = null;
+		if (this.browser) {
+			try {
+				await this.browser.disconnect();
+			} catch {}
+			this.browser = null;
+			this.currentHeadless = null;
+		}
+		this.activePageIndex = null;
+		const connectOptions = await this.resolveConnectOptions(endpointOrOptions);
+		const target = connectOptions.browserWSEndpoint ?? connectOptions.browserURL ?? "auto-detected Chrome debugging endpoint";
+		logger.info(`Connecting to existing browser: ${target}`);
+		this.browser = await this.connectWithTimeout(connectOptions, target, endpointOrOptions);
+		this.connectedToExistingBrowser = true;
+		this.browser.on("disconnected", () => {
+			logger.warn("Browser disconnected");
+			this.browser = null;
+			this.currentHeadless = null;
+			this.connectedToExistingBrowser = false;
+			this.browserTargetSessionManager?.dispose();
+			this.browserTargetSessionManager = null;
+			if (this.cdpSession) {
+				this.cdpSession = null;
+				this.cdpListeners = {};
+			}
+		});
+		logger.success("Connected to existing browser successfully");
+	}
+	getBrowser() {
+		return this.browser;
+	}
+	getBrowserTargetSessionManager() {
+		if (!this.browserTargetSessionManager) this.browserTargetSessionManager = new BrowserTargetSessionManager(() => this.browser);
+		return this.browserTargetSessionManager;
+	}
+	async listCdpTargets(filters) {
+		return await this.getBrowserTargetSessionManager().listTargets(filters);
+	}
+	async attachCdpTarget(targetId) {
+		return await this.getBrowserTargetSessionManager().attach(targetId);
+	}
+	async detachCdpTarget() {
+		return await this.getBrowserTargetSessionManager().detach();
+	}
+	getAttachedTargetSession() {
+		return this.browserTargetSessionManager?.getAttachedTargetSession() ?? null;
+	}
+	getAttachedTargetInfo() {
+		return this.browserTargetSessionManager?.getAttachedTargetInfo() ?? null;
+	}
+	getCollectionStats() {
+		return {
+			totalCollected: this.collectedUrls.size,
+			uniqueUrls: this.collectedUrls.size
+		};
+	}
+	clearCache() {
+		this.collectedUrls.clear();
+		logger.info("Collection cache cleared");
+	}
+	getCollectedFilesSummary() {
+		return getCollectedFilesSummaryImpl(this.collectedFilesCache);
+	}
+	getFileByUrl(url) {
+		return getFileByUrlImpl(this.collectedFilesCache, url);
+	}
+	getFilesByPattern(pattern, limit = 20, maxTotalSize = this.MAX_RESPONSE_SIZE) {
+		return getFilesByPatternImpl(this.collectedFilesCache, pattern, limit, maxTotalSize);
+	}
+	getTopPriorityFiles(topN = 10, maxTotalSize = this.MAX_RESPONSE_SIZE) {
+		return getTopPriorityFilesImpl(this.collectedFilesCache, topN, maxTotalSize);
+	}
+	clearCollectedFilesCache() {
+		const count = this.collectedFilesCache.size;
+		this.collectedFilesCache.clear();
+		logger.info(`Cleared collected files cache (${count} files)`);
+	}
+};
+//#endregion
+//#region src/modules/collector/DOMInspector.evaluations.ts
+const serializeForEvaluation = (value) => value === void 0 ? "undefined" : JSON.stringify(value);
+const SHADOW_DOM_WALKER_SCRIPT = `
+const walkShadowRoots = () => {
+  const roots = [document];
+  const queue = [document];
+  let shadowRootCount = 0;
+  while (queue.length > 0) {
+    const root = queue.shift();
+    if (!root) continue;
+    for (const element of Array.from(root.querySelectorAll('*'))) {
+      const shadowRoot = element.shadowRoot;
+      if (shadowRoot) {
+        roots.push(shadowRoot);
+        queue.push(shadowRoot);
+        shadowRootCount += 1;
+      }
+    }
+  }
+  return { roots, shadowRootCount };
+};
+`.trim();
+function buildQueryAllEvaluation(selector, limit) {
+	return `
+${SHADOW_DOM_WALKER_SCRIPT}
+const selector = ${serializeForEvaluation(selector)};
+const maxLimit = ${serializeForEvaluation(limit)};
+const { roots, shadowRootCount } = walkShadowRoots();
+const seen = new Set();
+const results = [];
+let totalMatches = 0;
+for (const root of roots) {
+  const nodeList = Array.from(root.querySelectorAll(selector));
+  totalMatches += nodeList.length;
+  for (const element of nodeList) {
+    if (seen.has(element)) continue;
+    seen.add(element);
+    const attributes = {};
+    for (const attr of Array.from(element.attributes)) {
+      attributes[attr.name] = attr.value;
+    }
+    const rect = element.getBoundingClientRect();
+    const style = window.getComputedStyle(element);
+    const textContent = element.textContent?.trim() || '';
+    results.push({
+      found: true,
+      nodeName: element.nodeName,
+      attributes,
+      textContent: textContent.length > 500 ? textContent.substring(0, 500) + '...[truncated]' : textContent,
+      boundingBox: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
+      visible: style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0',
+    });
+    if (results.length >= maxLimit) break;
+  }
+  if (results.length >= maxLimit) break;
+}
+if (totalMatches > maxLimit) {
+  console.warn('[DOMInspector] Found ' + totalMatches + ' elements for "' + selector + '", limiting to ' + maxLimit);
+}
+return { elements: results, diagnostics: { readyState: document.readyState, shadowRootCount } };
+`.trim();
+}
+function buildFindClickableEvaluation(filterText) {
+	return `
+${SHADOW_DOM_WALKER_SCRIPT}
+const filter = ${serializeForEvaluation(filterText)};
+const normalizedFilter = filter?.toLowerCase();
+const { roots, shadowRootCount } = walkShadowRoots();
+const results = [];
+const seen = new Set();
+const appendClickable = (element, type, fallbackSelector) => {
+  if (seen.has(element)) return;
+  seen.add(element);
+  const text = element.textContent?.trim() || (element.value ?? '').trim() || '';
+  if (normalizedFilter && !text.toLowerCase().includes(normalizedFilter)) return;
+  const rect = element.getBoundingClientRect();
+  const style = window.getComputedStyle(element);
+  let selector = fallbackSelector;
+  if (element.id) selector = '#' + element.id;
+  else if (element.className) selector = fallbackSelector + '.' + element.className.split(' ')[0];
+  results.push({
+    selector,
+    text,
+    type,
+    visible:
+      style.display !== 'none' &&
+      style.visibility !== 'hidden' &&
+      style.opacity !== '0' &&
+      rect.width > 0 &&
+      rect.height > 0,
+    boundingBox: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
+  });
+};
+for (const root of roots) {
+  root
+    .querySelectorAll('button, input[type="button"], input[type="submit"], input[type="reset"]')
+    .forEach((button) => appendClickable(button, 'button', button.tagName.toLowerCase()));
+  root.querySelectorAll('a[href]').forEach((link) => appendClickable(link, 'link', 'a'));
+}
+return { elements: results, diagnostics: { readyState: document.readyState, shadowRootCount } };
+`.trim();
+}
+function querySelectorEvaluation(selector) {
+	const element = document.querySelector(selector);
+	if (!element) return { found: false };
+	const attributes = {};
+	for (const attr of Array.from(element.attributes)) attributes[attr.name] = attr.value;
+	const rect = element.getBoundingClientRect();
+	const style = window.getComputedStyle(element);
+	return {
+		found: true,
+		nodeName: element.nodeName,
+		attributes,
+		textContent: element.textContent?.trim() || "",
+		boundingBox: {
+			x: rect.x,
+			y: rect.y,
+			width: rect.width,
+			height: rect.height
+		},
+		visible: style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0"
+	};
+}
+function getStructureEvaluation(depth, withText) {
+	const buildTree = (node, currentDepth) => {
+		if (currentDepth > depth) return null;
+		const result = {
+			tag: node.tagName,
+			id: node.id || void 0,
+			class: node.className || void 0
+		};
+		if (withText && node.childNodes.length === 1 && node.childNodes[0]?.nodeType === 3) result.text = node.textContent?.trim();
+		const children = Array.from(node.children).map((child) => buildTree(child, currentDepth + 1)).filter((child) => child !== null);
+		if (children.length > 0) result.children = children;
+		return result;
+	};
+	return buildTree(document.body, 0);
+}
+function getComputedStyleEvaluation(selector) {
+	const element = document.querySelector(selector);
+	if (!element) return null;
+	const computed = window.getComputedStyle(element);
+	const result = {};
+	for (const prop of [
+		"display",
+		"visibility",
+		"opacity",
+		"position",
+		"zIndex",
+		"width",
+		"height",
+		"top",
+		"left",
+		"right",
+		"bottom",
+		"color",
+		"backgroundColor",
+		"fontSize",
+		"fontFamily",
+		"border",
+		"padding",
+		"margin",
+		"overflow"
+	]) result[prop] = computed.getPropertyValue(prop);
+	return result;
+}
+function observeDOMChangesEvaluation(opts) {
+	const targetNode = opts.selector ? document.querySelector(opts.selector) : document.body;
+	if (!targetNode) {
+		console.error("Target node not found for MutationObserver");
+		return;
+	}
+	const observer = new MutationObserver((mutations) => {
+		mutations.forEach((mutation) => {
+			console.warn("[DOM Change]", {
+				type: mutation.type,
+				target: mutation.target,
+				addedNodes: mutation.addedNodes.length,
+				removedNodes: mutation.removedNodes.length,
+				attributeName: mutation.attributeName
+			});
+		});
+	});
+	observer.observe(targetNode, {
+		childList: opts.childList !== false,
+		attributes: opts.attributes !== false,
+		characterData: opts.characterData !== false,
+		subtree: opts.subtree !== false
+	});
+	window.__domObserver = observer;
+}
+function stopObservingDOMEvaluation() {
+	const typedWindow = window;
+	if (typedWindow.__domObserver) {
+		typedWindow.__domObserver.disconnect();
+		delete typedWindow.__domObserver;
+	}
+}
+function findByTextEvaluation(searchText, tagName) {
+	const xpath = tagName ? `//${tagName}[contains(text(), "${searchText}")]` : `//*[contains(text(), "${searchText}")]`;
+	const result = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+	const matchedElements = [];
+	for (let i = 0; i < Math.min(result.snapshotLength, 100); i++) {
+		const element = result.snapshotItem(i);
+		if (!element) continue;
+		const rect = element.getBoundingClientRect();
+		const style = window.getComputedStyle(element);
+		let selector = element.tagName.toLowerCase();
+		if (element.id) selector = `#${element.id}`;
+		else if (element.className) {
+			const classes = element.className.split(" ").filter(Boolean);
+			if (classes.length > 0) selector = `${element.tagName.toLowerCase()}.${classes[0]}`;
+		}
+		matchedElements.push({
+			found: true,
+			nodeName: element.tagName,
+			textContent: element.textContent?.trim(),
+			selector,
+			boundingBox: {
+				x: rect.x,
+				y: rect.y,
+				width: rect.width,
+				height: rect.height
+			},
+			visible: style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0"
+		});
+	}
+	return matchedElements;
+}
+function getXPathEvaluation(selector) {
+	const element = document.querySelector(selector);
+	if (!element) return null;
+	const parts = [];
+	let current = element;
+	while (current && current !== document.body && current !== document.documentElement) {
+		if (current.id) {
+			parts.unshift(`//*[@id="${current.id}"]`);
+			return parts.join("");
+		}
+		let ix = 0;
+		const siblings = current.parentElement?.children;
+		if (siblings) for (let i = 0; i < siblings.length; i++) {
+			const sibling = siblings[i];
+			if (!sibling) continue;
+			if (sibling === current) break;
+			if (sibling.tagName === current.tagName) ix += 1;
+		}
+		parts.unshift(`/${current.tagName.toLowerCase()}[${ix + 1}]`);
+		current = current.parentElement;
+	}
+	return "/html/body" + parts.join("");
+}
+function isInViewportEvaluation(selector) {
+	const element = document.querySelector(selector);
+	if (!element) return false;
+	const rect = element.getBoundingClientRect();
+	return rect.top >= 0 && rect.left >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && rect.right <= (window.innerWidth || document.documentElement.clientWidth);
+}
+//#endregion
+//#region src/modules/collector/DOMInspector.ts
+var DOMInspector = class {
+	cdpSession = null;
+	constructor(collector) {
+		this.collector = collector;
+	}
+	async waitForReadyState(page, timeoutMs = 3e3) {
+		const deadline = Date.now() + timeoutMs;
+		let waitedForReadyState = false;
+		let readyState = "unknown";
+		while (Date.now() <= deadline) {
+			readyState = await page.evaluate(() => document.readyState).catch(() => "unknown");
+			if (readyState === "complete") break;
+			waitedForReadyState = true;
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+		return {
+			readyState,
+			waitedForReadyState,
+			frameCount: typeof page.frames === "function" ? page.frames().length : 1
+		};
+	}
+	async querySelector(selector, _getAttributes = true) {
+		try {
+			const elementInfo = await (await this.collector.getActivePage()).evaluate(querySelectorEvaluation, selector);
+			logger.info(`querySelector: ${selector} - ${elementInfo.found ? "found" : "not found"}`);
+			return elementInfo;
+		} catch (error) {
+			logger.error(`querySelector failed for ${selector}:`, error);
+			return { found: false };
+		}
+	}
+	async querySelectorAll(selector, limit = DOM_QUERY_DEFAULT_LIMIT) {
+		try {
+			const page = await this.collector.getActivePage();
+			const readyStateStatus = await this.waitForReadyState(page);
+			const runQuery = async () => page.evaluate(new Function(buildQueryAllEvaluation(selector, limit)));
+			let result = await runQuery();
+			let retried = false;
+			if (result.elements.length === 0 && result.diagnostics.readyState === "complete") {
+				retried = true;
+				await new Promise((resolve) => setTimeout(resolve, 500));
+				result = await runQuery();
+			}
+			const diagnostics = {
+				readyState: result.diagnostics.readyState ?? readyStateStatus.readyState,
+				frameCount: readyStateStatus.frameCount,
+				shadowRootCount: result.diagnostics.shadowRootCount ?? 0,
+				retried,
+				waitedForReadyState: readyStateStatus.waitedForReadyState
+			};
+			logger.info(`querySelectorAll: ${selector} - found ${result.elements.length} elements (limit: ${limit}, readyState: ${diagnostics.readyState}, shadowRoots: ${diagnostics.shadowRootCount}, retried: ${retried})`);
+			return {
+				elements: result.elements,
+				diagnostics
+			};
+		} catch (error) {
+			logger.error(`querySelectorAll failed for ${selector}:`, error);
+			return {
+				elements: [],
+				diagnostics: {
+					readyState: "error",
+					frameCount: 0,
+					shadowRootCount: 0,
+					retried: false,
+					waitedForReadyState: false
+				}
+			};
+		}
+	}
+	async getStructure(maxDepth = 3, includeText = true) {
+		try {
+			const structure = await (await this.collector.getActivePage()).evaluate(getStructureEvaluation, maxDepth, includeText);
+			logger.info("DOM structure retrieved");
+			return structure;
+		} catch (error) {
+			logger.error("getStructure failed:", error);
+			return null;
+		}
+	}
+	async findClickable(filterText) {
+		try {
+			const page = await this.collector.getActivePage();
+			const readyStateStatus = await this.waitForReadyState(page);
+			const runQuery = async () => page.evaluate(new Function(buildFindClickableEvaluation(filterText)));
+			let result = await runQuery();
+			let retried = false;
+			if (result.elements.length === 0 && result.diagnostics.readyState === "complete") {
+				retried = true;
+				await new Promise((resolve) => setTimeout(resolve, 500));
+				result = await runQuery();
+			}
+			const diagnostics = {
+				readyState: result.diagnostics.readyState ?? readyStateStatus.readyState,
+				frameCount: readyStateStatus.frameCount,
+				shadowRootCount: result.diagnostics.shadowRootCount ?? 0,
+				retried,
+				waitedForReadyState: readyStateStatus.waitedForReadyState
+			};
+			logger.info(`findClickable: found ${result.elements.length} elements${filterText ? ` (filtered by: ${filterText})` : ""} (readyState: ${diagnostics.readyState}, shadowRoots: ${diagnostics.shadowRootCount}, retried: ${retried})`);
+			return {
+				elements: result.elements,
+				diagnostics
+			};
+		} catch (error) {
+			logger.error("findClickable failed:", error);
+			return {
+				elements: [],
+				diagnostics: {
+					readyState: "error",
+					frameCount: 0,
+					shadowRootCount: 0,
+					retried: false,
+					waitedForReadyState: false
+				}
+			};
+		}
+	}
+	async getComputedStyle(selector) {
+		try {
+			const styles = await (await this.collector.getActivePage()).evaluate(getComputedStyleEvaluation, selector);
+			logger.info(`getComputedStyle: ${selector} - ${styles ? "found" : "not found"}`);
+			return styles;
+		} catch (error) {
+			logger.error(`getComputedStyle failed for ${selector}:`, error);
+			return null;
+		}
+	}
+	async waitForElement(selector, timeout = DOM_WAIT_ELEMENT_TIMEOUT_MS) {
+		try {
+			await (await this.collector.getActivePage()).waitForSelector(selector, { timeout });
+			return await this.querySelector(selector);
+		} catch (error) {
+			logger.error(`waitForElement timeout for ${selector}:`, error);
+			return null;
+		}
+	}
+	async observeDOMChanges(options = {}) {
+		await (await this.collector.getActivePage()).evaluate(observeDOMChangesEvaluation, options);
+		logger.info("DOM change observer started");
+	}
+	async stopObservingDOM() {
+		await (await this.collector.getActivePage()).evaluate(stopObservingDOMEvaluation);
+		logger.info("DOM change observer stopped");
+	}
+	async findByText(text, tag) {
+		try {
+			const elements = await (await this.collector.getActivePage()).evaluate(findByTextEvaluation, text, tag);
+			logger.info(`findByText: "${text}" - found ${elements.length} elements`);
+			return elements;
+		} catch (error) {
+			logger.error(`findByText failed for "${text}":`, error);
+			return [];
+		}
+	}
+	async getXPath(selector) {
+		try {
+			const xpath = await (await this.collector.getActivePage()).evaluate(getXPathEvaluation, selector);
+			logger.info(`getXPath: ${selector} -> ${xpath}`);
+			return xpath;
+		} catch (error) {
+			logger.error(`getXPath failed for ${selector}:`, error);
+			return null;
+		}
+	}
+	async isInViewport(selector) {
+		try {
+			const inViewport = await (await this.collector.getActivePage()).evaluate(isInViewportEvaluation, selector);
+			logger.info(`isInViewport: ${selector} - ${inViewport}`);
+			return inViewport;
+		} catch (error) {
+			logger.error(`isInViewport failed for ${selector}:`, error);
+			return false;
+		}
+	}
+	async close() {
+		if (this.cdpSession) {
+			await this.cdpSession.detach();
+			this.cdpSession = null;
+			logger.info("DOM Inspector CDP session closed");
+		}
+	}
+};
+//#endregion
+//#region src/modules/debugger/ScriptManager.impl.extract-function-tree.ts
+const getErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+const asRecord = (value) => value !== null && typeof value === "object" ? value : null;
+const asCallable = (value) => typeof value === "function" ? value : null;
+const resolveCallableExport = (moduleValue, namedExport) => {
+	const moduleRecord = asRecord(moduleValue);
+	const defaultExport = moduleRecord?.default;
+	return asCallable(asRecord(defaultExport)?.default) ?? asCallable(defaultExport) ?? asCallable(moduleRecord?.[namedExport]) ?? asCallable(moduleValue);
+};
+async function extractFunctionTreeCore(ctx, scriptId, functionName, options = {}) {
+	const { maxDepth = 3, maxSize = 500, includeComments = true } = options;
+	const script = await ctx.getScriptSource(scriptId);
+	if (!script?.source) throw new Error(`Script not found: ${scriptId}`);
+	let parser;
+	let traverse;
+	let generate;
+	let t;
+	try {
+		parser = await import("@babel/parser");
+		const traverseCandidate = resolveCallableExport(await import("@babel/traverse"), "traverse");
+		if (typeof traverseCandidate !== "function") throw new Error("Invalid @babel/traverse export shape");
+		traverse = traverseCandidate;
+		const generateCandidate = resolveCallableExport(await import("@babel/generator"), "generate");
+		if (typeof generateCandidate !== "function") throw new Error("Invalid @babel/generator export shape");
+		generate = generateCandidate;
+		t = await import("@babel/types");
+	} catch (error) {
+		throw new Error(`Failed to load Babel dependencies. Please install: npm install @babel/parser @babel/traverse @babel/generator @babel/types\nError: ${getErrorMessage(error)}`, { cause: error });
+	}
+	let ast;
+	try {
+		ast = parser.parse(script.source, {
+			sourceType: "unambiguous",
+			plugins: ["jsx", "typescript"]
+		});
+	} catch (error) {
+		throw new Error(`Failed to parse script ${scriptId}: ${getErrorMessage(error)}`, { cause: error });
+	}
+	const allFunctions = /* @__PURE__ */ new Map();
+	const callGraph = {};
+	const extractDependencies = (path) => {
+		const deps = /* @__PURE__ */ new Set();
+		path.traverse({ CallExpression(callPath) {
+			if (t.isIdentifier(callPath.node.callee)) deps.add(callPath.node.callee.name);
+		} });
+		return Array.from(deps);
+	};
+	traverse(ast, {
+		FunctionDeclaration(path) {
+			const name = path.node.id?.name;
+			if (!name) return;
+			const funcCode = generate(path.node, { comments: includeComments }).code;
+			const deps = extractDependencies(path);
+			allFunctions.set(name, {
+				name,
+				code: funcCode,
+				startLine: path.node.loc?.start.line || 0,
+				endLine: path.node.loc?.end.line || 0,
+				dependencies: deps,
+				size: funcCode.length
+			});
+			callGraph[name] = deps;
+		},
+		VariableDeclarator(path) {
+			if (t.isIdentifier(path.node.id) && (t.isFunctionExpression(path.node.init) || t.isArrowFunctionExpression(path.node.init))) {
+				const name = path.node.id.name;
+				const funcCode = generate(path.node, { comments: includeComments }).code;
+				const deps = extractDependencies(path);
+				allFunctions.set(name, {
+					name,
+					code: funcCode,
+					startLine: path.node.loc?.start.line || 0,
+					endLine: path.node.loc?.end.line || 0,
+					dependencies: deps,
+					size: funcCode.length
+				});
+				callGraph[name] = deps;
+			}
+		}
+	});
+	const extracted = /* @__PURE__ */ new Set();
+	const toExtract = [functionName];
+	let currentDepth = 0;
+	while (toExtract.length > 0 && currentDepth < maxDepth) {
+		const current = toExtract.shift();
+		if (extracted.has(current)) continue;
+		const func = allFunctions.get(current);
+		if (!func) continue;
+		extracted.add(current);
+		for (const dep of func.dependencies) if (!extracted.has(dep) && allFunctions.has(dep)) toExtract.push(dep);
+		currentDepth++;
+	}
+	const functions = Array.from(extracted).map((name) => allFunctions.get(name)).filter(Boolean);
+	const code = functions.map((f) => f.code).join("\n\n");
+	const totalSize = code.length;
+	if (totalSize > maxSize * 1024) logger.warn(`Extracted code size (${(totalSize / 1024).toFixed(2)}KB) exceeds limit (${maxSize}KB)`);
+	logger.info(`extractFunctionTree: ${functionName} - extracted ${functions.length} functions (${(totalSize / 1024).toFixed(2)}KB)`);
+	return {
+		mainFunction: functionName,
+		code,
+		functions,
+		callGraph,
+		totalSize,
+		extractedCount: functions.length
+	};
+}
+//#endregion
+//#region src/modules/debugger/ScriptManager.impl.class.ts
+var ScriptManager = class ScriptManager {
+	static SOURCE_LOAD_BATCH_SIZE = 8;
+	static SEARCH_LINE_YIELD_INTERVAL = 250;
+	static SEARCH_SCRIPT_YIELD_INTERVAL = 10;
+	cdpSession = null;
+	scripts = /* @__PURE__ */ new Map();
+	scriptsByUrl = /* @__PURE__ */ new Map();
+	initialized = false;
+	initPromise;
+	keywordIndex = /* @__PURE__ */ new Map();
+	scriptChunks = /* @__PURE__ */ new Map();
+	CHUNK_SIZE = 100 * 1024;
+	constructor(collector) {
+		this.collector = collector;
+	}
+	async init() {
+		if (this.initialized) return;
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this.doInit();
+		try {
+			return await this.initPromise;
+		} finally {
+			this.initPromise = void 0;
+		}
+	}
+	async doInit() {
+		const page = await this.collector.getActivePage();
+		this.cdpSession = await page.createCDPSession();
+		await this.cdpSession.send("Debugger.enable");
+		this.cdpSession.on("Debugger.scriptParsed", (params) => {
+			const scriptInfo = {
+				scriptId: params.scriptId,
+				url: params.url,
+				startLine: params.startLine,
+				startColumn: params.startColumn,
+				endLine: params.endLine,
+				endColumn: params.endColumn,
+				sourceLength: params.length
+			};
+			this.scripts.set(params.scriptId, scriptInfo);
+			if (params.url) {
+				if (!this.scriptsByUrl.has(params.url)) this.scriptsByUrl.set(params.url, []);
+				this.scriptsByUrl.get(params.url).push(scriptInfo);
+			}
+			logger.debug(`Script parsed: ${params.url || "inline"} (${params.scriptId})`);
+		});
+		this.initialized = true;
+		logger.info("ScriptManager initialized");
+	}
+	async loadScriptSourceInternal(script) {
+		if (script.source) return true;
+		try {
+			const { scriptSource } = await this.cdpSession.send("Debugger.getScriptSource", { scriptId: script.scriptId });
+			script.source = scriptSource;
+			script.sourceLength = scriptSource.length;
+			this.buildKeywordIndex(script.scriptId, script.url, scriptSource);
+			this.chunkScript(script.scriptId, scriptSource);
+			return true;
+		} catch (error) {
+			logger.warn(`Failed to get source for script ${script.scriptId}:`, error);
+			return false;
+		}
+	}
+	async enable() {
+		return this.init();
+	}
+	async getAllScripts(includeSource = false, maxScripts = 1e3) {
+		if (!this.cdpSession) await this.init();
+		const scripts = Array.from(this.scripts.values());
+		if (scripts.length > maxScripts) logger.warn(`Found ${scripts.length} scripts, limiting to ${maxScripts}. Increase maxScripts parameter if needed.`);
+		const limitedScripts = scripts.slice(0, maxScripts);
+		if (includeSource) {
+			logger.warn(`Loading source code for ${limitedScripts.length} scripts. This may use significant memory.`);
+			let loadedCount = 0;
+			let failedCount = 0;
+			const missingScripts = limitedScripts.filter((script) => !script.source);
+			for (let batchStart = 0; batchStart < missingScripts.length; batchStart += ScriptManager.SOURCE_LOAD_BATCH_SIZE) {
+				const batch = missingScripts.slice(batchStart, batchStart + ScriptManager.SOURCE_LOAD_BATCH_SIZE);
+				const settled = await Promise.allSettled(batch.map(async (script) => {
+					if (await this.loadScriptSourceInternal(script)) {
+						loadedCount++;
+						if (loadedCount % 10 === 0) logger.debug(`Loaded ${loadedCount}/${limitedScripts.length} scripts...`);
+					} else failedCount++;
+				}));
+				for (const result of settled) if (result.status === "rejected") failedCount++;
+				await setImmediate();
+			}
+			logger.info(`getAllScripts: ${limitedScripts.length} scripts (loaded: ${loadedCount}, failed: ${failedCount})`);
+		} else logger.info(`getAllScripts: ${limitedScripts.length} scripts (source not included)`);
+		return limitedScripts;
+	}
+	async getScriptSource(scriptId, url) {
+		if (!scriptId && !url) throw new Error("Either scriptId or url parameter must be provided");
+		if (!this.cdpSession) await this.init();
+		let targetScript;
+		if (scriptId) targetScript = this.scripts.get(scriptId);
+		else if (url) {
+			const urlPattern = url.replace(/\*/g, ".*");
+			const regex = new RegExp(urlPattern);
+			for (const [scriptUrl, scripts] of this.scriptsByUrl.entries()) if (regex.test(scriptUrl)) {
+				targetScript = scripts[0];
+				break;
+			}
+		}
+		if (!targetScript) {
+			logger.warn(`Script not found: ${scriptId || url}`);
+			return null;
+		}
+		if (!targetScript.source) {
+			if (!await this.loadScriptSourceInternal(targetScript)) {
+				logger.error(`Failed to get script source for ${targetScript.scriptId}`);
+				return null;
+			}
+		}
+		logger.info(`getScriptSource: ${targetScript.url || "inline"} (${targetScript.sourceLength} bytes)`);
+		return targetScript;
+	}
+	async findScriptsByUrl(urlPattern) {
+		if (!this.cdpSession) await this.init();
+		const pattern = urlPattern.replace(/\*/g, ".*");
+		const regex = new RegExp(pattern);
+		const results = [];
+		for (const [url, scripts] of this.scriptsByUrl.entries()) if (regex.test(url)) results.push(...scripts);
+		logger.info(`findScriptsByUrl: ${urlPattern} - found ${results.length} scripts`);
+		return results;
+	}
+	clearCache() {
+		this.clear();
+	}
+	async searchInScripts(keyword, options = {}) {
+		if (!this.cdpSession) await this.init();
+		const { isRegex = false, caseSensitive = false, contextLines = 3, maxMatches = 100 } = options;
+		const searchRegex = isRegex ? new RegExp(keyword, caseSensitive ? "g" : "gi") : new RegExp(keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), caseSensitive ? "g" : "gi");
+		const matches = [];
+		const scripts = await this.getAllScripts(true, 500);
+		for (const [scriptIndex, script] of scripts.entries()) {
+			if (!script.source) continue;
+			if (matches.length >= maxMatches) break;
+			const lines = script.source.split("\n");
+			for (let i = 0; i < lines.length; i++) {
+				const line = lines[i];
+				if (!line) continue;
+				const lineMatches = Array.from(line.matchAll(searchRegex));
+				for (const match of lineMatches) {
+					if (matches.length >= maxMatches) break;
+					const startLine = Math.max(0, i - contextLines);
+					const endLine = Math.min(lines.length - 1, i + contextLines);
+					let context = lines.slice(startLine, endLine + 1).join("\n");
+					if (context.length > 2e3) {
+						const matchIndex = match.index || 0;
+						const snippetStart = Math.max(0, matchIndex - 100);
+						const snippetEnd = Math.min(line.length, matchIndex + 100);
+						context = (snippetStart > 0 ? "..." : "") + line.substring(snippetStart, snippetEnd) + (snippetEnd < line.length ? "..." : "");
+					}
+					matches.push({
+						scriptId: script.scriptId,
+						url: script.url || "inline",
+						line: i + 1,
+						column: match.index || 0,
+						matchText: match[0],
+						context
+					});
+				}
+				if ((i + 1) % ScriptManager.SEARCH_LINE_YIELD_INTERVAL === 0) await setImmediate();
+			}
+			if ((scriptIndex + 1) % ScriptManager.SEARCH_SCRIPT_YIELD_INTERVAL === 0) await setImmediate();
+		}
+		logger.info(`searchInScripts: "${keyword}" - found ${matches.length} matches`);
+		return {
+			keyword,
+			totalMatches: matches.length,
+			matches
+		};
+	}
+	async extractFunctionTree(scriptId, functionName, options = {}) {
+		return extractFunctionTreeCore(this, scriptId, functionName, options);
+	}
+	clear() {
+		this.scripts.clear();
+		this.scriptsByUrl.clear();
+		this.keywordIndex.clear();
+		this.scriptChunks.clear();
+		logger.info(" ScriptManager cleared - ready for new website");
+	}
+	async close() {
+		this.initPromise = void 0;
+		this.clear();
+		if (this.cdpSession) {
+			try {
+				await this.cdpSession.send("Debugger.disable");
+				await this.cdpSession.detach();
+				logger.info("CDP session closed");
+			} catch (error) {
+				logger.warn("Failed to close CDP session:", error);
+			}
+			this.cdpSession = null;
+		}
+		this.initialized = false;
+		logger.info(" ScriptManager closed");
+	}
+	getStats() {
+		let totalChunks = 0;
+		for (const chunks of this.scriptChunks.values()) totalChunks += chunks.length;
+		return {
+			totalScripts: this.scripts.size,
+			totalUrls: this.scriptsByUrl.size,
+			indexedKeywords: this.keywordIndex.size,
+			totalChunks
+		};
+	}
+	buildKeywordIndex(scriptId, url, content) {
+		const lines = content.split("\n");
+		const keywordRegex = /\b[a-zA-Z_$][a-zA-Z0-9_$]{2,}\b/g;
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			if (!line) continue;
+			const matches = Array.from(line.matchAll(keywordRegex));
+			for (const match of matches) {
+				const keyword = match[0].toLowerCase();
+				const startLine = Math.max(0, i - 3);
+				const endLine = Math.min(lines.length - 1, i + 3);
+				let context = lines.slice(startLine, endLine + 1).join("\n");
+				if (context.length > 1e3) {
+					const matchIndex = match.index || 0;
+					const snippetStart = Math.max(0, matchIndex - 50);
+					const snippetEnd = Math.min(line.length, matchIndex + 50);
+					context = (snippetStart > 0 ? "..." : "") + line.substring(snippetStart, snippetEnd) + (snippetEnd < line.length ? "..." : "");
+				}
+				const entry = {
+					scriptId,
+					url,
+					line: i + 1,
+					column: match.index || 0,
+					context
+				};
+				if (!this.keywordIndex.has(keyword)) this.keywordIndex.set(keyword, []);
+				this.keywordIndex.get(keyword).push(entry);
+			}
+		}
+		logger.debug(` Indexed ${this.keywordIndex.size} keywords for ${url}`);
+	}
+	chunkScript(scriptId, content) {
+		const chunks = [];
+		let offset = 0;
+		let chunkIndex = 0;
+		while (offset < content.length) {
+			const chunk = content.substring(offset, offset + this.CHUNK_SIZE);
+			chunks.push({
+				scriptId,
+				chunkIndex,
+				content: chunk,
+				size: chunk.length
+			});
+			offset += this.CHUNK_SIZE;
+			chunkIndex++;
+		}
+		this.scriptChunks.set(scriptId, chunks);
+		logger.debug(` Chunked script ${scriptId} into ${chunks.length} chunks`);
+	}
+	getScriptChunk(scriptId, chunkIndex) {
+		const chunks = this.scriptChunks.get(scriptId);
+		if (!chunks || chunkIndex >= chunks.length) return null;
+		const chunk = chunks[chunkIndex];
+		return chunk ? chunk.content : null;
+	}
+	async searchInScriptsEnhanced(keyword, options = {}) {
+		const { isRegex = false, caseSensitive = false, maxMatches = 100 } = options;
+		const searchTerm = caseSensitive ? keyword : keyword.toLowerCase();
+		const matches = [];
+		if (!isRegex) {
+			for (const [indexedKeyword, entries] of this.keywordIndex.entries()) {
+				if (indexedKeyword.includes(searchTerm)) for (const entry of entries) {
+					matches.push({
+						scriptId: entry.scriptId,
+						url: entry.url,
+						line: entry.line,
+						column: entry.column,
+						matchText: indexedKeyword,
+						context: entry.context
+					});
+					if (matches.length >= maxMatches) break;
+				}
+				if (matches.length >= maxMatches) break;
+			}
+			logger.info(` Enhanced search (indexed) found ${matches.length} matches for "${keyword}"`);
+			return {
+				keyword,
+				totalMatches: matches.length,
+				matches,
+				searchMethod: "indexed"
+			};
+		} else return {
+			...await this.searchInScripts(keyword, options),
+			searchMethod: "regex"
+		};
+	}
+};
+//#endregion
+export { connectPlaywrightCdpFallback as i, DOMInspector as n, CodeCollector as r, ScriptManager as t };