foresthouse 1.1.0 → 1.2.0-dev.1

package/dist/{react-xFA5HmqF.mjs → react-D0TO9XR2.mjs}

@@ -1,5 +1,5 @@
 import { builtinModules } from "node:module";
-import { execFileSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -363,11 +363,12 @@ function parsePnpmVersion(value) {
 //#region src/analyzers/deps/diff.ts
 const PNPM_LOCKFILE = "pnpm-lock.yaml";
 const PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
+const GIT_EXEC_MAX_BUFFER$1 = 64 * 1024 * 1024;
 function analyzePackageDependencyDiff(directory, diff) {
 	const resolvedInputPath = path.resolve(process.cwd(), directory);
-	const repositoryRoot = findGitRepositoryRoot(resolvedInputPath);
+	const repositoryRoot = findGitRepositoryRoot$1(resolvedInputPath);
 	const inputPathWithinRepository = resolveRepositoryInputPath(resolvedInputPath, repositoryRoot);
-	const comparison = resolveGitDiffComparison(repositoryRoot, diff);
+	const comparison = resolveGitDiffComparison$1(repositoryRoot, diff);
 	const beforeGraph = loadGitTreeGraph(repositoryRoot, comparison.beforeTree, inputPathWithinRepository);
 	const afterGraph = comparison.afterTree === void 0 ? loadWorkingTreeGraph(repositoryRoot, inputPathWithinRepository) : loadGitTreeGraph(repositoryRoot, comparison.afterTree, inputPathWithinRepository);
 	if (beforeGraph === void 0 && afterGraph === void 0) throw new Error(`No package.json found from ${resolvedInputPath}`);
@@ -382,7 +383,7 @@ function analyzePackageDependencyDiff(directory, diff) {
 	};
 }
 function resolveRepositoryInputPath(resolvedInputPath, repositoryRoot) {
-	const existingPath = findNearestExistingPath(resolvedInputPath);
+	const existingPath = findNearestExistingPath$1(resolvedInputPath);
 	const existingRealPath = fs.realpathSync.native(existingPath);
 	const repositoryRealPath = fs.realpathSync.native(repositoryRoot);
 	const relativeFromExistingPath = path.relative(existingPath, resolvedInputPath);
@@ -390,15 +391,15 @@ function resolveRepositoryInputPath(resolvedInputPath, repositoryRoot) {
 	const normalizedPath = path.normalize(path.join(relativeToRepository, relativeFromExistingPath));
 	return normalizedPath === "." ? "" : normalizedPath;
 }
-function findGitRepositoryRoot(resolvedInputPath) {
-	const searchPath = findNearestExistingPath(resolvedInputPath);
+function findGitRepositoryRoot$1(resolvedInputPath) {
+	const searchPath = findNearestExistingPath$1(resolvedInputPath);
 	try {
-		return runGit(searchPath, ["rev-parse", "--show-toplevel"]).trim();
+		return runGit$1(searchPath, ["rev-parse", "--show-toplevel"]).trim();
 	} catch (error) {
-		throw new Error(`Git diff mode requires a Git repository: ${getCommandErrorMessage(error)}`);
+		throw new Error(`Git diff mode requires a Git repository: ${getCommandErrorMessage$1(error)}`);
 	}
 }
-function findNearestExistingPath(resolvedInputPath) {
+function findNearestExistingPath$1(resolvedInputPath) {
 	let currentPath = resolvedInputPath;
 	while (!fs.existsSync(currentPath)) {
 		const parentPath = path.dirname(currentPath);
@@ -408,49 +409,49 @@ function findNearestExistingPath(resolvedInputPath) {
 	if (fs.statSync(currentPath).isFile()) return path.dirname(currentPath);
 	return currentPath;
 }
-function resolveGitDiffComparison(repositoryRoot, diff) {
+function resolveGitDiffComparison$1(repositoryRoot, diff) {
 	if (diff.includes("...")) {
-		const [baseRef, headRef] = splitDiffRange(diff, "...");
+		const [baseRef, headRef] = splitDiffRange$1(diff, "...");
 		try {
 			return {
-				beforeTree: resolveGitTree(repositoryRoot, runGit(repositoryRoot, [
+				beforeTree: resolveGitTree$1(repositoryRoot, runGit$1(repositoryRoot, [
 					"merge-base",
 					baseRef,
 					headRef
 				]).trim()),
-				afterTree: resolveGitTree(repositoryRoot, headRef)
+				afterTree: resolveGitTree$1(repositoryRoot, headRef)
 			};
 		} catch (error) {
-			throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+			throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage$1(error)}`);
 		}
 	}
 	if (diff.includes("..")) {
-		const [beforeRef, afterRef] = splitDiffRange(diff, "..");
+		const [beforeRef, afterRef] = splitDiffRange$1(diff, "..");
 		try {
 			return {
-				beforeTree: resolveGitTree(repositoryRoot, beforeRef),
-				afterTree: resolveGitTree(repositoryRoot, afterRef)
+				beforeTree: resolveGitTree$1(repositoryRoot, beforeRef),
+				afterTree: resolveGitTree$1(repositoryRoot, afterRef)
 			};
 		} catch (error) {
-			throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+			throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage$1(error)}`);
 		}
 	}
 	try {
 		return {
-			beforeTree: resolveGitTree(repositoryRoot, diff),
+			beforeTree: resolveGitTree$1(repositoryRoot, diff),
 			afterTree: void 0
 		};
 	} catch (error) {
-		throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+		throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage$1(error)}`);
 	}
 }
-function splitDiffRange(diff, separator) {
+function splitDiffRange$1(diff, separator) {
 	const [left, right, ...extra] = diff.split(separator);
 	if (left === void 0 || right === void 0 || left.length === 0 || right.length === 0 || extra.length > 0) throw new Error(`Invalid Git diff spec \`${diff}\``);
 	return [left, right];
 }
-function resolveGitTree(repositoryRoot, reference) {
-	return runGit(repositoryRoot, [
+function resolveGitTree$1(repositoryRoot, reference) {
+	return runGit$1(repositoryRoot, [
 		"rev-parse",
 		"--verify",
 		`${reference}^{tree}`
@@ -458,13 +459,13 @@ function resolveGitTree(repositoryRoot, reference) {
 }
 function loadWorkingTreeGraph(repositoryRoot, inputPathWithinRepository) {
 	const packageGraph = tryAnalyzePackageGraph(resolveSnapshotInputPath(repositoryRoot, inputPathWithinRepository));
-	return packageGraph === void 0 ? void 0 : toComparableGraph(packageGraph);
+	return packageGraph === void 0 ? void 0 : toComparableGraph$1(packageGraph);
 }
 function loadGitTreeGraph(repositoryRoot, tree, inputPathWithinRepository) {
-	const snapshotRoot = materializeGitTreeSnapshot(repositoryRoot, tree);
+	const snapshotRoot = materializeGitTreeSnapshot$1(repositoryRoot, tree);
 	try {
 		const packageGraph = tryAnalyzePackageGraph(resolveSnapshotInputPath(snapshotRoot, inputPathWithinRepository));
-		return packageGraph === void 0 ? void 0 : toComparableGraph(packageGraph);
+		return packageGraph === void 0 ? void 0 : toComparableGraph$1(packageGraph);
 	} finally {
 		fs.rmSync(snapshotRoot, {
 			recursive: true,
@@ -472,9 +473,9 @@ function loadGitTreeGraph(repositoryRoot, tree, inputPathWithinRepository) {
 		});
 	}
 }
-function materializeGitTreeSnapshot(repositoryRoot, tree) {
+function materializeGitTreeSnapshot$1(repositoryRoot, tree) {
 	const snapshotRoot = fs.mkdtempSync(path.join(os.tmpdir(), "foresthouse-deps-diff-"));
-	const trackedFiles = runGit(repositoryRoot, [
+	const trackedFiles = runGit$1(repositoryRoot, [
 		"ls-tree",
 		"-r",
 		"-z",
@@ -485,7 +486,7 @@ function materializeGitTreeSnapshot(repositoryRoot, tree) {
 		ensureSnapshotDirectory(snapshotRoot, filePath);
 	});
 	trackedFiles.filter(isManifestSnapshotFile).forEach((filePath) => {
-		const fileContent = runGit(repositoryRoot, [
+		const fileContent = runGit$1(repositoryRoot, [
 			"cat-file",
 			"-p",
 			`${tree}:${filePath}`
@@ -517,7 +518,7 @@ function tryAnalyzePackageGraph(inputPath) {
 		throw error;
 	}
 }
-function toComparableGraph(graph) {
+function toComparableGraph$1(graph) {
 	const pnpmLockResolutions = loadPnpmLockImporterResolutions(graph.repositoryRoot);
 	const nodes = /* @__PURE__ */ new Map();
 	graph.nodes.forEach((node, packageDir) => {
@@ -708,13 +709,13 @@ function collectChangedPackagePaths(repositoryRoot, comparison, beforeGraph, aft
 	return changedPackagePaths;
 }
 function listChangedRepositoryPaths(repositoryRoot, comparison) {
-	const trackedChanges = comparison.afterTree === void 0 ? runGit(repositoryRoot, [
+	const trackedChanges = comparison.afterTree === void 0 ? runGit$1(repositoryRoot, [
 		"diff",
 		"--name-only",
 		"-z",
 		comparison.beforeTree,
 		"--"
-	]) : runGit(repositoryRoot, [
+	]) : runGit$1(repositoryRoot, [
 		"diff",
 		"--name-only",
 		"-z",
@@ -722,7 +723,7 @@ function listChangedRepositoryPaths(repositoryRoot, comparison) {
 		comparison.afterTree
 	]);
 	const changedPaths = new Set(trackedChanges.split("\0").filter((filePath) => filePath.length > 0));
-	if (comparison.afterTree === void 0) runGit(repositoryRoot, [
+	if (comparison.afterTree === void 0) runGit$1(repositoryRoot, [
 		"ls-files",
 		"--others",
 		"--exclude-standard",
@@ -736,13 +737,14 @@ function isFileInPackage(filePath, packagePath) {
 	if (packagePath === ".") return true;
 	return filePath === packagePath || filePath.startsWith(`${packagePath}/`);
 }
-function runGit(repositoryRoot, args, options = {}) {
+function runGit$1(repositoryRoot, args, options = {}) {
 	const output = execFileSync("git", [
 		"-C",
 		repositoryRoot,
 		...args
 	], {
 		encoding: "utf8",
+		maxBuffer: GIT_EXEC_MAX_BUFFER$1,
 		stdio: [
 			"ignore",
 			"pipe",
@@ -751,7 +753,7 @@ function runGit(repositoryRoot, args, options = {}) {
 	});
 	return options.trim === false ? output : output.trimEnd();
 }
-function getCommandErrorMessage(error) {
+function getCommandErrorMessage$1(error) {
 	if (!(error instanceof Error)) return "Unknown Git error";
 	const stderr = Reflect.get(error, "stderr");
 	if (typeof stderr === "string" && stderr.trim().length > 0) return stderr.trim();
@@ -1523,6 +1525,67 @@ var MultiEntryImportAnalyzer = class extends BaseAnalyzer {
 	}
 };
 //#endregion
+//#region src/app/react-entry-files.ts
+const NEXT_JS_ENTRY_ROOTS = [
+	"pages",
+	"app",
+	path.join("src", "pages"),
+	path.join("src", "app")
+];
+function resolveReactEntryFiles(options) {
+	if (options.entryFile !== void 0) return [options.entryFile];
+	if (!options.nextjs) throw new Error("Missing React entry file. Use `foresthouse react <entry-file>` or `foresthouse react --nextjs`.");
+	return discoverNextJsPageEntries(options.cwd);
+}
+function discoverNextJsPageEntries(cwd) {
+	const effectiveCwd = path.resolve(cwd ?? process.cwd());
+	const entries = /* @__PURE__ */ new Set();
+	collectPagesRouterEntries(path.join(effectiveCwd, "pages"), effectiveCwd, entries);
+	collectAppRouterEntries(path.join(effectiveCwd, "app"), effectiveCwd, entries);
+	collectPagesRouterEntries(path.join(effectiveCwd, "src", "pages"), effectiveCwd, entries);
+	collectAppRouterEntries(path.join(effectiveCwd, "src", "app"), effectiveCwd, entries);
+	const resolvedEntries = [...entries].sort();
+	if (resolvedEntries.length > 0) return resolvedEntries;
+	const searchedRoots = NEXT_JS_ENTRY_ROOTS.map((root) => `\`${root}/\``).join(", ");
+	throw new Error(`No Next.js page entries found. Searched ${searchedRoots} relative to ${effectiveCwd}.`);
+}
+function collectPagesRouterEntries(rootDirectory, cwd, entries) {
+	walkDirectory(rootDirectory, (filePath, relativePath) => {
+		if (!isSourceCodeFile(filePath) || filePath.endsWith(".d.ts")) return;
+		if (relativePath.split(path.sep)[0] === "api") return;
+		if (path.basename(filePath).startsWith("_")) return;
+		entries.add(path.relative(cwd, filePath));
+	});
+}
+function collectAppRouterEntries(rootDirectory, cwd, entries) {
+	walkDirectory(rootDirectory, (filePath) => {
+		if (!isSourceCodeFile(filePath) || filePath.endsWith(".d.ts")) return;
+		const extension = path.extname(filePath);
+		if (path.basename(filePath, extension) !== "page") return;
+		entries.add(path.relative(cwd, filePath));
+	});
+}
+function walkDirectory(rootDirectory, visitor) {
+	if (!fs.existsSync(rootDirectory)) return;
+	const stack = [rootDirectory];
+	while (stack.length > 0) {
+		const directory = stack.pop();
+		if (directory === void 0) continue;
+		const directoryEntries = fs.readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+		for (let index = directoryEntries.length - 1; index >= 0; index -= 1) {
+			const entry = directoryEntries[index];
+			if (entry === void 0) continue;
+			const entryPath = path.join(directory, entry.name);
+			if (entry.isDirectory()) {
+				stack.push(entryPath);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			visitor(entryPath, path.relative(rootDirectory, entryPath));
+		}
+	}
+}
+//#endregion
 //#region src/analyzers/react/bindings.ts
 function collectImportsAndExports(statement, sourceDependencies, symbolsByName, importsByLocalName, exportsByName, reExportBindingsByName, exportAllBindings) {
 	switch (statement.type) {
@@ -1536,7 +1599,7 @@ function collectImportsAndExports(statement, sourceDependencies, symbolsByName,
 			collectExportAllBindings(statement, sourceDependencies, exportAllBindings);
 			return;
 		case "ExportDefaultDeclaration":
-			collectDefaultExport(statement, symbolsByName, exportsByName);
+			collectDefaultExport(statement, symbolsByName, importsByLocalName, exportsByName, reExportBindingsByName);
 			return;
 		default: return;
 	}
@@ -1571,6 +1634,12 @@ function getImportBinding(specifier, sourceSpecifier, sourcePath) {
 		sourceSpecifier,
 		...sourcePath === void 0 ? {} : { sourcePath }
 	};
+	if (specifier.type === "ImportNamespaceSpecifier") return {
+		localName: specifier.local.name,
+		importedName: "*",
+		sourceSpecifier,
+		...sourcePath === void 0 ? {} : { sourcePath }
+	};
 }
 function collectNamedExports(declaration, sourceDependencies, symbolsByName, exportsByName, reExportBindingsByName) {
 	if (declaration.exportKind === "type") return;
@@ -1611,14 +1680,19 @@ function collectExportAllBindings(declaration, sourceDependencies, exportAllBind
 		...sourcePath === void 0 ? {} : { sourcePath }
 	});
 }
-function collectDefaultExport(declaration, symbolsByName, exportsByName) {
+function collectDefaultExport(declaration, symbolsByName, importsByLocalName, exportsByName, reExportBindingsByName) {
 	if (declaration.declaration.type === "FunctionDeclaration" || declaration.declaration.type === "FunctionExpression") {
 		const localName = declaration.declaration.id?.name;
 		if (localName !== void 0) addExportBinding(localName, "default", symbolsByName, exportsByName);
 		return;
 	}
 	if (declaration.declaration.type === "Identifier") {
-		addExportBinding(declaration.declaration.name, "default", symbolsByName, exportsByName);
+		const localName = declaration.declaration.name;
+		addExportBinding(localName, "default", symbolsByName, exportsByName);
+		if (!exportsByName.has("default")) {
+			const importBinding = importsByLocalName.get(localName);
+			if (importBinding !== void 0) reExportBindingsByName.set("default", importBinding);
+		}
 		return;
 	}
 	if (declaration.declaration.type === "ArrowFunctionExpression") addExportBinding("default", "default", symbolsByName, exportsByName);
@@ -1682,6 +1756,14 @@ function getComponentReferenceName(node) {
 	const name = getJsxName(node.openingElement.name);
 	return name !== void 0 && isComponentName(name) ? name : void 0;
 }
+function getMemberExpressionComponentReferenceName(node) {
+	const name = node.openingElement.name;
+	if (name.type !== "JSXMemberExpression") return;
+	if (name.object.type !== "JSXIdentifier") return;
+	const objectName = name.object.name;
+	const propertyName = name.property.name;
+	if (isComponentName(objectName)) return `${objectName}.${propertyName}`;
+}
 function getBuiltinReferenceName(node) {
 	const name = getJsxName(node.openingElement.name);
 	return name !== void 0 && isIntrinsicElementName(name) ? name : void 0;
@@ -1796,7 +1878,7 @@ function collectNodeEntryUsages(node, filePath, sourceText, entries, includeBuil
 	if (FUNCTION_NODE_TYPES.has(node.type)) return;
 	let nextHasComponentAncestor = hasComponentAncestor;
 	if (node.type === "JSXElement") {
-		const referenceName = getComponentReferenceName(node);
+		const referenceName = getComponentReferenceName(node) ?? getMemberExpressionComponentReferenceName(node);
 		if (referenceName !== void 0) {
 			if (!hasComponentAncestor) addPendingReactUsageEntry(entries, referenceName, "component", createReactUsageLocation(filePath, sourceText, node.start));
 			nextHasComponentAncestor = true;
@@ -1982,6 +2064,10 @@ function analyzeSymbolUsages(symbol, includeBuiltins) {
 		if (node.type === "JSXElement") {
 			const name = getComponentReferenceName(node);
 			if (name !== void 0) symbol.componentReferences.add(name);
+			else {
+				const memberName = getMemberExpressionComponentReferenceName(node);
+				if (memberName !== void 0) symbol.componentReferences.add(memberName);
+			}
 			if (includeBuiltins) {
 				const builtinName = getBuiltinReferenceName(node);
 				if (builtinName !== void 0) symbol.builtinReferences.add(builtinName);
@@ -2063,6 +2149,8 @@ function collectComponentDeclarationEntryUsages(symbolsByName, sourceText) {
 //#region src/analyzers/react/references.ts
 function resolveReactReference(fileAnalysis, fileAnalyses, name, kind) {
 	if (kind === "builtin") return getBuiltinNodeId(name);
+	const dotIndex = name.indexOf(".");
+	if (dotIndex !== -1) return resolveNamespaceMemberReference(fileAnalysis, fileAnalyses, name.slice(0, dotIndex), name.slice(dotIndex + 1), kind);
 	const localSymbol = fileAnalysis.allSymbolsByName.get(name);
 	if (localSymbol !== void 0 && localSymbol.kind === kind) return localSymbol.id;
 	const importBinding = fileAnalysis.importsByLocalName.get(name);
@@ -2074,6 +2162,13 @@ function resolveReactReference(fileAnalysis, fileAnalyses, name, kind) {
 	if (targetId === void 0) return;
 	return targetId;
 }
+function resolveNamespaceMemberReference(fileAnalysis, fileAnalyses, namespaceName, propertyName, kind) {
+	const importBinding = fileAnalysis.importsByLocalName.get(namespaceName);
+	if (importBinding === void 0 || importBinding.importedName !== "*" || importBinding.sourcePath === void 0) return;
+	const sourceFileAnalysis = fileAnalyses.get(importBinding.sourcePath);
+	if (sourceFileAnalysis === void 0) return;
+	return resolveExportedSymbol(sourceFileAnalysis, propertyName, kind, fileAnalyses, /* @__PURE__ */ new Set());
+}
 function resolveExportedSymbol(fileAnalysis, exportName, kind, fileAnalyses, visited) {
 	const visitKey = `${fileAnalysis.filePath}:${exportName}:${kind}`;
 	if (visited.has(visitKey)) return;
@@ -2322,6 +2417,513 @@ function matchesReactFilter(node, filter) {
 	return filter === "all" || node.kind === filter;
 }
 //#endregion
+//#region src/analyzers/react/diff.ts
+function analyzeReactUsageDiff(options) {
+	const originalCwd = resolveOriginalCwd(options.cwd);
+	const repositoryRoot = findGitRepositoryRoot(resolveDiffInputPath(options, originalCwd));
+	const comparison = resolveGitDiffComparison(repositoryRoot, options.diff ?? "HEAD");
+	const [beforeGraph, afterGraph] = loadBothGraphs({
+		repositoryRoot,
+		originalCwd,
+		cwdWithinRepository: resolvePathWithinRepository(originalCwd, repositoryRoot, "Working directory"),
+		entryFile: options.entryFile,
+		nextjs: options.nextjs,
+		filter: options.filter,
+		includeBuiltins: options.includeBuiltins,
+		analyzeOptions: toAnalyzeOptions(options)
+	}, comparison);
+	if (beforeGraph === void 0 && afterGraph === void 0) throw new Error("No React entry files found for the requested diff. Check the entry path or Next.js discovery roots.");
+	const entries = diffEntries(beforeGraph, afterGraph);
+	return {
+		kind: "react-usage-diff",
+		repositoryRoot,
+		cwd: originalCwd,
+		entries,
+		roots: entries.length > 0 ? entries.map((entry) => entry.node) : diffRoots(beforeGraph, afterGraph)
+	};
+}
+const GIT_EXEC_MAX_BUFFER = 64 * 1024 * 1024;
+function resolveOriginalCwd(cwd) {
+	return path.resolve(cwd ?? process.cwd());
+}
+function resolveDiffInputPath(options, originalCwd) {
+	if (options.entryFile === void 0) return originalCwd;
+	return path.isAbsolute(options.entryFile) ? path.resolve(options.entryFile) : path.resolve(originalCwd, options.entryFile);
+}
+function toAnalyzeOptions(options) {
+	return {
+		...options.configPath === void 0 ? {} : { configPath: options.configPath },
+		expandWorkspaces: options.expandWorkspaces,
+		projectOnly: options.projectOnly,
+		includeBuiltins: options.includeBuiltins
+	};
+}
+function loadBothGraphs(context, comparison) {
+	const snapshotsToCleanup = [];
+	try {
+		let beforeRoot;
+		let afterRoot;
+		if (comparison.afterTree === void 0) {
+			beforeRoot = materializeGitTreeSnapshot(context.repositoryRoot, comparison.beforeTree);
+			snapshotsToCleanup.push(beforeRoot);
+			afterRoot = context.repositoryRoot;
+		} else {
+			[beforeRoot, afterRoot] = materializeTwoGitTreeSnapshots(context.repositoryRoot, comparison.beforeTree, comparison.afterTree);
+			snapshotsToCleanup.push(beforeRoot, afterRoot);
+		}
+		return [tryAnalyzeComparableReactGraph(context, beforeRoot), tryAnalyzeComparableReactGraph(context, afterRoot)];
+	} finally {
+		for (const dir of snapshotsToCleanup) fs.rm(dir, {
+			recursive: true,
+			force: true
+		}, () => {});
+	}
+}
+function tryAnalyzeComparableReactGraph(context, workingRoot) {
+	const snapshotCwd = resolveSnapshotCwd(workingRoot, context.cwdWithinRepository);
+	const entryFiles = resolveSnapshotEntryFiles(context, snapshotCwd, workingRoot);
+	if (entryFiles === void 0 || entryFiles.length === 0) return;
+	return toComparableGraph(analyzeReactUsage(entryFiles, {
+		...context.analyzeOptions,
+		cwd: snapshotCwd,
+		...context.analyzeOptions.configPath === void 0 ? {} : { configPath: resolveSnapshotConfigPath(context.analyzeOptions.configPath, workingRoot, context.repositoryRoot) }
+	}), context.repositoryRoot, context.originalCwd, context.filter);
+}
+function resolveSnapshotCwd(workingRoot, cwdWithinRepository) {
+	return cwdWithinRepository.length === 0 ? workingRoot : path.join(workingRoot, cwdWithinRepository);
+}
+function resolveSnapshotEntryFiles(context, snapshotCwd, workingRoot) {
+	if (context.entryFile !== void 0) {
+		const entryFile = resolveSnapshotEntryPath(context.entryFile, workingRoot, context.repositoryRoot);
+		return doesResolvedPathExist(entryFile, snapshotCwd) ? [entryFile] : void 0;
+	}
+	if (!context.nextjs) throw new Error("Missing React entry file. Use `foresthouse react <entry-file>` or `foresthouse react --nextjs`.");
+	try {
+		return resolveReactEntryFiles({
+			command: "react",
+			entryFile: void 0,
+			diff: void 0,
+			cwd: snapshotCwd,
+			configPath: void 0,
+			expandWorkspaces: true,
+			projectOnly: false,
+			json: false,
+			filter: context.filter,
+			nextjs: true,
+			includeBuiltins: context.includeBuiltins
+		});
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith("No Next.js page entries found.")) return;
+		throw error;
+	}
+}
+function resolveSnapshotEntryPath(entryFile, workingRoot, repositoryRoot) {
+	if (!path.isAbsolute(entryFile)) return entryFile;
+	const entryWithinRepository = resolvePathWithinRepository(entryFile, repositoryRoot, "React entry file");
+	return entryWithinRepository.length === 0 ? workingRoot : path.join(workingRoot, entryWithinRepository);
+}
+function resolveSnapshotConfigPath(configPath, workingRoot, repositoryRoot) {
+	if (!path.isAbsolute(configPath)) return configPath;
+	const configWithinRepository = resolvePathWithinRepository(configPath, repositoryRoot, "TypeScript config");
+	return configWithinRepository.length === 0 ? workingRoot : path.join(workingRoot, configWithinRepository);
+}
+function doesResolvedPathExist(entryFile, cwd) {
+	const resolvedEntryPath = path.isAbsolute(entryFile) ? entryFile : path.resolve(cwd, entryFile);
+	return fs.existsSync(resolvedEntryPath);
+}
+function toComparableGraph(graph, _repositoryRoot, originalCwd, filter) {
+	const nodes = /* @__PURE__ */ new Map();
+	graph.nodes.forEach((node) => {
+		const comparableNode = toComparableNode(node, graph, originalCwd, filter);
+		nodes.set(comparableNode.id, comparableNode);
+	});
+	const entries = indexEntries(getReactUsageEntries(graph, filter).map((entry) => toComparableEntry(entry, graph, originalCwd)));
+	return {
+		entriesByKey: new Map(entries.map((entry) => [entry.key, entry])),
+		rootIds: getReactUsageRoots(graph, filter).map((rootId) => {
+			const node = graph.nodes.get(rootId);
+			return node === void 0 ? void 0 : createComparableNodeId(node, graph.cwd);
+		}).filter((rootId) => rootId !== void 0),
+		nodes
+	};
+}
+function toComparableNode(node, graph, originalCwd, filter) {
+	const usages = indexUsages(getFilteredUsages(node, graph, filter).map((usage) => toComparableEdge(usage, graph)));
+	return {
+		id: createComparableNodeId(node, graph.cwd),
+		name: node.name,
+		symbolKind: node.kind,
+		filePath: toDisplayFilePath(node.filePath, graph.cwd, originalCwd),
+		exportNames: [...node.exportNames].sort(),
+		usagesByKey: new Map(usages.map((usage) => [usage.key, usage]))
+	};
+}
+function toComparableEdge(usage, graph) {
+	const targetNode = graph.nodes.get(usage.target);
+	return {
+		kind: usage.kind,
+		targetId: targetNode === void 0 ? usage.target : createComparableNodeId(targetNode, graph.cwd),
+		referenceName: usage.referenceName
+	};
+}
+function toComparableEntry(entry, graph, originalCwd) {
+	const targetNode = graph.nodes.get(entry.target);
+	return {
+		targetId: targetNode === void 0 ? entry.target : createComparableNodeId(targetNode, graph.cwd),
+		referenceName: entry.referenceName,
+		filePath: toDisplayFilePath(entry.location.filePath, graph.cwd, originalCwd),
+		line: entry.location.line,
+		column: entry.location.column
+	};
+}
+function indexUsages(usages) {
+	const counts = /* @__PURE__ */ new Map();
+	return [...usages].sort(compareComparableEdgeState).map((usage) => {
+		const signature = `${usage.kind}:${usage.targetId}`;
+		const occurrence = counts.get(signature) ?? 0;
+		counts.set(signature, occurrence + 1);
+		return {
+			...usage,
+			key: `${signature}#${occurrence}`
+		};
+	});
+}
+function indexEntries(entries) {
+	const counts = /* @__PURE__ */ new Map();
+	return [...entries].sort(compareComparableEntryState).map((entry) => {
+		const signature = `${entry.filePath}:${entry.targetId}`;
+		const occurrence = counts.get(signature) ?? 0;
+		counts.set(signature, occurrence + 1);
+		return {
+			...entry,
+			key: `${signature}#${occurrence}`
+		};
+	});
+}
+function createComparableNodeId(node, analysisCwd) {
+	return `${node.kind}:${toComparablePath(node.filePath, analysisCwd)}#${node.name}`;
+}
+function toComparablePath(filePath, analysisCwd) {
+	if (!path.isAbsolute(filePath)) return normalizePathSeparators(filePath);
+	const relativePath = path.relative(fs.realpathSync.native(analysisCwd), fs.realpathSync.native(filePath));
+	if (relativePath === "") return ".";
+	return normalizePathSeparators(relativePath);
+}
+function toDisplayFilePath(filePath, analysisCwd, originalCwd) {
+	if (!path.isAbsolute(filePath)) return normalizePathSeparators(filePath);
+	const relativePath = path.relative(fs.realpathSync.native(analysisCwd), fs.realpathSync.native(filePath));
+	if (relativePath === "") return ".";
+	return toDisplayPath(path.resolve(originalCwd, relativePath), originalCwd);
+}
+function diffEntries(beforeGraph, afterGraph) {
+	const entryKeys = new Set([...Array.from(beforeGraph?.entriesByKey.keys() ?? []), ...Array.from(afterGraph?.entriesByKey.keys() ?? [])]);
+	return Array.from(entryKeys).sort((left, right) => compareComparableEntryState(beforeGraph?.entriesByKey.get(left) ?? afterGraph?.entriesByKey.get(left), beforeGraph?.entriesByKey.get(right) ?? afterGraph?.entriesByKey.get(right))).flatMap((entryKey) => {
+		const beforeEntry = beforeGraph?.entriesByKey.get(entryKey);
+		const afterEntry = afterGraph?.entriesByKey.get(entryKey);
+		const node = diffNode(beforeEntry?.targetId, afterEntry?.targetId, beforeGraph, afterGraph, /* @__PURE__ */ new Set());
+		const change = resolveEntryChange(beforeEntry, afterEntry);
+		if (change === "unchanged" && !hasVisibleNodeChanges(node)) return [];
+		const currentEntry = afterEntry ?? beforeEntry;
+		if (currentEntry === void 0) return [];
+		return [{
+			key: currentEntry.key,
+			change,
+			targetId: node.id,
+			referenceName: afterEntry?.referenceName ?? beforeEntry?.referenceName ?? node.name,
+			...beforeEntry === void 0 ? {} : {
+				beforeReferenceName: beforeEntry.referenceName,
+				beforeFilePath: beforeEntry.filePath,
+				beforeLine: beforeEntry.line,
+				beforeColumn: beforeEntry.column
+			},
+			...afterEntry === void 0 ? {} : {
+				afterReferenceName: afterEntry.referenceName,
+				afterFilePath: afterEntry.filePath,
+				afterLine: afterEntry.line,
+				afterColumn: afterEntry.column
+			},
+			node
+		}];
+	});
+}
+function diffRoots(beforeGraph, afterGraph) {
+	const rootIds = new Set([...Array.from(beforeGraph?.rootIds ?? []), ...Array.from(afterGraph?.rootIds ?? [])]);
+	return Array.from(rootIds).sort((left, right) => compareComparableNodeState(beforeGraph?.nodes.get(left) ?? afterGraph?.nodes.get(left), beforeGraph?.nodes.get(right) ?? afterGraph?.nodes.get(right))).flatMap((rootId) => {
+		const node = diffNode(beforeGraph?.nodes.has(rootId) === true ? rootId : void 0, afterGraph?.nodes.has(rootId) === true ? rootId : void 0, beforeGraph, afterGraph, /* @__PURE__ */ new Set());
+		return hasVisibleNodeChanges(node) ? [node] : [];
+	});
+}
+function diffNode(beforeNodeId, afterNodeId, beforeGraph, afterGraph, ancestry) {
+	const beforeNode = beforeNodeId === void 0 ? void 0 : beforeGraph?.nodes.get(beforeNodeId);
+	const afterNode = afterNodeId === void 0 ? void 0 : afterGraph?.nodes.get(afterNodeId);
+	if (beforeNode === void 0 && afterNode === void 0) throw new Error("Unable to resolve React diff node.");
+	const ancestryKey = `${beforeNodeId ?? ""}->${afterNodeId ?? ""}`;
+	if (ancestry.has(ancestryKey)) {
+		const node = afterNode ?? beforeNode;
+		if (node === void 0) throw new Error("Unable to resolve circular React diff node.");
+		return {
+			id: node.id,
+			name: node.name,
+			symbolKind: node.symbolKind,
+			circular: true,
+			filePath: node.filePath,
+			change: "unchanged",
+			exportNames: node.exportNames,
+			usages: []
+		};
+	}
+	const nextAncestry = new Set(ancestry);
+	nextAncestry.add(ancestryKey);
+	const usages = collectUsageDiffs(beforeNode, afterNode, beforeGraph, afterGraph, nextAncestry);
+	const directChange = resolveNodeDirectChange(beforeNode, afterNode);
+	const node = afterNode ?? beforeNode;
+	if (node === void 0) throw new Error("Unable to resolve React diff node.");
+	return {
+		id: node.id,
+		name: node.name,
+		symbolKind: node.symbolKind,
+		filePath: node.filePath,
+		change: directChange === "unchanged" && usages.length > 0 ? "changed" : directChange,
+		exportNames: node.exportNames,
+		...beforeNode === void 0 ? {} : { beforeExportNames: beforeNode.exportNames },
+		...afterNode === void 0 ? {} : { afterExportNames: afterNode.exportNames },
+		usages
+	};
+}
+function collectUsageDiffs(beforeNode, afterNode, beforeGraph, afterGraph, ancestry) {
+	const usageKeys = new Set([...Array.from(beforeNode?.usagesByKey.keys() ?? []), ...Array.from(afterNode?.usagesByKey.keys() ?? [])]);
+	return Array.from(usageKeys).sort((left, right) => compareComparableEdgeState(beforeNode?.usagesByKey.get(left) ?? afterNode?.usagesByKey.get(left), beforeNode?.usagesByKey.get(right) ?? afterNode?.usagesByKey.get(right))).flatMap((usageKey) => {
+		const beforeUsage = beforeNode?.usagesByKey.get(usageKey);
+		const afterUsage = afterNode?.usagesByKey.get(usageKey);
+		const node = diffNode(beforeUsage?.targetId, afterUsage?.targetId, beforeGraph, afterGraph, ancestry);
+		const change = resolveEdgeChange(beforeUsage, afterUsage);
+		if (change === "unchanged" && !hasVisibleNodeChanges(node)) return [];
+		return [{
+			key: afterUsage?.key ?? beforeUsage?.key ?? usageKey,
+			kind: afterUsage?.kind ?? beforeUsage?.kind ?? "render",
+			change,
+			targetId: node.id,
+			referenceName: afterUsage?.referenceName ?? beforeUsage?.referenceName ?? node.name,
+			...beforeUsage === void 0 ? {} : { beforeReferenceName: beforeUsage.referenceName },
+			...afterUsage === void 0 ? {} : { afterReferenceName: afterUsage.referenceName },
+			node
+		}];
+	});
+}
+function resolveEntryChange(beforeEntry, afterEntry) {
+	if (beforeEntry === void 0 && afterEntry !== void 0) return "added";
+	if (beforeEntry !== void 0 && afterEntry === void 0) return "removed";
+	if (beforeEntry === void 0 || afterEntry === void 0) return "unchanged";
+	return beforeEntry.targetId === afterEntry.targetId && beforeEntry.referenceName === afterEntry.referenceName && beforeEntry.filePath === afterEntry.filePath && beforeEntry.line === afterEntry.line && beforeEntry.column === afterEntry.column ? "unchanged" : "changed";
+}
+function resolveNodeDirectChange(beforeNode, afterNode) {
+	if (beforeNode === void 0 && afterNode !== void 0) return "added";
+	if (beforeNode !== void 0 && afterNode === void 0) return "removed";
+	if (beforeNode === void 0 || afterNode === void 0) return "unchanged";
+	return beforeNode.name === afterNode.name && beforeNode.symbolKind === afterNode.symbolKind && beforeNode.filePath === afterNode.filePath && areStringArraysEqual(beforeNode.exportNames, afterNode.exportNames) ? "unchanged" : "changed";
+}
+function resolveEdgeChange(beforeUsage, afterUsage) {
+	if (beforeUsage === void 0 && afterUsage !== void 0) return "added";
+	if (beforeUsage !== void 0 && afterUsage === void 0) return "removed";
+	if (beforeUsage === void 0 || afterUsage === void 0) return "unchanged";
+	return beforeUsage.kind === afterUsage.kind && beforeUsage.targetId === afterUsage.targetId && beforeUsage.referenceName === afterUsage.referenceName ? "unchanged" : "changed";
+}
+function hasVisibleNodeChanges(node) {
+	return node.change !== "unchanged" || node.usages.length > 0;
+}
+function compareComparableNodeState(left, right) {
+	return (left?.filePath ?? "").localeCompare(right?.filePath ?? "") || (left?.name ?? "").localeCompare(right?.name ?? "") || (left?.symbolKind ?? "").localeCompare(right?.symbolKind ?? "");
+}
+function compareComparableEdgeState(left, right) {
+	return (left?.targetId ?? "").localeCompare(right?.targetId ?? "") || (left?.referenceName ?? "").localeCompare(right?.referenceName ?? "") || (left?.kind ?? "").localeCompare(right?.kind ?? "");
+}
+function compareComparableEntryState(left, right) {
+	return (left?.filePath ?? "").localeCompare(right?.filePath ?? "") || (left?.line ?? 0) - (right?.line ?? 0) || (left?.column ?? 0) - (right?.column ?? 0) || (left?.referenceName ?? "").localeCompare(right?.referenceName ?? "") || (left?.targetId ?? "").localeCompare(right?.targetId ?? "");
+}
+function areStringArraysEqual(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function resolvePathWithinRepository(resolvedPath, repositoryRoot, label) {
+	const absolutePath = path.resolve(resolvedPath);
+	const existingPath = findNearestExistingPath(absolutePath);
+	const existingRealPath = fs.realpathSync.native(existingPath);
+	const repositoryRealPath = fs.realpathSync.native(repositoryRoot);
+	const relativeFromExistingPath = path.relative(existingPath, absolutePath);
+	const relativePath = path.normalize(path.join(path.relative(repositoryRealPath, existingRealPath), relativeFromExistingPath));
+	if (relativePath === "") return "";
+	if (relativePath.startsWith("..")) throw new Error(`${label} must be inside the Git repository when using --diff.`);
+	return normalizePathSeparators(relativePath);
+}
+function findGitRepositoryRoot(resolvedInputPath) {
+	const searchPath = findNearestExistingPath(resolvedInputPath);
+	try {
+		return runGit(searchPath, ["rev-parse", "--show-toplevel"]).trim();
+	} catch (error) {
+		throw new Error(`Git diff mode requires a Git repository: ${getCommandErrorMessage(error)}`);
+	}
+}
+function findNearestExistingPath(resolvedInputPath) {
+	let currentPath = resolvedInputPath;
+	while (!fs.existsSync(currentPath)) {
+		const parentPath = path.dirname(currentPath);
+		if (parentPath === currentPath) return resolvedInputPath;
+		currentPath = parentPath;
+	}
+	if (fs.statSync(currentPath).isFile()) return path.dirname(currentPath);
+	return currentPath;
+}
+function resolveGitDiffComparison(repositoryRoot, diff) {
+	if (diff.includes("...")) {
+		const [baseRef, headRef] = splitDiffRange(diff, "...");
+		try {
+			return {
+				beforeTree: resolveGitTree(repositoryRoot, runGit(repositoryRoot, [
+					"merge-base",
+					baseRef,
+					headRef
+				]).trim()),
+				afterTree: resolveGitTree(repositoryRoot, headRef)
+			};
+		} catch (error) {
+			throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+		}
+	}
+	if (diff.includes("..")) {
+		const [beforeRef, afterRef] = splitDiffRange(diff, "..");
+		try {
+			return {
+				beforeTree: resolveGitTree(repositoryRoot, beforeRef),
+				afterTree: resolveGitTree(repositoryRoot, afterRef)
+			};
+		} catch (error) {
+			throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+		}
+	}
+	try {
+		return {
+			beforeTree: resolveGitTree(repositoryRoot, diff),
+			afterTree: void 0
+		};
+	} catch (error) {
+		throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+	}
+}
+function splitDiffRange(diff, separator) {
+	const [left, right, ...extra] = diff.split(separator);
+	if (left === void 0 || right === void 0 || left.length === 0 || right.length === 0 || extra.length > 0) throw new Error(`Invalid Git diff spec \`${diff}\``);
+	return [left, right];
+}
+function resolveGitTree(repositoryRoot, reference) {
+	return runGit(repositoryRoot, [
+		"rev-parse",
+		"--verify",
+		`${reference}^{tree}`
+	]).trim();
+}
+function materializeGitTreeSnapshot(repositoryRoot, tree) {
+	const snapshotRoot = fs.mkdtempSync(path.join(os.tmpdir(), "foresthouse-react-diff-"));
+	execSync(`git -C ${JSON.stringify(repositoryRoot)} archive --format=tar ${tree} | tar -x -C ${JSON.stringify(snapshotRoot)}`, {
+		maxBuffer: GIT_EXEC_MAX_BUFFER,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	return snapshotRoot;
+}
+function materializeTwoGitTreeSnapshots(repositoryRoot, beforeTree, afterTree) {
+	const afterSnap = materializeGitTreeSnapshot(repositoryRoot, afterTree);
+	try {
+		return [cloneSnapshotWithOverlay(repositoryRoot, afterSnap, beforeTree, afterTree), afterSnap];
+	} catch {
+		return [materializeGitTreeSnapshot(repositoryRoot, beforeTree), afterSnap];
+	}
+}
+function cloneSnapshotWithOverlay(repositoryRoot, sourceSnap, targetTree, sourceTree) {
+	const targetSnap = fs.mkdtempSync(path.join(os.tmpdir(), "foresthouse-react-diff-"));
+	fs.rmSync(targetSnap, { recursive: true });
+	if (process.platform === "darwin") execFileSync("cp", [
+		"-cR",
+		sourceSnap,
+		targetSnap
+	], { stdio: "ignore" });
+	else execFileSync("cp", [
+		"-a",
+		"--reflink=auto",
+		sourceSnap,
+		targetSnap
+	], { stdio: "ignore" });
+	const diffOutput = execFileSync("git", [
+		"-C",
+		repositoryRoot,
+		"diff",
+		"--name-status",
+		"--no-renames",
+		"-z",
+		targetTree,
+		sourceTree
+	], {
+		maxBuffer: GIT_EXEC_MAX_BUFFER,
+		encoding: "utf8"
+	});
+	if (diffOutput.length === 0) return targetSnap;
+	const parts = diffOutput.split("\0");
+	const filesToDelete = [];
+	const filesToRestore = [];
+	for (let i = 0; i + 1 < parts.length; i += 2) {
+		const status = parts[i];
+		const file = parts[i + 1];
+		if (file === void 0) break;
+		if (status === "A") filesToDelete.push(file);
+		else if (status === "D" || status === "M") filesToRestore.push(file);
+	}
+	for (const file of filesToDelete) fs.rmSync(path.join(targetSnap, file), { force: true });
+	if (filesToRestore.length > 0) {
+		const archive = execFileSync("git", [
+			"-C",
+			repositoryRoot,
+			"archive",
+			"--format=tar",
+			targetTree,
+			"--",
+			...filesToRestore
+		], { maxBuffer: GIT_EXEC_MAX_BUFFER });
+		execFileSync("tar", [
+			"-x",
+			"-C",
+			targetSnap
+		], { input: archive });
+	}
+	return targetSnap;
+}
+function runGit(repositoryRoot, args, options = {}) {
+	const output = execFileSync("git", [
+		"-C",
+		repositoryRoot,
+		...args
+	], {
+		encoding: "utf8",
+		maxBuffer: GIT_EXEC_MAX_BUFFER,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	return options.trim === false ? output : output.trimEnd();
+}
+function getCommandErrorMessage(error) {
+	if (!(error instanceof Error)) return "Unknown Git error";
+	const stderr = Reflect.get(error, "stderr");
+	if (typeof stderr === "string" && stderr.trim().length > 0) return stderr.trim();
+	if (Buffer.isBuffer(stderr) && stderr.byteLength > 0) return stderr.toString("utf8").trim();
+	return error.message;
+}
+function normalizePathSeparators(filePath) {
+	return filePath.split(path.sep).join("/");
+}
+//#endregion
 //#region src/color.ts
 const ANSI_RESET = "\x1B[0m";
 const ANSI_COMPONENT = "\x1B[36m";
@@ -2579,6 +3181,20 @@ function printReactUsageTree(graph, options = {}) {
 	});
 	return lines.join("\n");
 }
+function printReactUsageDiffTree(graph, options = {}) {
+	const color = resolveColorSupport(options.color);
+	if (graph.entries.length > 0) return renderReactDiffEntries(graph.entries, color);
+	if (graph.roots.length === 0) return "No React changes found.";
+	const lines = [];
+	graph.roots.forEach((root, index) => {
+		lines.push(formatDiffLine(root.change, formatReactDiffNodeLabel(root, color), color));
+		root.usages.forEach((usage, usageIndex) => {
+			lines.push(...renderDiffUsage(usage, color, "", usageIndex === root.usages.length - 1));
+		});
+		if (index < graph.roots.length - 1) lines.push("");
+	});
+	return lines.join("\n");
+}
 function renderReactUsageEntries(graph, entries, cwd, filter, color) {
 	const lines = [];
 	entries.forEach((entry, index) => {
@@ -2618,6 +3234,63 @@ function formatReactEntryLabel(entry, cwd) {
 function formatReactNodeFilePath$1(node, cwd) {
 	return node.kind === "builtin" ? "html" : toDisplayPath(node.filePath, cwd);
 }
+function renderReactDiffEntries(entries, color) {
+	const lines = [];
+	entries.forEach((entry, index) => {
+		lines.push(formatDiffLine(resolveVisibleEntryChange(entry), formatReactDiffEntryLabel(entry), color));
+		lines.push(formatDiffLine(entry.node.change, formatReactDiffNodeLabel(entry.node, color, entry.beforeReferenceName, entry.afterReferenceName), color));
+		entry.node.usages.forEach((usage, usageIndex) => {
+			lines.push(...renderDiffUsage(usage, color, "", usageIndex === entry.node.usages.length - 1));
+		});
+		if (index < entries.length - 1) lines.push("");
+	});
+	return lines.join("\n");
+}
+function renderDiffUsage(usage, color, prefix, isLast) {
+	const line = `${`${prefix}${isLast ? "└─ " : "├─ "}`}${formatDiffLine(resolveVisibleEdgeChange(usage), formatReactDiffNodeLabel(usage.node, color, usage.beforeReferenceName, usage.afterReferenceName), color)}`;
+	if (usage.node.circular === true) return [`${line} (circular)`];
+	const childLines = [line];
+	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
+	usage.node.usages.forEach((childUsage, index) => {
+		childLines.push(...renderDiffUsage(childUsage, color, nextPrefix, index === usage.node.usages.length - 1));
+	});
+	return childLines;
+}
+function formatReactDiffEntryLabel(entry) {
+	const beforeLocation = entry.beforeFilePath === void 0 || entry.beforeLine === void 0 || entry.beforeColumn === void 0 ? void 0 : `${entry.beforeFilePath}:${entry.beforeLine}:${entry.beforeColumn}`;
+	const afterLocation = entry.afterFilePath === void 0 || entry.afterLine === void 0 || entry.afterColumn === void 0 ? void 0 : `${entry.afterFilePath}:${entry.afterLine}:${entry.afterColumn}`;
+	if (entry.change === "changed" && beforeLocation !== void 0 && afterLocation !== void 0) return `${beforeLocation} -> ${afterLocation}`;
+	return afterLocation ?? beforeLocation ?? entry.referenceName;
+}
+function formatReactDiffNodeLabel(node, color, beforeReferenceName, afterReferenceName) {
+	return `${formatReactDiffSymbolLabel(node.name, node.symbolKind, color, beforeReferenceName, afterReferenceName)} (${node.filePath})`;
+}
+function formatReactDiffSymbolLabel(name, kind, color, beforeReferenceName, afterReferenceName) {
+	if (![beforeReferenceName, afterReferenceName].filter((referenceName) => referenceName !== void 0).some((referenceName) => referenceName !== name)) return formatReactSymbolLabel(name, kind, color);
+	const aliasText = formatReactDiffAlias(name, beforeReferenceName, afterReferenceName);
+	return `${colorizeReactLabel(formatReactSymbolName(name, kind), kind, color)} ${colorizeMuted(aliasText, color)} ${colorizeReactLabel(`[${kind}]`, kind, color)}`;
+}
+function formatReactDiffAlias(name, beforeReferenceName, afterReferenceName) {
+	if (beforeReferenceName !== void 0 && afterReferenceName !== void 0 && beforeReferenceName !== afterReferenceName) return `as ${beforeReferenceName} -> ${afterReferenceName}`;
+	const currentReferenceName = afterReferenceName ?? beforeReferenceName;
+	if (currentReferenceName === void 0 || currentReferenceName === name) return "as self";
+	return `as ${currentReferenceName}`;
+}
+function resolveVisibleEntryChange(entry) {
+	return entry.change === "unchanged" ? entry.node.change : entry.change;
+}
+function resolveVisibleEdgeChange(usage) {
+	return usage.change === "unchanged" ? usage.node.change : usage.change;
+}
+function formatDiffLine(change, text, color) {
+	if (change === "unchanged") return text;
+	return colorizePackageDiff(`${toDiffMarker(change)} ${text}`, change, color);
+}
+function toDiffMarker(change) {
+	if (change === "added") return "+";
+	if (change === "removed") return "-";
+	return "~";
+}
 //#endregion
 //#region src/output/json/deps.ts
 function graphToSerializablePackageTree(graph) {
@@ -2775,6 +3448,13 @@ function graphToSerializableReactTree(graph, options = {}) {
 		roots
 	};
 }
+function diffGraphToSerializableReactTree(graph) {
+	return {
+		kind: graph.kind,
+		entries: graph.entries.map((entry) => serializeReactDiffEntry(entry)),
+		roots: graph.roots.map((root) => serializeReactDiffNode(root))
+	};
+}
 function serializeReactUsageNode(nodeId, graph, filter, visited) {
 	const node = graph.nodes.get(nodeId);
 	if (node === void 0) return {
@@ -2822,7 +3502,50 @@ function serializeReactUsageEntry(entry, graph, filter) {
 function formatReactNodeFilePath(filePath, kind, cwd) {
 	return kind === "builtin" ? "html" : toDisplayPath(filePath, cwd);
 }
+function serializeReactDiffNode(node) {
+	return {
+		id: node.id,
+		name: node.name,
+		symbolKind: node.symbolKind,
+		...node.circular === true ? { circular: true } : {},
+		filePath: node.filePath,
+		change: node.change,
+		exportNames: node.exportNames,
+		...node.beforeExportNames === void 0 ? {} : { beforeExportNames: node.beforeExportNames },
+		...node.afterExportNames === void 0 ? {} : { afterExportNames: node.afterExportNames },
+		usages: node.usages.map((usage) => serializeReactDiffEdge(usage))
+	};
+}
+function serializeReactDiffEdge(usage) {
+	return {
+		key: usage.key,
+		kind: usage.kind,
+		change: usage.change,
+		targetId: usage.targetId,
+		referenceName: usage.referenceName,
+		...usage.beforeReferenceName === void 0 ? {} : { beforeReferenceName: usage.beforeReferenceName },
+		...usage.afterReferenceName === void 0 ? {} : { afterReferenceName: usage.afterReferenceName },
+		node: serializeReactDiffNode(usage.node)
+	};
+}
+function serializeReactDiffEntry(entry) {
+	return {
+		key: entry.key,
+		change: entry.change,
+		targetId: entry.targetId,
+		referenceName: entry.referenceName,
+		...entry.beforeReferenceName === void 0 ? {} : { beforeReferenceName: entry.beforeReferenceName },
+		...entry.afterReferenceName === void 0 ? {} : { afterReferenceName: entry.afterReferenceName },
+		...entry.beforeFilePath === void 0 ? {} : { beforeFilePath: entry.beforeFilePath },
+		...entry.beforeLine === void 0 ? {} : { beforeLine: entry.beforeLine },
+		...entry.beforeColumn === void 0 ? {} : { beforeColumn: entry.beforeColumn },
+		...entry.afterFilePath === void 0 ? {} : { afterFilePath: entry.afterFilePath },
+		...entry.afterLine === void 0 ? {} : { afterLine: entry.afterLine },
+		...entry.afterColumn === void 0 ? {} : { afterColumn: entry.afterColumn },
+		node: serializeReactDiffNode(entry.node)
+	};
+}
 //#endregion
-export { printReactUsageTree as a, printPackageDependencyTree as c, getReactUsageRoots as d, analyzeReactUsage as f, analyzePackageDependencies as g, analyzePackageDependencyDiff as h, graphToSerializablePackageTree as i, getFilteredUsages as l, isSourceCodeFile as m, graphToSerializableTree as n, printDependencyTree as o, analyzeDependencies as p, diffGraphToSerializablePackageTree as r, printPackageDependencyDiffTree as s, graphToSerializableReactTree as t, getReactUsageEntries as u };
+export { analyzeDependencies as _, graphToSerializablePackageTree as a, printDependencyTree as c, analyzeReactUsageDiff as d, getFilteredUsages as f, resolveReactEntryFiles as g, analyzeReactUsage as h, diffGraphToSerializablePackageTree as i, printPackageDependencyDiffTree as l, getReactUsageRoots as m, graphToSerializableReactTree as n, printReactUsageDiffTree as o, getReactUsageEntries as p, graphToSerializableTree as r, printReactUsageTree as s, diffGraphToSerializableReactTree as t, printPackageDependencyTree as u, analyzePackageDependencyDiff as v, analyzePackageDependencies as y };
 
-//# sourceMappingURL=react-xFA5HmqF.mjs.map
+//# sourceMappingURL=react-D0TO9XR2.mjs.map