@jshookmcp/jshook 0.2.8 → 0.2.9

package/dist/manifest-Bcf-TJzH.mjs

@@ -0,0 +1,848 @@
+import { t as VersionDetector } from "./VersionDetector-CwVLVdDM.mjs";
+import { a as argString, r as argNumber } from "./parse-args-BlRjqlkL.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as tool } from "./tool-builder-DCbIC5Eo.mjs";
+//#region src/modules/v8-inspector/V8InspectorClient.ts
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null;
+}
+function isCDPPageLike$3(value) {
+	return isRecord$3(value) && typeof value["createCDPSession"] === "function";
+}
+function isCDPSessionLike(value) {
+	return isRecord$3(value) && typeof value["send"] === "function" && typeof value["detach"] === "function";
+}
+/**
+* CDP wrapper for V8 HeapProfiler operations.
+*
+* Provides heap snapshot capture, object inspection, and usage stats
+* via the Chrome DevTools Protocol HeapProfiler domain.
+*/
+var V8InspectorClient = class {
+	session = null;
+	constructor(getPage) {
+		this.getPage = getPage;
+	}
+	/**
+	* Enable the HeapProfiler domain via CDP.
+	* Must be called before any heap profiling operations.
+	*/
+	async enableHeapProfiler() {
+		const session = await this.createSession();
+		if (!session) throw new Error("V8InspectorClient: cannot create CDP session");
+		await session.send("HeapProfiler.enable");
+		this.session = session;
+	}
+	/**
+	* Take a heap snapshot and collect all chunks via the HeapProfiler.addHeapSnapshotChunk event.
+	*
+	* @param onChunk - Callback invoked for each snapshot chunk received.
+	* @returns Total size of the snapshot in bytes.
+	*/
+	async takeHeapSnapshot(onChunk) {
+		if (!this.session) await this.enableHeapProfiler();
+		const session = this.session;
+		if (!session) throw new Error("V8InspectorClient: session not available for heap snapshot");
+		return new Promise((resolve, reject) => {
+			const chunks = [];
+			let totalSize = 0;
+			const chunkHandler = (data) => {
+				const chunk = data?.chunk;
+				if (typeof chunk === "string") {
+					chunks.push(chunk);
+					totalSize += Buffer.byteLength(chunk, "utf8");
+					onChunk?.(chunk);
+				}
+			};
+			session.on("HeapProfiler.addHeapSnapshotChunk", chunkHandler);
+			session.send("HeapProfiler.takeHeapSnapshot", { reportProgress: false }).then(() => {
+				session.off("HeapProfiler.addHeapSnapshotChunk", chunkHandler);
+				resolve(totalSize);
+			}).catch((error) => {
+				session.off("HeapProfiler.addHeapSnapshotChunk", chunkHandler);
+				reject(error);
+			});
+		});
+	}
+	/**
+	* Retrieve a heap object by its object ID.
+	*
+	* @param objectId - Heap snapshot object identifier (e.g. "1:1234").
+	* @returns The object's properties and metadata.
+	*/
+	async getObjectByObjectId(_objectId) {
+		if (!this.session) await this.enableHeapProfiler();
+		const session = this.session;
+		if (!session) return null;
+		try {
+			return await session.send("HeapProfiler.getObjectByObjectId", { objectId: _objectId });
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Get current V8 heap usage statistics.
+	*
+	* @returns Object with jsHeapSizeUsed, jsHeapSizeTotal, jsHeapSizeLimit.
+	*/
+	async getHeapUsage() {
+		if (!this.session) await this.enableHeapProfiler();
+		const session = this.session;
+		if (!session) return {
+			jsHeapSizeUsed: 0,
+			jsHeapSizeTotal: 0,
+			jsHeapSizeLimit: 0
+		};
+		try {
+			const response = await session.send("HeapProfiler.getHeapUsage");
+			const jsHeapSizeUsed = response["jsHeapSizeUsed"];
+			const jsHeapSizeTotal = response["jsHeapSizeTotal"];
+			const jsHeapSizeLimit = response["jsHeapSizeLimit"];
+			return {
+				jsHeapSizeUsed: typeof jsHeapSizeUsed === "number" ? jsHeapSizeUsed : 0,
+				jsHeapSizeTotal: typeof jsHeapSizeTotal === "number" ? jsHeapSizeTotal : 0,
+				jsHeapSizeLimit: typeof jsHeapSizeLimit === "number" ? jsHeapSizeLimit : 0
+			};
+		} catch {
+			try {
+				const result = (await session.send("Runtime.evaluate", {
+					expression: `
+            (() => {
+              const m = performance.memory;
+              return m ? JSON.stringify({
+                jsHeapSizeUsed: m.usedJSHeapSize,
+                jsHeapSizeTotal: m.totalJSHeapSize,
+                jsHeapSizeLimit: m.jsHeapSizeLimit
+              }) : null;
+            })()
+          `,
+					returnByValue: true
+				}))["result"];
+				if (typeof result === "string" && result !== "null") return JSON.parse(result);
+			} catch {}
+			return {
+				jsHeapSizeUsed: 0,
+				jsHeapSizeTotal: 0,
+				jsHeapSizeLimit: 0
+			};
+		}
+	}
+	/**
+	* Detach the underlying CDP session and release resources.
+	*/
+	async dispose() {
+		if (this.session) {
+			await this.session.detach().catch(() => void 0);
+			this.session = null;
+		}
+	}
+	async createSession() {
+		if (this.session) return this.session;
+		if (!this.getPage) return null;
+		try {
+			const page = await this.getPage();
+			if (!isCDPPageLike$3(page)) return null;
+			const session = await page.createCDPSession();
+			if (!isCDPSessionLike(session)) return null;
+			return session;
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/v8-inspector/definitions.ts
+const v8InspectorTools = [
+	tool("v8_heap_snapshot_capture", (t) => t.desc("Capture a V8 heap snapshot from the active browser target").query()),
+	tool("v8_heap_snapshot_analyze", (t) => t.desc("Analyze a previously captured V8 heap snapshot").string("snapshotId", "Heap snapshot identifier").required("snapshotId").query()),
+	tool("v8_heap_diff", (t) => t.desc("Diff two captured V8 heap snapshots").string("beforeSnapshotId", "Baseline snapshot identifier").string("afterSnapshotId", "Updated snapshot identifier").required("beforeSnapshotId", "afterSnapshotId").query()),
+	tool("v8_object_inspect", (t) => t.desc("Inspect a V8 heap object by address").string("address", "Heap object address").required("address").query()),
+	tool("v8_heap_stats", (t) => t.desc("Return V8 heap snapshot statistics").query()),
+	tool("v8_bytecode_extract", (t) => t.desc("Extract V8 Ignition bytecode for a function").string("functionId", "CDP RemoteObjectId of the function").required("functionId").query()),
+	tool("v8_version_detect", (t) => t.desc("Detect V8 engine version and feature support").query()),
+	tool("v8_jit_inspect", (t) => t.desc("Inspect JIT-compiled code for a function").string("functionId", "CDP RemoteObjectId of the function").required("functionId").query())
+];
+//#endregion
+//#region src/server/domains/v8-inspector/handlers/heap-snapshot.ts
+const snapshotCache = /* @__PURE__ */ new Map();
+function getSnapshotCache() {
+	return snapshotCache;
+}
+function storeSnapshot(snapshot) {
+	snapshotCache.set(snapshot.id, snapshot);
+	return snapshot;
+}
+function getSnapshot(snapshotId) {
+	return snapshotCache.get(snapshotId);
+}
+function isRecord$2(v) {
+	return typeof v === "object" && v !== null;
+}
+function isCDPPageLike$2(v) {
+	return isRecord$2(v) && typeof v["createCDPSession"] === "function";
+}
+async function handleHeapSnapshotCapture(_args, options) {
+	const snapshotId = `snapshot_${Date.now().toString(36)}`;
+	const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const chunks = [];
+	if (options.client) try {
+		const stored = storeSnapshot({
+			id: snapshotId,
+			chunks,
+			capturedAt,
+			sizeBytes: await options.client.takeHeapSnapshot((chunk) => {
+				chunks.push(chunk);
+			})
+		});
+		options.setSnapshot(snapshotId);
+		return {
+			success: true,
+			snapshotId: stored.id,
+			capturedAt: stored.capturedAt,
+			sizeBytes: stored.sizeBytes,
+			chunks: [],
+			simulated: false
+		};
+	} catch {}
+	try {
+		const page = await options.getPage();
+		if (isCDPPageLike$2(page)) {
+			const session = await page.createCDPSession();
+			const sessionSend = (method, params) => session.send(method, params);
+			const sessionDetach = () => session.detach();
+			await sessionSend("HeapProfiler.enable");
+			const response = await sessionSend("Runtime.evaluate", {
+				expression: `
+          (() => {
+            const m = performance.memory;
+            return m ? JSON.stringify({
+              jsHeapSizeUsed: m.usedJSHeapSize,
+              jsHeapSizeTotal: m.totalJSHeapSize,
+              jsHeapSizeLimit: m.jsHeapSizeLimit
+            }) : null;
+          })()
+        `,
+				returnByValue: true
+			});
+			await sessionDetach().catch(() => void 0);
+			const result = isRecord$2(response) ? response["result"] : void 0;
+			let sizeBytes = 0;
+			if (typeof result === "string" && result !== "null") sizeBytes = JSON.parse(result).jsHeapSizeUsed ?? 0;
+			const stored = storeSnapshot({
+				id: snapshotId,
+				chunks: [`{"simulated":true,"sizeBytes":${sizeBytes}}`],
+				capturedAt,
+				sizeBytes
+			});
+			options.setSnapshot(snapshotId);
+			return {
+				success: true,
+				snapshotId: stored.id,
+				capturedAt: stored.capturedAt,
+				sizeBytes: stored.sizeBytes,
+				chunks: [],
+				simulated: true
+			};
+		}
+	} catch {}
+	const stored = storeSnapshot({
+		id: snapshotId,
+		chunks: ["{}"],
+		capturedAt,
+		sizeBytes: 0
+	});
+	options.setSnapshot(snapshotId);
+	return {
+		success: true,
+		snapshotId: stored.id,
+		capturedAt: stored.capturedAt,
+		sizeBytes: stored.sizeBytes,
+		chunks: [],
+		simulated: true
+	};
+}
+//#endregion
+//#region src/modules/v8-inspector/BytecodeExtractor.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+function isCDPPageLike$1(value) {
+	return isRecord$1(value) && typeof value["createCDPSession"] === "function";
+}
+function toNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function toStringValue(value) {
+	return typeof value === "string" ? value : null;
+}
+function toRecordArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter(isRecord$1);
+}
+function splitOperands(raw) {
+	return raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function inferOpcode(line) {
+	const trimmed = line.trim();
+	if (trimmed.startsWith("function ")) return {
+		opcode: "FunctionDeclaration",
+		operands: []
+	};
+	if (trimmed.startsWith("return ")) return {
+		opcode: "Return",
+		operands: [trimmed.slice(7)]
+	};
+	if (trimmed.includes("=>")) return {
+		opcode: "CreateClosure",
+		operands: []
+	};
+	if (trimmed.includes("(") && trimmed.includes(")")) {
+		const nameMatch = /^([A-Za-z_$][\w$]*)\(/u.exec(trimmed);
+		if (nameMatch?.[1]) return {
+			opcode: "Call",
+			operands: [nameMatch[1]]
+		};
+	}
+	if (trimmed.includes("=")) {
+		const parts = trimmed.split("=", 2);
+		const left = parts[0];
+		const right = parts[1];
+		if (left && right) return {
+			opcode: "Store",
+			operands: [left.trim(), right.trim()]
+		};
+	}
+	if (trimmed.startsWith("if ")) return {
+		opcode: "JumpIfTrue",
+		operands: [trimmed]
+	};
+	if (trimmed.startsWith("for ") || trimmed.startsWith("while ")) return {
+		opcode: "Loop",
+		operands: [trimmed]
+	};
+	if (trimmed.startsWith("{") || trimmed.startsWith("const ") || trimmed.startsWith("let ")) return {
+		opcode: "LoadLiteral",
+		operands: [trimmed]
+	};
+	return {
+		opcode: "Evaluate",
+		operands: [trimmed]
+	};
+}
+function buildPseudoBytecode(source) {
+	const instructions = ["; pseudo-bytecode synthesized from script source"];
+	let offset = 0;
+	for (const line of source.split(/\r?\n/u)) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0) continue;
+		const { opcode, operands } = inferOpcode(trimmed);
+		const operandText = operands.join(", ");
+		instructions.push(`${offset} ${opcode}${operandText.length > 0 ? ` ${operandText}` : ""}`);
+		offset += 1;
+	}
+	return instructions.join("\n");
+}
+function inferFunctionName(source, functionOffset) {
+	if (typeof functionOffset === "number" && functionOffset >= 0 && functionOffset < source.length) {
+		const start = Math.max(0, functionOffset - 120);
+		const end = Math.min(source.length, functionOffset + 120);
+		const nearby = source.slice(start, end);
+		const namedFunction = /function\s+([A-Za-z_$][\w$]*)/u.exec(nearby);
+		if (namedFunction?.[1]) return namedFunction[1];
+		const assignedFunction = /([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\(/u.exec(nearby);
+		if (assignedFunction?.[1]) return assignedFunction[1];
+	}
+	return /function\s+([A-Za-z_$][\w$]*)/u.exec(source)?.[1] ?? "anonymous";
+}
+function findObjectLiteralProperties(source) {
+	const matches = source.matchAll(/\{([^{}]+:[^{}]+)\}/gu);
+	const results = [];
+	let index = 0;
+	for (const match of matches) {
+		const body = match[1];
+		if (!body) continue;
+		const properties = body.split(",").map((entry) => entry.trim()).map((entry) => {
+			const [key] = entry.split(":", 1);
+			return key?.trim() ?? "";
+		}).filter((entry) => entry.length > 0).filter((entry, position, list) => list.indexOf(entry) === position);
+		if (properties.length === 0) continue;
+		results.push({
+			address: `hidden-class-${index}`,
+			properties,
+			transitionMap: properties.length > 1 ? properties.join(" -> ") : void 0
+		});
+		index += 1;
+	}
+	return results;
+}
+var BytecodeExtractor = class {
+	versionDetector;
+	constructor(getPage) {
+		this.getPage = getPage;
+		this.versionDetector = new VersionDetector(getPage);
+	}
+	async extractBytecode(scriptId, functionOffset) {
+		const scriptSource = await this.getScriptSource(scriptId);
+		if (!scriptSource) return null;
+		const functions = await this.getCoverageFunctions(scriptId);
+		const functionByOffset = typeof functionOffset === "number" ? functions.find((candidate) => functionOffset >= candidate.startOffset && functionOffset <= candidate.endOffset) : void 0;
+		const functionName = functionByOffset?.functionName && functionByOffset.functionName.length > 0 ? functionByOffset.functionName : inferFunctionName(scriptSource, functionOffset);
+		const sourceSlice = functionByOffset && functionByOffset.endOffset > functionByOffset.startOffset ? scriptSource.slice(functionByOffset.startOffset, functionByOffset.endOffset) : scriptSource;
+		await this.versionDetector.supportsNativesSyntax();
+		return {
+			functionName,
+			bytecode: buildPseudoBytecode(sourceSlice),
+			sourcePosition: typeof functionOffset === "number" ? functionOffset : functionByOffset ? functionByOffset.startOffset : void 0
+		};
+	}
+	disassembleBytecode(bytecode) {
+		const instructions = [];
+		for (const line of bytecode.split(/\r?\n/u)) {
+			const trimmed = line.trim();
+			if (trimmed.length === 0 || trimmed.startsWith(";")) continue;
+			const match = /^(\d+)\s*@\s*([A-Za-z_][\w.]*)\s*(.*)$/u.exec(trimmed) ?? /^(?:0x[0-9a-fA-F]+\s+@)?\s*(\d+)\s*[: ]\s*([A-Za-z_][\w.]*)\s*(.*)$/u.exec(trimmed) ?? /^(\d+)\s+([A-Za-z_][\w.]*)\s*(.*)$/u.exec(trimmed);
+			if (!match) continue;
+			const offset = Number(match[1]);
+			if (!Number.isFinite(offset)) continue;
+			instructions.push({
+				offset,
+				opcode: match[2] ?? "Unknown",
+				operands: splitOperands(match[3] ?? "")
+			});
+		}
+		return instructions;
+	}
+	async findHiddenClasses(scriptId) {
+		const scriptSource = await this.getScriptSource(scriptId);
+		if (!scriptSource) return [];
+		return findObjectLiteralProperties(scriptSource);
+	}
+	async getCoverageFunctions(scriptId) {
+		const session = await this.createSession();
+		if (!session) return [];
+		try {
+			await session.send("Profiler.enable");
+			await session.send("Profiler.startPreciseCoverage", {
+				callCount: true,
+				detailed: true
+			});
+			const response = await session.send("Profiler.takePreciseCoverage");
+			const targetScript = (isRecord$1(response) ? toRecordArray(response["result"]) : []).find((entry) => typeof entry["scriptId"] === "string" && entry["scriptId"] === scriptId);
+			if (!targetScript) return [];
+			const functions = toRecordArray(targetScript["functions"]);
+			const extracted = [];
+			for (const fn of functions) {
+				const primaryRange = toRecordArray(fn["ranges"])[0];
+				if (!primaryRange) continue;
+				const startOffset = toNumber(primaryRange["startOffset"]);
+				const endOffset = toNumber(primaryRange["endOffset"]);
+				if (startOffset === null || endOffset === null) continue;
+				extracted.push({
+					functionName: toStringValue(fn["functionName"]) ?? "anonymous",
+					startOffset,
+					endOffset
+				});
+			}
+			return extracted;
+		} catch {
+			return [];
+		} finally {
+			await session.send("Profiler.stopPreciseCoverage").catch(() => void 0);
+			await session.send("Profiler.disable").catch(() => void 0);
+			await session.detach().catch(() => void 0);
+		}
+	}
+	async getScriptSource(scriptId) {
+		const session = await this.createSession();
+		if (!session) return null;
+		try {
+			await session.send("Debugger.enable");
+			const response = await session.send("Debugger.getScriptSource", { scriptId });
+			if (!isRecord$1(response)) return null;
+			const scriptSource = response["scriptSource"];
+			return typeof scriptSource === "string" ? scriptSource : null;
+		} catch {
+			return null;
+		} finally {
+			await session.send("Debugger.disable").catch(() => void 0);
+			await session.detach().catch(() => void 0);
+		}
+	}
+	async createSession() {
+		if (!this.getPage) return null;
+		try {
+			const page = await this.getPage();
+			if (!isCDPPageLike$1(page)) return null;
+			return await page.createCDPSession();
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
+//#region src/modules/v8-inspector/JITInspector.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isCDPPageLike(value) {
+	return isRecord(value) && typeof value["createCDPSession"] === "function";
+}
+function readNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (isRecord(value) && typeof value["value"] === "number") {
+		const nested = value["value"];
+		return typeof nested === "number" && Number.isFinite(nested) ? nested : null;
+	}
+	return null;
+}
+function mapOptimizationTier(status) {
+	if (status === null) return {
+		optimized: false,
+		tier: "unknown"
+	};
+	if ((status & 128) !== 0) return {
+		optimized: true,
+		tier: "maglev"
+	};
+	if ((status & 64) !== 0) return {
+		optimized: true,
+		tier: "turbofan"
+	};
+	if ((status & 16) !== 0 || (status & 32) !== 0) return {
+		optimized: true,
+		tier: "optimized"
+	};
+	return {
+		optimized: false,
+		tier: "interpreted"
+	};
+}
+var JITInspector = class {
+	bytecodeExtractor;
+	versionDetector;
+	optimizedFunctionsCache = [];
+	constructor(getPage) {
+		this.getPage = getPage;
+		this.bytecodeExtractor = new BytecodeExtractor(getPage);
+		this.versionDetector = new VersionDetector(getPage);
+	}
+	async inspectJIT(scriptId) {
+		const hiddenClasses = await this.bytecodeExtractor.findHiddenClasses(scriptId);
+		const extraction = await this.bytecodeExtractor.extractBytecode(scriptId);
+		const functionNames = /* @__PURE__ */ new Set();
+		if (extraction) functionNames.add(extraction.functionName);
+		for (const hiddenClass of hiddenClasses) {
+			const candidate = hiddenClass.properties[0];
+			if (candidate) functionNames.add(candidate);
+		}
+		if (functionNames.size === 0) functionNames.add("anonymous");
+		const supportsNativesSyntax = await this.versionDetector.supportsNativesSyntax();
+		const results = [];
+		for (const functionName of functionNames) {
+			const { optimized, tier } = mapOptimizationTier(supportsNativesSyntax ? await this.getOptimizationStatus(functionName) : null);
+			results.push({
+				functionName,
+				optimized,
+				tier
+			});
+		}
+		this.optimizedFunctionsCache = results;
+		return results;
+	}
+	async forceDeoptimization(functionRef) {
+		if (!await this.versionDetector.supportsNativesSyntax()) return;
+		const session = await this.createSession();
+		if (!session) return;
+		try {
+			await session.send("Runtime.evaluate", {
+				expression: `
+          (() => {
+            try {
+              const candidate = eval(${JSON.stringify(functionRef)});
+              if (typeof candidate === 'function') {
+                %DeoptimizeFunction(candidate);
+              }
+            } catch (error) {
+              return undefined;
+            }
+            return undefined;
+          })()
+        `,
+				returnByValue: true,
+				awaitPromise: false
+			});
+		} finally {
+			await session.detach().catch(() => void 0);
+		}
+	}
+	async getOptimizedFunctions() {
+		return [...this.optimizedFunctionsCache];
+	}
+	async getOptimizationStatus(functionName) {
+		const session = await this.createSession();
+		if (!session) return null;
+		try {
+			const response = await session.send("Runtime.evaluate", {
+				expression: `
+          (() => {
+            try {
+              const candidate = globalThis[${JSON.stringify(functionName)}];
+              if (typeof candidate !== 'function') {
+                return null;
+              }
+              return %GetOptimizationStatus(candidate);
+            } catch (error) {
+              return null;
+            }
+          })()
+        `,
+				returnByValue: true,
+				awaitPromise: false
+			});
+			if (!isRecord(response)) return null;
+			return readNumber(response["result"]);
+		} catch {
+			return null;
+		} finally {
+			await session.detach().catch(() => void 0);
+		}
+	}
+	async createSession() {
+		if (!this.getPage) return null;
+		try {
+			const page = await this.getPage();
+			if (!isCDPPageLike(page)) return null;
+			return await page.createCDPSession();
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/v8-inspector/handlers/bytecode-extract.ts
+async function handleBytecodeExtract(args, runtime) {
+	const scriptId = argString(args, "scriptId", "").trim();
+	const functionOffset = argNumber(args, "functionOffset");
+	if (scriptId.length === 0) return {
+		success: false,
+		error: "scriptId is required"
+	};
+	const extractor = new BytecodeExtractor(runtime?.getPage);
+	const extraction = await extractor.extractBytecode(scriptId, functionOffset ?? void 0);
+	if (!extraction) return {
+		success: false,
+		error: `Unable to extract bytecode for scriptId "${scriptId}"`
+	};
+	return {
+		success: true,
+		scriptId,
+		functionOffset: functionOffset ?? null,
+		extraction,
+		disassembly: extractor.disassembleBytecode(extraction.bytecode),
+		hiddenClasses: await extractor.findHiddenClasses(scriptId)
+	};
+}
+//#endregion
+//#region src/server/domains/v8-inspector/handlers/jit-inspect.ts
+async function handleJitInspect(args, runtime) {
+	const scriptId = argString(args, "scriptId", "").trim();
+	if (scriptId.length === 0) return {
+		success: false,
+		error: "scriptId is required"
+	};
+	return {
+		success: true,
+		scriptId,
+		functions: await new JITInspector(runtime?.getPage).inspectJIT(scriptId)
+	};
+}
+//#endregion
+//#region src/server/domains/v8-inspector/handlers/impl.ts
+function requireStringArg(args, key) {
+	const value = args[key];
+	if (typeof value !== "string" || value.length === 0) throw new Error(`${key} is required`);
+	return value;
+}
+function requirePageController(ctx) {
+	const pageController = ctx.pageController;
+	if (!pageController) throw new Error("PageController not available");
+	return pageController;
+}
+var V8InspectorHandlers = class {
+	currentSnapshotId = null;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handle(toolName, args) {
+		const handler = {
+			v8_heap_snapshot_capture: (toolArgs) => this.v8_heap_snapshot_capture(toolArgs),
+			v8_heap_snapshot_analyze: (toolArgs) => this.v8_heap_snapshot_analyze(toolArgs),
+			v8_heap_diff: (toolArgs) => this.v8_heap_diff(toolArgs),
+			v8_object_inspect: (toolArgs) => this.v8_object_inspect(toolArgs),
+			v8_heap_stats: (toolArgs) => this.v8_heap_stats(toolArgs),
+			v8_bytecode_extract: (toolArgs) => this.v8_bytecode_extract(toolArgs),
+			v8_version_detect: (toolArgs) => this.v8_version_detect(toolArgs),
+			v8_jit_inspect: (toolArgs) => this.v8_jit_inspect(toolArgs)
+		}[toolName];
+		if (!handler) throw new Error(`Unknown v8-inspector tool: ${toolName}`);
+		return handler(args);
+	}
+	async v8_heap_snapshot_capture(args) {
+		requirePageController(this.deps.ctx);
+		const pageController = this.deps.ctx.pageController;
+		const result = await handleHeapSnapshotCapture(args, {
+			getPage: () => Promise.resolve(pageController),
+			getSnapshot: () => this.currentSnapshotId,
+			setSnapshot: (id) => {
+				this.currentSnapshotId = id;
+			},
+			client: this.deps.client
+		});
+		if (result.success && result.snapshotId) this.deps.ctx.eventBus.emit("v8:heap_captured", {
+			snapshotId: result.snapshotId,
+			sizeBytes: result.sizeBytes,
+			timestamp: result.capturedAt
+		});
+		return result;
+	}
+	async v8_heap_snapshot_analyze(args) {
+		const snapshotId = requireStringArg(args, "snapshotId");
+		const snapshot = getSnapshot(snapshotId);
+		if (!snapshot) throw new Error(`Snapshot ${snapshotId} not found`);
+		return {
+			success: true,
+			snapshotId,
+			summary: {
+				chunkCount: snapshot.chunks.length,
+				sizeBytes: snapshot.sizeBytes
+			},
+			objectAddress: `0x${snapshot.sizeBytes.toString(16)}`
+		};
+	}
+	async v8_heap_diff(args) {
+		const beforeSnapshotId = typeof args.beforeSnapshotId === "string" ? args.beforeSnapshotId : void 0;
+		const afterSnapshotId = typeof args.afterSnapshotId === "string" ? args.afterSnapshotId : void 0;
+		if (!beforeSnapshotId || !afterSnapshotId) throw new Error("Both beforeSnapshotId and afterSnapshotId are required");
+		const beforeSnapshot = getSnapshot(beforeSnapshotId);
+		if (!beforeSnapshot) throw new Error(`Snapshot ${beforeSnapshotId} not found`);
+		const afterSnapshot = getSnapshot(afterSnapshotId);
+		if (!afterSnapshot) throw new Error(`Snapshot ${afterSnapshotId} not found`);
+		return {
+			success: true,
+			beforeSnapshotId,
+			afterSnapshotId,
+			sizeDeltaBytes: afterSnapshot.sizeBytes - beforeSnapshot.sizeBytes
+		};
+	}
+	async v8_object_inspect(args) {
+		const address = requireStringArg(args, "address");
+		let objectData;
+		try {
+			objectData = await this.deps.client.getObjectByObjectId(address) ?? void 0;
+		} catch {}
+		return {
+			success: true,
+			address,
+			...objectData ? { objectData } : {}
+		};
+	}
+	async v8_heap_stats(_args) {
+		requirePageController(this.deps.ctx);
+		let heapUsage;
+		try {
+			heapUsage = await this.deps.client.getHeapUsage();
+		} catch {}
+		return {
+			success: true,
+			snapshotCount: getSnapshotCache().size,
+			...heapUsage ? { heapUsage } : {}
+		};
+	}
+	async v8_bytecode_extract(args) {
+		const pageController = this.deps.ctx.pageController;
+		return handleBytecodeExtract(args, { getPage: pageController ? () => Promise.resolve(pageController) : void 0 });
+	}
+	async v8_version_detect(_args) {
+		const pageController = this.deps.ctx.pageController;
+		if (!pageController) return {
+			success: false,
+			error: "PageController not available"
+		};
+		const { VersionDetector } = await import("./VersionDetector-CwVLVdDM.mjs").then((n) => n.n);
+		return {
+			success: true,
+			version: await new VersionDetector(() => Promise.resolve(pageController)).detectV8Version(),
+			features: {}
+		};
+	}
+	async v8_jit_inspect(args) {
+		const pageController = this.deps.ctx.pageController;
+		return handleJitInspect(args, { getPage: pageController ? () => Promise.resolve(pageController) : void 0 });
+	}
+};
+const registrations = v8InspectorTools.map((toolDef) => ({
+	tool: toolDef,
+	domain: "v8-inspector",
+	bind: bindByDepKey("v8InspectorHandlers", (handlers, args) => handlers.handle(toolDef.name, args))
+}));
+async function ensure(ctx) {
+	if (!ctx.pageController) throw new Error("v8-inspector: PageController not available");
+	const handlers = new V8InspectorHandlers({
+		ctx,
+		client: new V8InspectorClient(() => Promise.resolve(ctx.pageController))
+	});
+	ctx.v8InspectorHandlers = handlers;
+	return handlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: "v8-inspector",
+	depKey: "v8InspectorHandlers",
+	profiles: ["workflow", "full"],
+	registrations,
+	ensure,
+	prerequisites: {
+		v8_heap_snapshot_capture: [{
+			condition: "Browser must be connected",
+			fix: "Call browser_launch or browser_attach first"
+		}],
+		v8_heap_snapshot_analyze: [{
+			condition: "A snapshotId must be provided",
+			fix: "Capture a heap snapshot before analysis"
+		}],
+		v8_heap_diff: [{
+			condition: "Both snapshot identifiers are required",
+			fix: "Capture before/after snapshots before diffing"
+		}]
+	},
+	toolDependencies: [{
+		from: "v8_heap_snapshot_capture",
+		to: "browser_attach",
+		relation: "requires",
+		weight: .8
+	}, {
+		from: "v8_object_inspect",
+		to: "v8_heap_snapshot_analyze",
+		relation: "precedes",
+		weight: .6
+	}],
+	workflowRule: {
+		patterns: [
+			/v8.*heap/i,
+			/heap.*snapshot/i,
+			/jit/i,
+			/object.*address/i
+		],
+		priority: 80,
+		tools: [
+			"v8_heap_snapshot_capture",
+			"v8_heap_snapshot_analyze",
+			"v8_object_inspect",
+			"v8_heap_stats"
+		],
+		hint: "Capture a heap snapshot, analyze it, then inspect interesting objects by address."
+	}
+};
+//#endregion
+export { V8InspectorHandlers, manifest as default };