@jshookmcp/jshook 0.2.9 → 0.3.0

package/dist/manifest-BpS4gtUK.mjs

@@ -0,0 +1,1347 @@
+import { t as VersionDetector } from "./VersionDetector-K3V4vGsw.mjs";
+import { a as argString, r as argNumber, t as argBool } from "./parse-args-B4cY5Vx5.mjs";
+import { t as bindByDepKey } from "./bind-helpers-ClV34xdn.mjs";
+import { t as tool } from "./tool-builder-BHJp32mV.mjs";
+import { spawn } from "node:child_process";
+//#region src/modules/v8-inspector/V8InspectorClient.ts
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null;
+}
+function toNumber$1(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function unwrapRuntimeValue$2(value) {
+	if (!isRecord$3(value)) return value;
+	if ("value" in value) return unwrapRuntimeValue$2(value["value"]);
+	if ("result" in value) return unwrapRuntimeValue$2(value["result"]);
+	return value;
+}
+function parseHeapUsage(value) {
+	const unwrapped = unwrapRuntimeValue$2(value);
+	const normalized = typeof unwrapped === "string" ? (() => {
+		try {
+			return JSON.parse(unwrapped);
+		} catch {
+			return null;
+		}
+	})() : unwrapped;
+	if (!isRecord$3(normalized)) return null;
+	const jsHeapSizeUsed = toNumber$1(normalized["jsHeapSizeUsed"]) ?? toNumber$1(normalized["usedSize"]);
+	const jsHeapSizeTotal = toNumber$1(normalized["jsHeapSizeTotal"]) ?? toNumber$1(normalized["totalSize"]);
+	const jsHeapSizeLimit = toNumber$1(normalized["jsHeapSizeLimit"]) ?? 0;
+	if (jsHeapSizeUsed === null && jsHeapSizeTotal === null && jsHeapSizeLimit === 0) return null;
+	const patch = {};
+	if (jsHeapSizeUsed !== null) patch.jsHeapSizeUsed = jsHeapSizeUsed;
+	if (jsHeapSizeTotal !== null) patch.jsHeapSizeTotal = jsHeapSizeTotal;
+	if (jsHeapSizeLimit > 0) patch.jsHeapSizeLimit = jsHeapSizeLimit;
+	return patch;
+}
+function hasMeaningfulHeapUsage(stats) {
+	return stats.jsHeapSizeUsed > 0 || stats.jsHeapSizeTotal > 0 || stats.jsHeapSizeLimit > 0;
+}
+function mergeHeapUsage(base, patch) {
+	if (!base && !patch) return null;
+	const merged = {
+		jsHeapSizeUsed: patch?.jsHeapSizeUsed ?? base?.jsHeapSizeUsed ?? 0,
+		jsHeapSizeTotal: patch?.jsHeapSizeTotal ?? base?.jsHeapSizeTotal ?? 0,
+		jsHeapSizeLimit: patch?.jsHeapSizeLimit ?? base?.jsHeapSizeLimit ?? 0
+	};
+	return hasMeaningfulHeapUsage(merged) ? merged : null;
+}
+function parsePerformanceMetrics(value) {
+	const unwrapped = unwrapRuntimeValue$2(value);
+	if (!isRecord$3(unwrapped) || !Array.isArray(unwrapped["metrics"])) return null;
+	const metrics = /* @__PURE__ */ new Map();
+	for (const metric of unwrapped["metrics"]) {
+		if (!isRecord$3(metric)) continue;
+		const name = typeof metric["name"] === "string" ? metric["name"] : null;
+		const metricValue = toNumber$1(metric["value"]);
+		if (!name || metricValue === null) continue;
+		metrics.set(name, metricValue);
+	}
+	const jsHeapSizeUsed = metrics.get("JSHeapUsedSize") ?? 0;
+	const jsHeapSizeTotal = metrics.get("JSHeapTotalSize") ?? 0;
+	if (jsHeapSizeUsed === 0 && jsHeapSizeTotal === 0) return null;
+	return {
+		jsHeapSizeUsed,
+		jsHeapSizeTotal
+	};
+}
+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) {
+		const session = await this.createSession();
+		if (!session) return null;
+		try {
+			const response = await session.send("Runtime.getProperties", {
+				objectId: _objectId,
+				ownProperties: true,
+				accessorPropertiesOnly: false,
+				generatePreview: true
+			});
+			if (Array.isArray(response.result)) return {
+				kind: "runtime-object",
+				properties: response.result,
+				internalProperties: Array.isArray(response.internalProperties) ? response.internalProperties : [],
+				privateProperties: Array.isArray(response.privateProperties) ? response.privateProperties : [],
+				...response.exceptionDetails ? { exceptionDetails: response.exceptionDetails } : {}
+			};
+		} catch {}
+		try {
+			return await session.send("HeapProfiler.getObjectByHeapObjectId", { 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) throw new Error("V8InspectorClient: session not available for heap usage");
+		let heapUsage = null;
+		try {
+			const runtimeUsage = await session.send("Runtime.getHeapUsage");
+			heapUsage = mergeHeapUsage(heapUsage, parseHeapUsage(runtimeUsage));
+		} catch {}
+		try {
+			const profilerUsage = await session.send("HeapProfiler.getHeapUsage");
+			heapUsage = mergeHeapUsage(heapUsage, parseHeapUsage(profilerUsage));
+		} catch {}
+		try {
+			const metrics = await session.send("Performance.getMetrics");
+			heapUsage = mergeHeapUsage(heapUsage, parsePerformanceMetrics(metrics));
+		} catch {}
+		try {
+			const response = await session.send("Runtime.evaluate", {
+				expression: `
+          (() => {
+            const m = performance.memory;
+            return m
+              ? {
+                  jsHeapSizeUsed: m.usedJSHeapSize,
+                  jsHeapSizeTotal: m.totalJSHeapSize,
+                  jsHeapSizeLimit: m.jsHeapSizeLimit
+                }
+              : null;
+          })()
+        `,
+				returnByValue: true
+			});
+			heapUsage = mergeHeapUsage(heapUsage, parseHeapUsage(response));
+		} catch {}
+		if (!heapUsage) throw new Error("V8InspectorClient: heap usage metrics unavailable");
+		return heapUsage;
+	}
+	/**
+	* 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;
+			this.session = session;
+			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").query()),
+	tool("v8_heap_snapshot_analyze", (t) => t.desc("Analyze a captured V8 heap snapshot").string("snapshotId", "Snapshot ID").required("snapshotId").query()),
+	tool("v8_heap_diff", (t) => t.desc("Diff two V8 heap snapshots").string("beforeSnapshotId", "Baseline snapshot ID").string("afterSnapshotId", "Updated snapshot ID").required("beforeSnapshotId", "afterSnapshotId").query()),
+	tool("v8_object_inspect", (t) => t.desc("Inspect a live JS object by object identifier").string("address", "Runtime objectId or compatible heap object id").required("address").query()),
+	tool("v8_heap_stats", (t) => t.desc("Read V8 heap usage").query()),
+	tool("v8_bytecode_extract", (t) => t.desc("Attempt V8 bytecode extraction for a script").string("scriptId", "CDP scriptId").number("functionOffset", "Optional function byte offset").boolean("includeSourceFallback", "Include source-derived fallback output").required("scriptId").query()),
+	tool("v8_version_detect", (t) => t.desc("Detect V8 version and capabilities").query()),
+	tool("v8_jit_inspect", (t) => t.desc("Inspect JIT status for a V8 script").string("scriptId", "CDP scriptId").required("scriptId").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";
+}
+function unwrapRuntimeValue$1(value) {
+	if (!isRecord$2(value)) return value;
+	if ("value" in value) return unwrapRuntimeValue$1(value["value"]);
+	if ("result" in value) return unwrapRuntimeValue$1(value["result"]);
+	return value;
+}
+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
+              ? {
+                  jsHeapSizeUsed: m.usedJSHeapSize,
+                  jsHeapSizeTotal: m.totalJSHeapSize,
+                  jsHeapSizeLimit: m.jsHeapSizeLimit
+                }
+              : null;
+          })()
+        `,
+				returnByValue: true
+			});
+			await sessionDetach().catch(() => void 0);
+			const result = unwrapRuntimeValue$1(response);
+			const parsedResult = typeof result === "string" ? (() => {
+				try {
+					return JSON.parse(result);
+				} catch {
+					return null;
+				}
+			})() : result;
+			let sizeBytes = 0;
+			if (isRecord$2(parsedResult) && typeof parsedResult["jsHeapSizeUsed"] === "number") sizeBytes = parsedResult["jsHeapSizeUsed"];
+			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/NativeBytecodePrinter.ts
+const STATUS_PREFIX = "__JSHOOK_BYTECODE_STATUS__:";
+const TARGET_NAME = "__jshookBytecodeTarget__";
+const DEFAULT_TIMEOUT_MS = 15e3;
+function isValidFunctionName(value) {
+	return /^[A-Za-z_$][\w$]*$/u.test(value);
+}
+function normalizeFunctionName(value) {
+	const trimmed = value.trim();
+	if (trimmed.length === 0 || trimmed === "anonymous") return TARGET_NAME;
+	return isValidFunctionName(trimmed) ? trimmed : TARGET_NAME;
+}
+function shouldWrapAsObjectMember(source) {
+	const trimmed = source.trim();
+	if (trimmed.startsWith("function") || trimmed.startsWith("async function") || trimmed.startsWith("class ") || trimmed.startsWith("(") || trimmed.includes("=>")) return false;
+	return /^(?:async\s+)?(?:get\s+|set\s+)?\*?\s*[A-Za-z_$][\w$]*\s*\(/u.test(trimmed);
+}
+function buildBootstrapScript(context) {
+	const source = context.sourceSlice.trim();
+	const requestedName = context.functionName.trim();
+	return `
+let ${TARGET_NAME};
+${shouldWrapAsObjectMember(source) ? `
+try {
+  const __jshookHolder = { ${source} };
+  const __jshookCandidate = __jshookHolder[${JSON.stringify(requestedName)}];
+  if (typeof __jshookCandidate === 'function') {
+    ${TARGET_NAME} = __jshookCandidate;
+  }
+} catch {}
+` : `
+try {
+  ${TARGET_NAME} = (${source});
+} catch {}
+`}
+
+if (typeof ${TARGET_NAME} !== 'function') {
+  console.log(${JSON.stringify(`${STATUS_PREFIX}resolve-failed`)});
+} else {
+  try {
+    const __jshookArity =
+      typeof ${TARGET_NAME}.length === 'number' && ${TARGET_NAME}.length > 0
+        ? ${TARGET_NAME}.length
+        : 0;
+    Reflect.apply(${TARGET_NAME}, globalThis, Array.from({ length: __jshookArity }, () => undefined));
+  } catch (error) {
+    console.log(${JSON.stringify(`${STATUS_PREFIX}invoke-error:`)} + String(error));
+  }
+  console.log(${JSON.stringify(`${STATUS_PREFIX}done`)});
+}
+`;
+}
+function parsePrintedBytecode(output, candidateNames) {
+	const lines = output.split(/\r?\n/u);
+	const filters = new Set(candidateNames.filter((entry) => entry.length > 0));
+	let matchedFunctionName = null;
+	let capturing = false;
+	const captured = [];
+	for (const line of lines) {
+		const headerMatch = /^\[generated bytecode for function: (.+?) \(/u.exec(line);
+		if (headerMatch?.[1]) {
+			if (capturing && captured.length > 0) break;
+			matchedFunctionName = filters.has(headerMatch[1]) ? headerMatch[1] : null;
+			capturing = matchedFunctionName !== null;
+			if (capturing) {
+				captured.length = 0;
+				captured.push(line);
+			}
+			continue;
+		}
+		if (!capturing) continue;
+		if (line.startsWith(STATUS_PREFIX)) break;
+		captured.push(line);
+	}
+	if (captured.length === 0) return {
+		bytecode: null,
+		matchedFunctionName: null
+	};
+	return {
+		bytecode: captured.join("\n").trim(),
+		matchedFunctionName
+	};
+}
+function parseStatus(output) {
+	const line = output.split(/\r?\n/u).find((entry) => entry.startsWith(STATUS_PREFIX) && entry.length > 27);
+	return line ? line.slice(27) : null;
+}
+function formatIsolatedFailure(output, stderr, fallback) {
+	const status = parseStatus(output);
+	if (status === "resolve-failed") return "Unable to reconstruct an executable function from the captured source slice";
+	if (typeof status === "string" && status.startsWith("invoke-error:")) return `Function compiled but raised during isolated invocation: ${status.slice(13)}`;
+	const stderrText = stderr.trim();
+	if (stderrText.length > 0) return stderrText;
+	return fallback;
+}
+async function runBytecodePrinter(bootstrapScript, filterName, timeoutMs) {
+	return await new Promise((resolve) => {
+		const child = spawn(process.execPath, [
+			"--print-bytecode",
+			`--print-bytecode-filter=${filterName}`,
+			"-"
+		], { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		let stdout = "";
+		let stderr = "";
+		let settled = false;
+		const finish = (error) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve({
+				stdout,
+				stderr,
+				error
+			});
+		};
+		const timer = setTimeout(() => {
+			child.kill();
+			finish(`Timed out after ${timeoutMs}ms while waiting for isolated bytecode output`);
+		}, timeoutMs);
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", (error) => {
+			finish(error instanceof Error ? error.message : String(error));
+		});
+		child.on("close", (code) => {
+			finish(code === 0 ? null : `Bytecode printer exited with code ${code}`);
+		});
+		child.stdin.end(bootstrapScript);
+	});
+}
+async function printNativeIgnitionBytecode(context, timeoutMs = DEFAULT_TIMEOUT_MS) {
+	const requestedName = normalizeFunctionName(context.functionName);
+	const candidateNames = Array.from(new Set([requestedName, TARGET_NAME]));
+	const bootstrapScript = buildBootstrapScript(context);
+	for (const filterName of candidateNames) {
+		const { stdout, stderr, error } = await runBytecodePrinter(bootstrapScript, filterName, timeoutMs);
+		const extracted = parsePrintedBytecode(stdout, candidateNames);
+		if (extracted.bytecode) {
+			const resolvedFunctionName = extracted.matchedFunctionName === TARGET_NAME ? requestedName : extracted.matchedFunctionName;
+			return {
+				available: true,
+				bytecode: extracted.bytecode,
+				format: "ignition-bytecode",
+				functionName: resolvedFunctionName ?? requestedName,
+				reason: "Ignition bytecode emitted by an isolated V8 process via --print-bytecode from the extracted source slice",
+				rawIgnitionBytecodeAvailable: true
+			};
+		}
+		if (error && filterName === candidateNames.at(-1)) return {
+			available: false,
+			bytecode: null,
+			format: null,
+			functionName: requestedName,
+			reason: formatIsolatedFailure(stdout, stderr, error),
+			rawIgnitionBytecodeAvailable: false
+		};
+	}
+	return {
+		available: false,
+		bytecode: null,
+		format: null,
+		functionName: requestedName,
+		reason: "Isolated V8 bytecode printer did not emit a matching function block",
+		rawIgnitionBytecodeAvailable: false
+	};
+}
+//#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;
+}
+function unwrapRuntimeValue(response) {
+	const result = response["result"];
+	if (isRecord$1(result) && result["value"] !== void 0) return result["value"];
+	return result;
+}
+function formatUnavailableReason(result) {
+	const explicitReason = toStringValue(result["reason"]);
+	if (explicitReason) return explicitReason;
+	const disassemblyError = toStringValue(result["disassemblyError"]);
+	if (disassemblyError) return disassemblyError;
+	const disassemblyType = toStringValue(result["disassemblyType"]);
+	if (disassemblyType) return `Native disassembly returned ${disassemblyType} instead of text`;
+	return "Runtime disassembly output is not exposed through the current browser/CDP path";
+}
+var BytecodeExtractor = class {
+	versionDetector;
+	constructor(getPage) {
+		this.getPage = getPage;
+		this.versionDetector = new VersionDetector(getPage);
+	}
+	async extractBytecode(scriptId, functionOffset) {
+		const context = await this.resolveScriptFunctionContext(scriptId, functionOffset);
+		if (!context) return null;
+		return {
+			functionName: context.functionName,
+			bytecode: buildPseudoBytecode(context.sourceSlice),
+			sourcePosition: context.sourcePosition
+		};
+	}
+	async attemptNativeBytecodeExtraction(scriptId, functionOffset) {
+		const context = await this.resolveScriptFunctionContext(scriptId, functionOffset);
+		if (!context) return null;
+		if (!await this.versionDetector.supportsNativesSyntax()) return {
+			available: false,
+			bytecode: null,
+			format: null,
+			functionName: context.functionName,
+			rawIgnitionBytecodeAvailable: false,
+			reason: "V8 natives syntax is unavailable in the current browser target",
+			sourcePosition: context.sourcePosition,
+			supportsNativesSyntax: false
+		};
+		const session = await this.createSession();
+		if (!session) return {
+			available: false,
+			bytecode: null,
+			format: null,
+			functionName: context.functionName,
+			rawIgnitionBytecodeAvailable: false,
+			reason: "Browser/page CDP session is unavailable for native bytecode inspection",
+			sourcePosition: context.sourcePosition,
+			supportsNativesSyntax: true
+		};
+		try {
+			const response = await session.send("Runtime.evaluate", {
+				expression: this.buildNativeExtractionExpression(context.functionName),
+				returnByValue: true,
+				awaitPromise: false
+			});
+			if (!isRecord$1(response)) return {
+				available: false,
+				bytecode: null,
+				format: null,
+				functionName: context.functionName,
+				rawIgnitionBytecodeAvailable: false,
+				reason: "Runtime.evaluate did not return structured data",
+				sourcePosition: context.sourcePosition,
+				supportsNativesSyntax: true
+			};
+			if (response["exceptionDetails"]) return {
+				available: false,
+				bytecode: null,
+				format: null,
+				functionName: context.functionName,
+				rawIgnitionBytecodeAvailable: false,
+				reason: "Runtime.evaluate raised an exception while probing native bytecode",
+				sourcePosition: context.sourcePosition,
+				supportsNativesSyntax: true
+			};
+			const value = unwrapRuntimeValue(response);
+			const result = isRecord$1(value) ? value : {};
+			const bytecode = toStringValue(result["disassembly"]);
+			const nativeSourcePosition = toNumber(result["nativeSourcePosition"]);
+			if (bytecode && bytecode.length > 0) return {
+				available: true,
+				bytecode,
+				format: "v8-disassembly",
+				functionName: context.functionName,
+				rawIgnitionBytecodeAvailable: false,
+				reason: "Native V8 disassembly text returned via %DisassembleFunction",
+				sourcePosition: nativeSourcePosition ?? context.sourcePosition,
+				supportsNativesSyntax: true
+			};
+			const isolatedAttempt = await printNativeIgnitionBytecode(context);
+			if (isolatedAttempt.available && isolatedAttempt.bytecode) return {
+				available: true,
+				bytecode: isolatedAttempt.bytecode,
+				format: isolatedAttempt.format,
+				functionName: isolatedAttempt.functionName,
+				rawIgnitionBytecodeAvailable: isolatedAttempt.rawIgnitionBytecodeAvailable,
+				reason: isolatedAttempt.reason,
+				sourcePosition: nativeSourcePosition ?? context.sourcePosition,
+				supportsNativesSyntax: true
+			};
+			return {
+				available: false,
+				bytecode: null,
+				format: null,
+				functionName: context.functionName,
+				rawIgnitionBytecodeAvailable: false,
+				reason: `${formatUnavailableReason(result)}; isolated printer: ${isolatedAttempt.reason}`,
+				sourcePosition: nativeSourcePosition ?? context.sourcePosition,
+				supportsNativesSyntax: true
+			};
+		} catch (error) {
+			return {
+				available: false,
+				bytecode: null,
+				format: null,
+				functionName: context.functionName,
+				rawIgnitionBytecodeAvailable: false,
+				reason: error instanceof Error ? error.message : String(error),
+				sourcePosition: context.sourcePosition,
+				supportsNativesSyntax: true
+			};
+		} finally {
+			await session.detach().catch(() => 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+\w+>\s+[0-9A-Fa-f]+\s+@\s*(\d+)\s*:\s*(?:[0-9A-Fa-f]{2}(?:\s+[0-9A-Fa-f]{2})*\s+)?([A-Za-z_][\w.]*)\s*(.*)$/u.exec(trimmed) ?? /^(\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);
+	}
+	buildNativeExtractionExpression(functionName) {
+		return `
+      (() => {
+        const functionName = ${JSON.stringify(functionName)};
+        try {
+          const candidate = globalThis[functionName];
+          if (typeof candidate !== 'function') {
+            return {
+              functionName,
+              reason: 'Resolved function is not reachable via globalThis in the current target',
+            };
+          }
+
+          const nativeSourcePosition = (() => {
+            try {
+              return %FunctionGetScriptSourcePosition(candidate);
+            } catch (error) {
+              return null;
+            }
+          })();
+
+          try {
+            const disassembly = %DisassembleFunction(candidate);
+            return {
+              functionName,
+              disassembly: typeof disassembly === 'string' ? disassembly : null,
+              disassemblyType: typeof disassembly,
+              nativeSourcePosition:
+                typeof nativeSourcePosition === 'number' ? nativeSourcePosition : null,
+            };
+          } catch (error) {
+            return {
+              functionName,
+              disassemblyError: String(error),
+              nativeSourcePosition:
+                typeof nativeSourcePosition === 'number' ? nativeSourcePosition : null,
+            };
+          }
+        } catch (error) {
+          return {
+            functionName,
+            reason: String(error),
+          };
+        }
+      })()
+    `;
+	}
+	async resolveScriptFunctionContext(scriptId, functionOffset) {
+		const scriptSource = await this.getScriptSource(scriptId);
+		if (!scriptSource) return null;
+		const functions = await this.getCoverageFunctions(scriptId);
+		const defaultFunction = (typeof functionOffset === "number" ? functions.find((candidate) => functionOffset >= candidate.startOffset && functionOffset <= candidate.endOffset) : void 0) ?? functions.find((candidate) => candidate.functionName.length > 0 && candidate.functionName !== "anonymous") ?? functions[0];
+		const functionName = defaultFunction?.functionName && defaultFunction.functionName.length > 0 && defaultFunction.functionName !== "anonymous" ? defaultFunction.functionName : inferFunctionName(scriptSource, functionOffset);
+		const sourceSlice = defaultFunction && defaultFunction.endOffset > defaultFunction.startOffset ? scriptSource.slice(defaultFunction.startOffset, defaultFunction.endOffset) : scriptSource;
+		return {
+			functionName,
+			sourcePosition: typeof functionOffset === "number" ? functionOffset : defaultFunction ? defaultFunction.startOffset : void 0,
+			sourceSlice
+		};
+	}
+	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 {
+			functions: results,
+			supportsNativesSyntax,
+			inspectionMode: supportsNativesSyntax ? "native-status" : "heuristic"
+		};
+	}
+	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");
+	const includeSourceFallback = argBool(args, "includeSourceFallback", false);
+	if (scriptId.length === 0) return {
+		success: false,
+		error: "scriptId is required"
+	};
+	const extractor = new BytecodeExtractor(runtime?.getPage);
+	const nativeAttempt = await extractor.attemptNativeBytecodeExtraction(scriptId, functionOffset ?? void 0);
+	if (!nativeAttempt) return {
+		success: false,
+		error: `Unable to inspect bytecode for scriptId "${scriptId}"`
+	};
+	const hiddenClasses = await extractor.findHiddenClasses(scriptId);
+	if (nativeAttempt.available && nativeAttempt.bytecode) {
+		const extraction = {
+			functionName: nativeAttempt.functionName,
+			bytecode: nativeAttempt.bytecode,
+			sourcePosition: nativeAttempt.sourcePosition
+		};
+		return {
+			success: true,
+			scriptId,
+			functionOffset: functionOffset ?? null,
+			mode: "native",
+			bytecodeAvailable: true,
+			format: nativeAttempt.format,
+			rawIgnitionBytecodeAvailable: nativeAttempt.rawIgnitionBytecodeAvailable,
+			supportsNativesSyntax: nativeAttempt.supportsNativesSyntax,
+			reason: nativeAttempt.reason,
+			extraction,
+			disassembly: extractor.disassembleBytecode(nativeAttempt.bytecode),
+			hiddenClasses,
+			sourceFallback: null
+		};
+	}
+	const sourceFallback = includeSourceFallback ? await extractor.extractBytecode(scriptId, functionOffset ?? void 0) : null;
+	return {
+		success: true,
+		scriptId,
+		functionOffset: functionOffset ?? null,
+		mode: sourceFallback ? "source-fallback" : "unavailable",
+		bytecodeAvailable: false,
+		format: null,
+		rawIgnitionBytecodeAvailable: nativeAttempt.rawIgnitionBytecodeAvailable,
+		supportsNativesSyntax: nativeAttempt.supportsNativesSyntax,
+		reason: nativeAttempt.reason,
+		extraction: null,
+		disassembly: [],
+		hiddenClasses,
+		sourceFallback: sourceFallback ? {
+			format: "pseudo-bytecode",
+			extraction: sourceFallback,
+			disassembly: extractor.disassembleBytecode(sourceFallback.bytecode)
+		} : null
+	};
+}
+//#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"
+	};
+	const inspection = await new JITInspector(runtime?.getPage).inspectJIT(scriptId);
+	return {
+		success: true,
+		scriptId,
+		inspectionMode: inspection.inspectionMode,
+		supportsNativesSyntax: inspection.supportsNativesSyntax,
+		functions: inspection.functions
+	};
+}
+//#endregion
+//#region src/server/domains/v8-inspector/handlers/impl.ts
+function createDebuggerObjectData(properties) {
+	return {
+		kind: "runtime-object",
+		source: "debugger-session",
+		propertyCount: properties.length,
+		properties
+	};
+}
+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;
+}
+function createV8InspectorClient(ctx) {
+	return new V8InspectorClient(createPageGetter(ctx));
+}
+function createPageGetter(ctx) {
+	const pageController = requirePageController(ctx);
+	return async () => await pageController.getPage();
+}
+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 result = await handleHeapSnapshotCapture(args, {
+			getPage: createPageGetter(this.deps.ctx),
+			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 = await this.inspectObjectViaDebugger(address);
+		if (!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) {
+		return handleBytecodeExtract(args, { getPage: this.deps.ctx.pageController ? createPageGetter(this.deps.ctx) : void 0 });
+	}
+	async v8_version_detect(_args) {
+		if (!this.deps.ctx.pageController) return {
+			success: false,
+			error: "PageController not available"
+		};
+		const { VersionDetector } = await import("./VersionDetector-K3V4vGsw.mjs").then((n) => n.n);
+		const detector = new VersionDetector(createPageGetter(this.deps.ctx));
+		return {
+			success: true,
+			version: await detector.detectV8Version(),
+			features: { nativesSyntax: await detector.supportsNativesSyntax() }
+		};
+	}
+	async v8_jit_inspect(args) {
+		return handleJitInspect(args, { getPage: this.deps.ctx.pageController ? createPageGetter(this.deps.ctx) : void 0 });
+	}
+	async inspectObjectViaDebugger(address) {
+		const debuggerManager = this.deps.ctx.debuggerManager;
+		if (!debuggerManager || typeof debuggerManager.getObjectPropertiesById !== "function") return;
+		try {
+			const properties = await debuggerManager.getObjectPropertiesById(address);
+			if (!Array.isArray(properties)) return;
+			return createDebuggerObjectData(properties);
+		} catch {
+			return;
+		}
+	}
+};
+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: createV8InspectorClient(ctx)
+	});
+	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 };