@jshookmcp/jshook 0.2.9 → 0.3.1

package/dist/sourcemap-Dq8ez8vS.mjs

@@ -1,650 +0,0 @@
-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 };