@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/sourcemap-Dq8ez8vS.mjs

@@ -0,0 +1,650 @@
+import { tr as SOURCEMAP_EXT_TIMEOUT_MS } from "./constants-B0OANIBL.mjs";
+import { i as resolveArtifactPath } from "./artifacts-Bk2-_uPq.mjs";
+import { s as evaluateWithTimeout } from "./PageController-Bqm2kZ_X.mjs";
+import "./definitions-LKpC3-nL.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 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
+/**
+* Extension-related sub-handler for sourcemap domain.
+*/
+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 attachedSessionId = "";
+		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);
+			attachedSessionId = requiredStringArg(asRecord(await session.send("Target.attachToTarget", {
+				targetId: preferred.targetId,
+				flatten: true
+			})).sessionId, "sessionId");
+			const evaluation = await this.evaluateInAttachedTarget(session, attachedSessionId, 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 (attachedSessionId) await trySend(session, "Target.detachFromTarget", { sessionId: attachedSessionId });
+			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, sessionId, code, returnByValue) {
+		if (!session.on) throw new Error("CDP session does not support event listeners");
+		const commandId = Date.now() % 1e9;
+		const commandMessage = JSON.stringify({
+			id: commandId,
+			method: "Runtime.evaluate",
+			params: {
+				expression: code,
+				returnByValue,
+				awaitPromise: true
+			}
+		});
+		const responseMessage = await new Promise((resolvePromise, rejectPromise) => {
+			const timeout = setTimeout(() => {
+				cleanup();
+				rejectPromise(/* @__PURE__ */ new Error("Runtime.evaluate timed out"));
+			}, SOURCEMAP_EXT_TIMEOUT_MS);
+			const onMessage = (payload) => {
+				const record = asRecord(payload);
+				if (asString(record.sessionId) !== sessionId) return;
+				const rawMessage = asString(record.message);
+				if (!rawMessage) return;
+				let parsed;
+				try {
+					parsed = JSON.parse(rawMessage);
+				} catch {
+					return;
+				}
+				const parsedRecord = asRecord(parsed);
+				if (parsedRecord.id !== commandId) return;
+				cleanup();
+				resolvePromise(parsedRecord);
+			};
+			const cleanup = () => {
+				clearTimeout(timeout);
+				session.off?.("Target.receivedMessageFromTarget", onMessage);
+			};
+			session.on?.("Target.receivedMessageFromTarget", onMessage);
+			session.send("Target.sendMessageToTarget", {
+				sessionId,
+				message: commandMessage
+			}).catch((error) => {
+				cleanup();
+				rejectPromise(error);
+			});
+		});
+		const errorRecord = asRecord(responseMessage.error);
+		if (Object.keys(errorRecord).length > 0) throw new Error(asString(errorRecord.message) ?? asString(errorRecord.data) ?? "Runtime.evaluate failed");
+		const resultEnvelope = asRecord(responseMessage.result);
+		return {
+			result: resultEnvelope.result !== void 0 ? resultEnvelope.result : null,
+			exceptionDetails: resultEnvelope.exceptionDetails !== void 0 ? resultEnvelope.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.
+*/
+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(250);
+			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);
+		}
+	}
+};
+//#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);
+	}
+};
+//#endregion
+export { SourcemapToolHandlers };