@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/sourcemap-BIDHUVXy.mjs

@@ -0,0 +1,934 @@
+import { cr as SOURCEMAP_V4_RETRY_DELAY_MS, sr as SOURCEMAP_V4_RAW_FIELD_MAX_LEN } from "./constants-CDZLOoVv.mjs";
+import { i as resolveArtifactPath } from "./artifacts-DkfosXH3.mjs";
+import { n as detachFromFlatTarget, t as attachToFlatTarget } from "./flat-target-session-Dgax2Cy3.mjs";
+import { s as evaluateWithTimeout } from "./PageController-BPJNqqBN.mjs";
+import "./definitions-DAgIyjxM.mjs";
+import { dirname, resolve } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+//#region src/server/domains/sourcemap/handlers/shared.ts
+const BASE64_DECODE_MAP = new Map(Array.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").map((char, index) => [char, index]));
+function fromVlqSigned(value) {
+	const isNegative = (value & 1) === 1;
+	const shifted = value >> 1;
+	return isNegative ? -shifted : shifted;
+}
+function decodeVlqSegment(segment) {
+	const values = [];
+	let index = 0;
+	while (index < segment.length) {
+		let result = 0;
+		let shift = 0;
+		let continuation = true;
+		while (continuation) {
+			const char = segment.charAt(index);
+			if (!char) throw new Error(`Unexpected end of VLQ segment: "${segment}"`);
+			index += 1;
+			const digit = BASE64_DECODE_MAP.get(char);
+			if (digit === void 0) throw new Error(`Invalid VLQ base64 char "${char}" in segment "${segment}"`);
+			continuation = (digit & 32) !== 0;
+			const digitValue = digit & 31;
+			result += digitValue << shift;
+			shift += 5;
+		}
+		values.push(fromVlqSigned(result));
+	}
+	return values;
+}
+function decodeVlqSegmentUnsigned(segment) {
+	const values = [];
+	let index = 0;
+	while (index < segment.length) {
+		let result = 0;
+		let shift = 0;
+		let continuation = true;
+		while (continuation) {
+			const char = segment.charAt(index);
+			if (!char) throw new Error(`Unexpected end of VLQ segment: "${segment}"`);
+			index += 1;
+			const digit = BASE64_DECODE_MAP.get(char);
+			if (digit === void 0) throw new Error(`Invalid VLQ base64 char "${char}" in segment "${segment}"`);
+			continuation = (digit & 32) !== 0;
+			const digitValue = digit & 31;
+			result += digitValue << shift;
+			shift += 5;
+		}
+		values.push(result);
+	}
+	return values;
+}
+function decodeMappings(mappings) {
+	if (!mappings) return [];
+	const decoded = [];
+	let previousSource = 0;
+	let previousOriginalLine = 0;
+	let previousOriginalColumn = 0;
+	let previousName = 0;
+	const lines = mappings.split(";");
+	for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+		const line = lines[lineIndex] ?? "";
+		let generatedColumn = 0;
+		if (!line) continue;
+		const segments = line.split(",");
+		for (const segment of segments) {
+			if (!segment) continue;
+			const values = decodeVlqSegment(segment);
+			const generatedDelta = values[0];
+			if (generatedDelta === void 0) continue;
+			generatedColumn += generatedDelta;
+			const mapping = {
+				generatedLine: lineIndex + 1,
+				generatedColumn
+			};
+			if (values.length >= 4) {
+				previousSource += values[1] ?? 0;
+				previousOriginalLine += values[2] ?? 0;
+				previousOriginalColumn += values[3] ?? 0;
+				mapping.sourceIndex = previousSource;
+				mapping.originalLine = previousOriginalLine + 1;
+				mapping.originalColumn = previousOriginalColumn;
+				if (values.length >= 5) {
+					previousName += values[4] ?? 0;
+					mapping.nameIndex = previousName;
+				}
+			}
+			decoded.push(mapping);
+		}
+	}
+	return decoded;
+}
+function countMappingsStats(mappings) {
+	if (!mappings) return {
+		mappingsCount: 0,
+		segmentCount: 0
+	};
+	let mappingsCount = 0;
+	let segmentCount = 0;
+	let inNonEmptyLine = false;
+	for (let i = 0; i < mappings.length; i++) {
+		const ch = mappings[i];
+		if (ch === ";") {
+			if (inNonEmptyLine) mappingsCount++;
+			inNonEmptyLine = false;
+		} else if (ch === ",") segmentCount++;
+		else if (!inNonEmptyLine) {
+			inNonEmptyLine = true;
+			segmentCount++;
+		}
+	}
+	if (inNonEmptyLine) mappingsCount++;
+	return {
+		mappingsCount,
+		segmentCount
+	};
+}
+function json(payload) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(payload, null, 2)
+	}] };
+}
+function fail(tool, error) {
+	return json({
+		success: false,
+		tool,
+		error: error instanceof Error ? error.message : String(error)
+	});
+}
+function asRecord(value) {
+	return typeof value === "object" && value !== null ? value : {};
+}
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function hasProtocol(value) {
+	return /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value);
+}
+function parseBooleanArg(value, defaultValue) {
+	return typeof value === "boolean" ? value : defaultValue;
+}
+function requiredStringArg(value, fieldName) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${fieldName} is required`);
+	return value.trim();
+}
+function optionalStringArg(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+async function safeDetach(session) {
+	if (!session.detach) return;
+	try {
+		await session.detach();
+	} catch {}
+}
+async function trySend(session, method, params) {
+	try {
+		await session.send(method, params);
+	} catch {}
+}
+async function delay(ms) {
+	await new Promise((r) => setTimeout(() => r(), ms));
+}
+//#endregion
+//#region src/server/domains/sourcemap/handlers/extension-handlers.ts
+var ExtensionHandlers = class {
+	state;
+	constructor(state) {
+		this.state = state;
+	}
+	async handleExtensionListInstalled(_args) {
+		const session = await (await this.state.collector.getActivePage()).createCDPSession();
+		try {
+			return json((await this.getExtensionTargets(session)).map((target) => ({
+				extensionId: target.extensionId,
+				name: target.name,
+				type: target.type,
+				url: target.url
+			})));
+		} catch (error) {
+			return fail("extension_list_installed", error);
+		} finally {
+			await safeDetach(session);
+		}
+	}
+	async handleExtensionExecuteInContext(args) {
+		const extensionId = requiredStringArg(args.extensionId, "extensionId");
+		const code = requiredStringArg(args.code, "code");
+		const returnByValue = parseBooleanArg(args.returnByValue, true);
+		const session = await (await this.state.collector.getActivePage()).createCDPSession();
+		let attachedSession = null;
+		try {
+			const targets = await this.getExtensionTargets(session, extensionId);
+			if (targets.length === 0) throw new Error(`No background target found for extension: ${extensionId}`);
+			const preferred = this.pickPreferredExtensionTarget(targets);
+			attachedSession = await attachToFlatTarget(session, preferred.targetId);
+			const evaluation = await this.evaluateInAttachedTarget(attachedSession, code, returnByValue);
+			return json({
+				extensionId,
+				target: {
+					type: preferred.type,
+					url: preferred.url,
+					name: preferred.name
+				},
+				result: evaluation.result,
+				exceptionDetails: evaluation.exceptionDetails
+			});
+		} catch (error) {
+			return fail("extension_execute_in_context", error);
+		} finally {
+			if (attachedSession) await detachFromFlatTarget(session, attachedSession).catch(() => void 0);
+			await safeDetach(session);
+		}
+	}
+	async getExtensionTargets(session, expectedExtensionId) {
+		const response = asRecord(await session.send("Target.getTargets"));
+		const targetInfos = Array.isArray(response.targetInfos) ? response.targetInfos : [];
+		const allowedTypes = new Set(["service_worker", "background_page"]);
+		const result = [];
+		for (const item of targetInfos) {
+			const record = asRecord(item);
+			const targetId = asString(record.targetId);
+			const type = asString(record.type);
+			const url = asString(record.url);
+			if (!targetId || !type || !url) continue;
+			if (!allowedTypes.has(type)) continue;
+			const extensionId = this.extractExtensionId(url);
+			if (!extensionId) continue;
+			if (expectedExtensionId && extensionId !== expectedExtensionId) continue;
+			const title = asString(record.title) ?? "";
+			result.push({
+				targetId,
+				extensionId,
+				name: title || extensionId,
+				type,
+				url
+			});
+		}
+		result.sort((left, right) => {
+			const leftScore = left.type === "service_worker" ? 0 : 1;
+			const rightScore = right.type === "service_worker" ? 0 : 1;
+			if (leftScore !== rightScore) return leftScore - rightScore;
+			return left.extensionId.localeCompare(right.extensionId);
+		});
+		return result;
+	}
+	pickPreferredExtensionTarget(targets) {
+		return targets.find((target) => target.type === "service_worker") ?? targets[0];
+	}
+	extractExtensionId(url) {
+		return url.match(/^chrome-extension:\/\/([a-p]{32})(?:\/|$)/i)?.[1] ?? null;
+	}
+	async evaluateInAttachedTarget(session, code, returnByValue) {
+		const response = asRecord(await session.send("Runtime.evaluate", {
+			expression: code,
+			returnByValue,
+			awaitPromise: true
+		}));
+		const resultEnvelope = asRecord(response.result);
+		return {
+			result: returnByValue && resultEnvelope.value !== void 0 ? resultEnvelope.value : Object.keys(resultEnvelope).length > 0 ? resultEnvelope : null,
+			exceptionDetails: response.exceptionDetails !== void 0 ? response.exceptionDetails : null
+		};
+	}
+};
+//#endregion
+//#region src/server/domains/sourcemap/handlers/sourcemap-parsing.ts
+/**
+* Sourcemap parsing, URL resolution, and path normalization functions.
+*/
+function parseSourceMap(sourceMapUrl, scriptUrl, collector) {
+	return loadSourceMap(sourceMapUrl, scriptUrl, collector).then((loaded) => {
+		const mappings = decodeMappings(loaded.map.mappings);
+		const generatedLines = new Set(mappings.map((item) => item.generatedLine));
+		return {
+			resolvedUrl: loaded.resolvedUrl,
+			map: loaded.map,
+			mappings,
+			mappingsCount: generatedLines.size,
+			segmentCount: mappings.length
+		};
+	});
+}
+function parseSourceMapStats(sourceMapUrl, scriptUrl, collector) {
+	return loadSourceMap(sourceMapUrl, scriptUrl, collector).then((loaded) => {
+		const { mappingsCount, segmentCount } = countMappingsStats(loaded.map.mappings);
+		return {
+			resolvedUrl: loaded.resolvedUrl,
+			map: loaded.map,
+			mappingsCount,
+			segmentCount
+		};
+	});
+}
+async function loadSourceMap(sourceMapUrl, scriptUrl, collector) {
+	const resolvedUrl = resolveSourceMapUrl(sourceMapUrl, scriptUrl ?? "");
+	let sourceMapText = "";
+	if (resolvedUrl.startsWith("data:")) sourceMapText = decodeDataUriJson(resolvedUrl);
+	else sourceMapText = await fetchSourceMapText(resolvedUrl, collector);
+	let parsedJson;
+	try {
+		parsedJson = JSON.parse(sourceMapText);
+	} catch {
+		throw new Error(`Invalid SourceMap JSON: ${resolvedUrl}`);
+	}
+	return {
+		resolvedUrl,
+		map: normalizeSourceMap(parsedJson)
+	};
+}
+function normalizeSourceMap(value) {
+	const record = asRecord(value);
+	if (record.version !== 3) throw new Error("Only SourceMap version 3 is supported");
+	const mappings = asString(record.mappings);
+	if (mappings === void 0) throw new Error("SourceMap.mappings is required");
+	const sources = (Array.isArray(record.sources) ? record.sources : []).map((item) => asString(item)).filter((item) => typeof item === "string");
+	const names = (Array.isArray(record.names) ? record.names : []).map((item) => asString(item)).filter((item) => typeof item === "string");
+	const sourceRoot = asString(record.sourceRoot);
+	let sourcesContent;
+	if (Array.isArray(record.sourcesContent)) sourcesContent = record.sourcesContent.map((item) => typeof item === "string" ? item : null);
+	return {
+		version: 3,
+		sources,
+		sourcesContent,
+		mappings,
+		names,
+		sourceRoot
+	};
+}
+async function fetchSourceMapText(resolvedUrl, collector) {
+	validateFetchUrl(resolvedUrl);
+	{
+		const ac = new AbortController();
+		const t = setTimeout(() => ac.abort(), 1e4);
+		try {
+			const response = await fetch(resolvedUrl, { signal: ac.signal });
+			if (!response.ok) throw new Error(`HTTP ${response.status} ${response.statusText}`);
+			return await response.text();
+		} catch (err) {
+			if (err.name === "AbortError") throw new Error(`SourceMap fetch timed out after 10s: ${resolvedUrl}`, { cause: err });
+		} finally {
+			clearTimeout(t);
+		}
+	}
+	const fetched = await evaluateWithTimeout(await collector.getActivePage(), async (url) => {
+		const ac = new AbortController();
+		const t = setTimeout(() => ac.abort(), 1e4);
+		try {
+			const resp = await fetch(url, { signal: ac.signal });
+			if (!resp.ok) return `__FETCH_ERROR__HTTP ${resp.status} ${resp.statusText}`;
+			return await resp.text();
+		} catch (error) {
+			return `__FETCH_ERROR__${error instanceof Error ? error.message : String(error)}`;
+		} finally {
+			clearTimeout(t);
+		}
+	}, resolvedUrl);
+	if (typeof fetched !== "string") throw new Error("Failed to fetch SourceMap content");
+	if (fetched.startsWith("__FETCH_ERROR__")) throw new Error(fetched.slice(15) || "Failed to fetch SourceMap content");
+	return fetched;
+}
+function validateFetchUrl(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new Error(`Invalid URL: ${url}`);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`Blocked: unsupported protocol "${parsed.protocol}"`);
+	const hostname = parsed.hostname.toLowerCase();
+	const blockedPatterns = [
+		/^127\./,
+		/^10\./,
+		/^172\.(1[6-9]|2\d|3[01])\./,
+		/^192\.168\./,
+		/^0\./,
+		/^169\.254\./,
+		/^\[?::1\]?$/,
+		/^\[?fe80:/i,
+		/^\[?fc00:/i,
+		/^\[?fd/i
+	];
+	if ([
+		"localhost",
+		"metadata.google.internal",
+		"metadata"
+	].includes(hostname)) throw new Error(`SSRF blocked: hostname "${hostname}" is not allowed`);
+	for (const pattern of blockedPatterns) if (pattern.test(hostname)) throw new Error(`SSRF blocked: protected/reserved IP "${hostname}" is not allowed`);
+}
+function decodeDataUriJson(dataUri) {
+	const commaIndex = dataUri.indexOf(",");
+	if (commaIndex === -1) throw new Error("Invalid data URI source map");
+	const metadata = dataUri.slice(0, commaIndex);
+	const dataPart = dataUri.slice(commaIndex + 1);
+	if (/;base64/i.test(metadata)) return Buffer.from(dataPart, "base64").toString("utf-8");
+	return decodeURIComponent(dataPart);
+}
+function resolveSourceMapUrl(sourceMapUrl, scriptUrl) {
+	const trimmed = sourceMapUrl.trim();
+	if (!trimmed) return "";
+	if (trimmed.startsWith("data:")) return trimmed;
+	if (hasProtocol(trimmed)) return trimmed;
+	if (!scriptUrl) return trimmed;
+	try {
+		return new URL(trimmed, scriptUrl).toString();
+	} catch {
+		return trimmed;
+	}
+}
+function extractSourceMappingUrlFromScript(scriptSource) {
+	const tail = scriptSource.slice(-8192);
+	const regex = /(?:\/\/[@#]\s*sourceMappingURL=([^\s]+)|\/\*[@#]\s*sourceMappingURL=([^*]+)\*\/)/g;
+	let match;
+	let found = null;
+	while (true) {
+		match = regex.exec(tail);
+		if (!match) break;
+		const candidate = (match[1] ?? match[2] ?? "").trim();
+		if (candidate) found = candidate;
+	}
+	return found;
+}
+function combineSourceRoot(sourceRoot, sourcePath) {
+	if (!sourceRoot) return sourcePath;
+	if (!sourcePath) return sourceRoot;
+	if (hasProtocol(sourcePath) || sourcePath.startsWith("/")) return sourcePath;
+	if (hasProtocol(sourceRoot)) try {
+		const base = sourceRoot.endsWith("/") ? sourceRoot : `${sourceRoot}/`;
+		return new URL(sourcePath, base).toString();
+	} catch {
+		return `${sourceRoot.replace(/\/+$/g, "")}/${sourcePath.replace(/^\/+/g, "")}`;
+	}
+	return `${sourceRoot.replace(/\/+$/g, "")}/${sourcePath.replace(/^\/+/g, "")}`;
+}
+function normalizeSourcePath(sourcePath, index) {
+	let candidate = sourcePath.trim();
+	if (!candidate) return `source_${index + 1}.js`;
+	if (candidate.startsWith("webpack://")) candidate = candidate.slice(10);
+	if (candidate.startsWith("data:")) return `inline/source_${index + 1}.txt`;
+	if (hasProtocol(candidate)) try {
+		const parsed = new URL(candidate);
+		candidate = `${parsed.hostname}${parsed.pathname}`;
+	} catch {
+		candidate = candidate.replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//, "");
+	}
+	candidate = candidate.replace(/[?#].*$/g, "");
+	candidate = candidate.replace(/^[A-Za-z]:[\\/]/, "");
+	candidate = candidate.replace(/^\/+/, "");
+	const parts = candidate.split(/[\\/]+/).map((seg) => sanitizePathSegment(seg)).filter((seg) => seg !== "" && seg !== "." && seg !== "..");
+	if (parts.length === 0) return `source_${index + 1}.js`;
+	return parts.join("/");
+}
+function sanitizePathSegment(segment) {
+	const sanitized = Array.from(segment, (char) => {
+		const codePoint = char.codePointAt(0);
+		return codePoint !== void 0 && (codePoint <= 31 || "<>:\"|?*".includes(char)) ? "_" : char;
+	}).join("").replace(/\s+/g, " ").trim();
+	if (!sanitized || sanitized === "." || sanitized === "..") return "_";
+	return sanitized;
+}
+function safeTarget(value) {
+	return value.replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//, "").replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 48);
+}
+//#endregion
+//#region src/server/domains/sourcemap/handlers/sourcemap-handlers.ts
+/**
+* Main sourcemap sub-handler — discover, fetch/parse, reconstruct tree.
+*/
+function countScopeNodes(nodes) {
+	let count = 0;
+	for (const node of nodes) {
+		if (!node) continue;
+		count += 1 + countScopeNodes(node.children);
+	}
+	return count;
+}
+var SourcemapHandlers = class {
+	state;
+	constructor(state) {
+		this.state = state;
+	}
+	async handleSourcemapDiscover(args) {
+		const includeInline = parseBooleanArg(args.includeInline, true);
+		const session = await (await this.state.collector.getActivePage()).createCDPSession();
+		const scripts = /* @__PURE__ */ new Map();
+		const onScriptParsed = (payload) => {
+			const record = asRecord(payload);
+			const scriptId = asString(record.scriptId);
+			if (!scriptId) return;
+			const scriptUrl = asString(record.url) ?? "";
+			const sourceMapUrlRaw = asString(record.sourceMapURL) ?? "";
+			const existing = scripts.get(scriptId);
+			const sourceMapUrlResolved = sourceMapUrlRaw ? resolveSourceMapUrl(sourceMapUrlRaw, scriptUrl) : existing?.sourceMapUrl ?? "";
+			scripts.set(scriptId, {
+				scriptId,
+				scriptUrl: scriptUrl || existing?.scriptUrl || "",
+				sourceMapUrl: sourceMapUrlResolved,
+				isInline: sourceMapUrlResolved.startsWith("data:")
+			});
+		};
+		try {
+			session.on?.("Debugger.scriptParsed", onScriptParsed);
+			await session.send("Debugger.enable");
+			await delay(SOURCEMAP_V4_RETRY_DELAY_MS);
+			for (const item of scripts.values()) {
+				if (item.sourceMapUrl) continue;
+				if (!item.scriptId || !item.scriptUrl) continue;
+				try {
+					const scriptSource = asString(asRecord(await session.send("Debugger.getScriptSource", { scriptId: item.scriptId })).scriptSource);
+					if (!scriptSource) continue;
+					const extracted = extractSourceMappingUrlFromScript(scriptSource);
+					if (!extracted) continue;
+					const resolvedSourceMap = resolveSourceMapUrl(extracted, item.scriptUrl);
+					item.sourceMapUrl = resolvedSourceMap;
+					item.isInline = resolvedSourceMap.startsWith("data:");
+				} catch {
+					continue;
+				}
+			}
+			return json(Array.from(scripts.values()).filter((item) => item.sourceMapUrl.length > 0).filter((item) => includeInline || !item.isInline).toSorted((left, right) => {
+				const leftKey = `${left.scriptUrl}|${left.scriptId}`;
+				const rightKey = `${right.scriptUrl}|${right.scriptId}`;
+				return leftKey.localeCompare(rightKey);
+			}).map((item) => ({
+				scriptUrl: item.scriptUrl,
+				sourceMapUrl: item.sourceMapUrl,
+				isInline: item.isInline,
+				scriptId: item.scriptId
+			})));
+		} catch (error) {
+			return fail("sourcemap_discover", error);
+		} finally {
+			session.off?.("Debugger.scriptParsed", onScriptParsed);
+			await trySend(session, "Debugger.disable");
+			await safeDetach(session);
+		}
+	}
+	async handleSourcemapFetchAndParse(args) {
+		try {
+			const parsed = await parseSourceMap(requiredStringArg(args.sourceMapUrl, "sourceMapUrl"), optionalStringArg(args.scriptUrl), this.state.collector);
+			const responsePayload = {
+				sources: parsed.map.sources,
+				mappingsCount: parsed.mappingsCount,
+				segmentCount: parsed.segmentCount
+			};
+			if (Array.isArray(parsed.map.sourcesContent)) responsePayload.sourcesContent = parsed.map.sourcesContent;
+			return json(responsePayload);
+		} catch (error) {
+			return fail("sourcemap_fetch_and_parse", error);
+		}
+	}
+	async handleSourcemapReconstructTree(args) {
+		try {
+			const sourceMapUrl = requiredStringArg(args.sourceMapUrl, "sourceMapUrl");
+			const outputDir = optionalStringArg(args.outputDir);
+			const parsed = await parseSourceMapStats(sourceMapUrl, void 0, this.state.collector);
+			const artifactPath = await resolveArtifactPath({
+				category: "reports",
+				toolName: "sourcemap-tree",
+				target: safeTarget(parsed.resolvedUrl),
+				ext: "tmp",
+				...outputDir ? { customDir: outputDir } : {}
+			});
+			const outputRoot = artifactPath.absolutePath.replace(/\.tmp$/i, "");
+			const outputRootDisplay = artifactPath.displayPath.replace(/\.tmp$/i, "");
+			await mkdir(outputRoot, { recursive: true });
+			const writtenFiles = [];
+			let skippedFiles = 0;
+			for (let index = 0; index < parsed.map.sources.length; index += 1) {
+				const rawSourcePath = parsed.map.sources[index] ?? "";
+				const sourcePath = combineSourceRoot(parsed.map.sourceRoot, rawSourcePath);
+				const relativePath = normalizeSourcePath(sourcePath, index);
+				const absolutePath = resolve(outputRoot, relativePath);
+				const sourceContent = parsed.map.sourcesContent && index < parsed.map.sourcesContent.length ? parsed.map.sourcesContent[index] : null;
+				const fileContent = typeof sourceContent === "string" ? sourceContent : `/* source content missing in source map: ${sourcePath} */\n`;
+				try {
+					await mkdir(dirname(absolutePath), { recursive: true });
+					await writeFile(absolutePath, fileContent, "utf-8");
+					writtenFiles.push(relativePath);
+				} catch {
+					skippedFiles += 1;
+				}
+			}
+			return json({
+				outputDir: outputRootDisplay,
+				totalSources: parsed.map.sources.length,
+				writtenFiles: writtenFiles.length,
+				skippedFiles,
+				files: writtenFiles
+			});
+		} catch (error) {
+			return fail("sourcemap_reconstruct_tree", error);
+		}
+	}
+	async handleSourcemapParseV4(args) {
+		const sourceMapUrl = requiredStringArg(args.sourceMapUrl, "sourceMapUrl");
+		const extractScopes = parseBooleanArg(args.extractScopes, true);
+		const extractDebugIds = parseBooleanArg(args.extractDebugIds, true);
+		try {
+			const raw = await fetchSourceMapText(sourceMapUrl, this.state.collector);
+			const parsed = JSON.parse(raw);
+			const names = Array.isArray(parsed.names) ? parsed.names.filter((x) => typeof x === "string") : [];
+			const sources = Array.isArray(parsed.sources) ? parsed.sources.filter((x) => typeof x === "string") : [];
+			const v3Baseline = {
+				version: parsed.version,
+				sources: sources.length,
+				names: names.length,
+				mappings: typeof parsed.mappings === "string" ? parsed.mappings.length : 0,
+				hasFile: typeof parsed.file === "string",
+				hasSourceRoot: typeof parsed.sourceRoot === "string"
+			};
+			const result = {
+				success: true,
+				sourceMapUrl,
+				version: parsed.version,
+				v3Baseline
+			};
+			if (extractDebugIds && typeof parsed.debugId === "string") {
+				const debugIdValid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(parsed.debugId);
+				result.debugId = parsed.debugId;
+				result.debugIdValid = debugIdValid;
+			}
+			const scopesField = typeof parsed.scopes === "string" ? parsed.scopes : typeof parsed.x_scopes === "string" ? parsed.x_scopes : void 0;
+			if (extractScopes && scopesField) try {
+				const decoded = decodeScopesField(scopesField, names, sources);
+				result.isV4 = true;
+				result.scopes = decoded;
+				result.scopeCount = countScopeNodes(decoded.originalScopes);
+				result.generatedRangeCount = decoded.generatedRanges.length;
+			} catch (scopeError) {
+				result.success = false;
+				result.scopeDecodeError = scopeError instanceof Error ? scopeError.message : String(scopeError);
+				result.rawScopesField = scopesField.substring(0, SOURCEMAP_V4_RAW_FIELD_MAX_LEN) + (scopesField.length > SOURCEMAP_V4_RAW_FIELD_MAX_LEN ? "..." : "");
+				result.isV4 = true;
+			}
+			const extensions = {};
+			if (parsed.x_scopeLines) extensions.x_scopeLines = parsed.x_scopeLines;
+			if (parsed.x_namesIdx) extensions.x_namesIdx = parsed.x_namesIdx;
+			if (parsed.x_computedBases) extensions.x_computedBases = parsed.x_computedBases;
+			if (Object.keys(extensions).length > 0) result.extensions = extensions;
+			if (!scopesField && !parsed.debugId && Object.keys(extensions).length === 0) {
+				result.isV4 = false;
+				result.note = "No v4 fields (scopes/debugId) found. This source map is v3 only.";
+			}
+			if (args.compareV3 === true) result.comparison = {
+				v3Only: [
+					"version",
+					"sources",
+					"names",
+					"mappings",
+					"file",
+					"sourceRoot"
+				],
+				v4Only: Object.keys(result).filter((k) => ![
+					"success",
+					"sourceMapUrl",
+					"version",
+					"v3Baseline",
+					"comparison"
+				].includes(k))
+			};
+			return json(result);
+		} catch (error) {
+			return fail("sourcemap_parse_v4", error);
+		}
+	}
+};
+function decodeScopesField(scopesText, names, sources) {
+	const items = scopesText.split(",");
+	const idx = { value: 0 };
+	const originalByStartIndex = [];
+	let previousOriginalName = 0;
+	let previousOriginalKind = 0;
+	let previousOriginalVariable = 0;
+	let previousGeneratedLine = 0;
+	let previousGeneratedColumn = 0;
+	let previousDefinition = 0;
+	const readName = (absoluteIndex1Based) => absoluteIndex1Based > 0 && absoluteIndex1Based <= names.length ? names[absoluteIndex1Based - 1] : void 0;
+	function safeItem(index) {
+		return index >= 0 && index < items.length ? items[index] : void 0;
+	}
+	function parseOriginalTree(sourceIndex, previousPos) {
+		const startItem = safeItem(idx.value++);
+		if (!startItem?.startsWith("B")) throw new Error(`expected original scope start 'B', got "${startItem}"`);
+		const rawUnsigned = decodeVlqSegmentUnsigned(startItem.slice(1));
+		const rawSigned = decodeVlqSegment(startItem.slice(1));
+		let p = 0;
+		const flags = rawUnsigned[p++] ?? 0;
+		const line = previousPos.line + (rawUnsigned[p++] ?? 0);
+		const columnRaw = rawUnsigned[p++] ?? 0;
+		const column = line === previousPos.line ? previousPos.column + columnRaw : columnRaw;
+		let name;
+		if ((flags & 1) !== 0) {
+			previousOriginalName += rawSigned[p++] ?? 0;
+			name = names[previousOriginalName];
+		}
+		let kind;
+		if ((flags & 2) !== 0) {
+			previousOriginalKind += rawSigned[p++] ?? 0;
+			kind = names[previousOriginalKind];
+		}
+		const node = {
+			index: originalByStartIndex.length,
+			sourceIndex,
+			start: {
+				line,
+				column
+			},
+			end: {
+				line,
+				column
+			},
+			name,
+			kind,
+			isStackFrame: (flags & 4) !== 0,
+			variables: [],
+			children: []
+		};
+		originalByStartIndex.push(node);
+		let cursorPos = {
+			line,
+			column
+		};
+		while (idx.value < items.length) {
+			const item = items[idx.value] ?? "";
+			if (item.startsWith("D")) {
+				idx.value++;
+				const vars = decodeVlqSegment(item.slice(1));
+				for (const rawVar of vars) {
+					previousOriginalVariable += rawVar;
+					node.variables.push(names[previousOriginalVariable] ?? `<name:${previousOriginalVariable}>`);
+				}
+				continue;
+			}
+			if (item.startsWith("B")) {
+				const child = parseOriginalTree(sourceIndex, cursorPos);
+				cursorPos = { ...child.end };
+				node.children.push(child);
+				continue;
+			}
+			break;
+		}
+		const endItem = safeItem(idx.value++);
+		if (!endItem?.startsWith("C")) throw new Error(`expected original scope end 'C', got "${endItem}"`);
+		const endRaw = decodeVlqSegmentUnsigned(endItem.slice(1));
+		const endLine = cursorPos.line + (endRaw[0] ?? 0);
+		const endColumnRaw = endRaw[1] ?? 0;
+		node.end = {
+			line: endLine,
+			column: endLine === cursorPos.line ? cursorPos.column + endColumnRaw : endColumnRaw
+		};
+		return node;
+	}
+	function parseGeneratedTree(previousPos) {
+		const startItem = safeItem(idx.value++);
+		if (!startItem?.startsWith("E")) throw new Error(`expected generated range start 'E', got "${startItem}"`);
+		const rawUnsigned = decodeVlqSegmentUnsigned(startItem.slice(1));
+		const rawSigned = decodeVlqSegment(startItem.slice(1));
+		let p = 0;
+		const flags = rawUnsigned[p++] ?? 0;
+		const hasLine = (flags & 1) !== 0;
+		const line = previousPos.line + (hasLine ? rawUnsigned[p++] ?? 0 : 0);
+		const columnRaw = rawUnsigned[p++] ?? 0;
+		const column = line === previousPos.line ? previousPos.column + columnRaw : columnRaw;
+		let definitionIndex;
+		if ((flags & 2) !== 0) {
+			previousDefinition += rawSigned[p++] ?? 0;
+			definitionIndex = previousDefinition;
+		}
+		const node = {
+			start: {
+				line,
+				column
+			},
+			end: {
+				line,
+				column
+			},
+			isStackFrame: (flags & 4) !== 0,
+			isHidden: (flags & 8) !== 0,
+			definitionIndex,
+			children: []
+		};
+		const subrangeState = /* @__PURE__ */ new Map();
+		let previousVariableIndex = 0;
+		let cursorPos = {
+			line,
+			column
+		};
+		while (idx.value < items.length) {
+			const item = items[idx.value] ?? "";
+			if (item.startsWith("G")) {
+				idx.value++;
+				node.bindings = decodeVlqSegmentUnsigned(item.slice(1)).map((v) => readName(v));
+				continue;
+			}
+			if (item.startsWith("H")) {
+				idx.value++;
+				const sub = decodeVlqSegmentUnsigned(item.slice(1));
+				if (!node.bindings) node.bindings = [];
+				let s = 0;
+				previousVariableIndex += sub[s++] ?? 0;
+				const variableIndex = previousVariableIndex;
+				const ranges = [];
+				let prev = subrangeState.get(variableIndex) ?? {
+					line: node.start.line,
+					column: node.start.column
+				};
+				while (s < sub.length) {
+					const expr = readName(sub[s++] ?? 0);
+					const lineDelta = sub[s++] ?? 0;
+					const nextLine = prev.line + lineDelta;
+					const colRaw = sub[s++] ?? 0;
+					const nextColumn = nextLine === prev.line ? prev.column + colRaw : colRaw;
+					ranges.push({
+						from: {
+							line: nextLine,
+							column: nextColumn
+						},
+						expression: expr
+					});
+					prev = {
+						line: nextLine,
+						column: nextColumn
+					};
+				}
+				subrangeState.set(variableIndex, prev);
+				while (node.bindings.length <= variableIndex) node.bindings.push(void 0);
+				node.bindings[variableIndex] = ranges;
+				continue;
+			}
+			if (item.startsWith("I")) {
+				idx.value++;
+				const cs = decodeVlqSegmentUnsigned(item.slice(1));
+				node.callsite = {
+					sourceIndex: cs[0] ?? 0,
+					line: cs[1] ?? 0,
+					column: cs[2] ?? 0
+				};
+				continue;
+			}
+			if (item.startsWith("E")) {
+				const child = parseGeneratedTree(cursorPos);
+				cursorPos = { ...child.end };
+				node.children.push(child);
+				continue;
+			}
+			break;
+		}
+		const endItem = safeItem(idx.value++);
+		if (!endItem?.startsWith("F")) throw new Error(`expected generated range end 'F', got "${endItem}"`);
+		const endRaw = decodeVlqSegmentUnsigned(endItem.slice(1));
+		const endHasLine = endRaw.length === 2;
+		const endLine = cursorPos.line + (endHasLine ? endRaw[0] ?? 0 : 0);
+		const endColumnRaw = endRaw[endHasLine ? 1 : 0] ?? 0;
+		const endColumn = endLine === cursorPos.line ? cursorPos.column + endColumnRaw : endColumnRaw;
+		node.end = {
+			line: endLine,
+			column: endColumn
+		};
+		previousGeneratedLine = endLine;
+		previousGeneratedColumn = endColumn;
+		return node;
+	}
+	const originalScopes = Array.from({ length: sources.length }, () => null);
+	for (let sourceIndex = 0; sourceIndex < sources.length && idx.value < items.length; sourceIndex++) {
+		if ((items[idx.value] ?? "") === "") {
+			idx.value++;
+			continue;
+		}
+		if (!(items[idx.value] ?? "").startsWith("B")) break;
+		originalScopes[sourceIndex] = parseOriginalTree(sourceIndex, {
+			line: 0,
+			column: 0
+		});
+		if ((items[idx.value] ?? "") === "") idx.value++;
+	}
+	const generatedRanges = [];
+	while (idx.value < items.length) {
+		if ((items[idx.value] ?? "") === "") {
+			idx.value++;
+			continue;
+		}
+		generatedRanges.push(parseGeneratedTree({
+			line: previousGeneratedLine,
+			column: previousGeneratedColumn
+		}));
+	}
+	return {
+		originalScopes,
+		generatedRanges
+	};
+}
+//#endregion
+//#region src/server/domains/sourcemap/handlers.impl.core.ts
+var SourcemapToolHandlers = class {
+	collector;
+	extension;
+	sourcemap;
+	constructor(collector) {
+		this.collector = collector;
+		const state = { collector };
+		this.extension = new ExtensionHandlers(state);
+		this.sourcemap = new SourcemapHandlers(state);
+	}
+	handleExtensionListInstalled(args) {
+		return this.extension.handleExtensionListInstalled(args);
+	}
+	handleExtensionExecuteInContext(args) {
+		return this.extension.handleExtensionExecuteInContext(args);
+	}
+	handleSourcemapDiscover(args) {
+		return this.sourcemap.handleSourcemapDiscover(args);
+	}
+	handleSourcemapFetchAndParse(args) {
+		return this.sourcemap.handleSourcemapFetchAndParse(args);
+	}
+	handleSourcemapReconstructTree(args) {
+		return this.sourcemap.handleSourcemapReconstructTree(args);
+	}
+	handleSourcemapParseV4(args) {
+		return this.sourcemap.handleSourcemapParseV4(args);
+	}
+};
+//#endregion
+export { SourcemapToolHandlers };