@codefast/cli 0.3.12 → 0.3.13-canary.1

package/dist/lib/mirror/application/engine.mjs

@@ -0,0 +1,248 @@
+import { DTS_EXTENSION, PACKAGE_JSON_EXPORT, VALID_JS_EXTENSIONS } from "../domain/constants.mjs";
+import { isDirentList } from "../infra/dirent-list.mjs";
+import { normalizePath } from "../infra/path-normalizer.mjs";
+import path from "node:path";
+//#region src/lib/mirror/application/engine.ts
+function resolvePackageScopedConfig(configMap, pkgMeta) {
+	if (!configMap) return;
+	return configMap[pkgMeta.packageName];
+}
+async function scanDirectoryFiles(fs, dir, baseDir = dir) {
+	try {
+		const raw = await fs.readdir(dir, {
+			recursive: true,
+			withFileTypes: true
+		});
+		if (!isDirentList(raw)) return [];
+		return raw.filter((dirent) => dirent.isFile()).map((dirent) => {
+			const fullPath = path.join(dirent.parentPath, dirent.name);
+			return normalizePath(path.relative(baseDir, fullPath));
+		});
+	} catch (caughtError) {
+		if (caughtError && typeof caughtError === "object" && "code" in caughtError) {
+			if (caughtError.code === "ENOENT" || caughtError.code === "EACCES") return [];
+		}
+		throw caughtError;
+	}
+}
+async function isDirectoryCssOnly(fs, distDir, dirPath) {
+	try {
+		const raw = await fs.readdir(path.join(distDir, dirPath), { withFileTypes: true });
+		if (!isDirentList(raw)) return false;
+		if (raw.length === 0) return true;
+		return raw.every((dirent) => dirent.isFile() && dirent.name.endsWith(".css"));
+	} catch {
+		return false;
+	}
+}
+function groupFilesByModule(files) {
+	const modules = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		let ext;
+		let modulePath;
+		if (file.endsWith(".d.ts")) {
+			ext = DTS_EXTENSION;
+			modulePath = file.slice(0, -DTS_EXTENSION.length);
+		} else {
+			ext = path.extname(file);
+			if (!VALID_JS_EXTENSIONS.has(ext)) continue;
+			modulePath = file.slice(0, -ext.length);
+		}
+		if (!path.basename(modulePath)) continue;
+		let distModule = modules.get(modulePath);
+		if (!distModule) {
+			distModule = {
+				path: modulePath,
+				files: {
+					js: null,
+					mjs: null,
+					cjs: null,
+					dts: null
+				}
+			};
+			modules.set(modulePath, distModule);
+		}
+		if (ext === ".js") distModule.files.js = file;
+		else if (ext === ".mjs") distModule.files.mjs = file;
+		else if (ext === ".cjs") distModule.files.cjs = file;
+		else if (ext === ".d.ts") distModule.files.dts = file;
+	}
+	return modules;
+}
+function toExportPath(distPath) {
+	if (distPath === "index") return ".";
+	if (distPath.endsWith("/index")) return `./${distPath.slice(0, -6)}`;
+	return `./${distPath}`;
+}
+const GROUP_ORDER = {
+	components: 100,
+	hooks: 200,
+	primitives: 300,
+	core: 400,
+	loaders: 500,
+	utils: 600,
+	adapters: 700,
+	script: 750,
+	css: 900
+};
+function getExportGroup(exportPath, pathTransform) {
+	if (exportPath === ".") return [
+		".",
+		"",
+		0,
+		0
+	];
+	const cleanPath = exportPath.startsWith("./") ? exportPath.slice(2) : exportPath;
+	if (cleanPath.endsWith("/*")) {
+		const dirName = cleanPath.slice(0, -2);
+		return [
+			dirName,
+			"",
+			dirName === "css" ? 900 : 100,
+			0
+		];
+	}
+	const parts = cleanPath.split("/");
+	if (parts.length === 1) {
+		const name = parts[0];
+		if (name in GROUP_ORDER) return [
+			name,
+			"",
+			GROUP_ORDER[name] ?? 0,
+			0
+		];
+		if (pathTransform) return [
+			"components",
+			name,
+			100,
+			1
+		];
+		return [
+			"",
+			name,
+			800,
+			1
+		];
+	}
+	const group = parts[0] ?? "";
+	return [
+		group,
+		parts.slice(1).join("/"),
+		GROUP_ORDER[group] ?? 700,
+		1
+	];
+}
+function createPathTransform(config, pkgMeta) {
+	const pathConfig = resolvePackageScopedConfig(config?.pathTransformations, pkgMeta);
+	if (!pathConfig) return null;
+	const { removePrefix } = pathConfig;
+	if (!removePrefix) return null;
+	return (exportPath) => {
+		if (!exportPath.startsWith(removePrefix)) return exportPath;
+		const result = exportPath.slice(removePrefix.length);
+		if (result && result !== "." && !result.startsWith("./")) return `./${result}`;
+		return result;
+	};
+}
+function getSortTuple(exportPath, pathTransform) {
+	const [group, subpath, order, isIndex] = getExportGroup(exportPath, pathTransform);
+	return [
+		order,
+		group,
+		isIndex,
+		subpath
+	];
+}
+function compareTuples(left, right) {
+	if (left[0] !== right[0]) return left[0] - right[0];
+	if (left[1] !== right[1]) return left[1] < right[1] ? -1 : 1;
+	if (left[2] !== right[2]) return left[2] - right[2];
+	if (left[3] !== right[3]) return left[3] < right[3] ? -1 : 1;
+	return 0;
+}
+async function generateCssExports(fs, distDir, cssConfig) {
+	if (cssConfig === false) return {};
+	if (cssConfig === true) cssConfig = { enabled: true };
+	if (!cssConfig || cssConfig.enabled === false) return {};
+	const cssFiles = (await scanDirectoryFiles(fs, distDir)).filter((relativeDistPath) => relativeDistPath.endsWith(".css"));
+	if (!cssFiles.length) return {};
+	const cssExports = { ...cssConfig.customExports };
+	const cssByDir = /* @__PURE__ */ new Map();
+	const rootCss = [];
+	for (const file of cssFiles) {
+		const dirName = normalizePath(path.dirname(file));
+		if (dirName === ".") rootCss.push(file);
+		else {
+			const arr = cssByDir.get(dirName) || [];
+			arr.push(file);
+			cssByDir.set(dirName, arr);
+		}
+	}
+	for (const file of rootCss) {
+		const exportPath = `./${file}`;
+		if (!(exportPath in cssExports)) cssExports[exportPath] = `./dist/${file}`;
+	}
+	for (const [dirName, dirFiles] of cssByDir.entries()) if (await isDirectoryCssOnly(fs, distDir, dirName) && !cssConfig.forceExportFiles) {
+		const wildcardExport = `./${dirName}/*`;
+		if (!(wildcardExport in cssExports)) cssExports[wildcardExport] = `./dist/${dirName}/*`;
+	} else for (const file of dirFiles) {
+		const exportPath = `./${file}`;
+		if (!(exportPath in cssExports)) cssExports[exportPath] = `./dist/${file}`;
+	}
+	return cssExports;
+}
+/**
+* Compute `package.json#exports` from a built `dist/` tree. No logging; no writes.
+*/
+async function generateExports(fs, distDir, pathTransform, cssConfig, customExports) {
+	const files = await scanDirectoryFiles(fs, distDir);
+	if (!files.length) return {
+		exports: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		originalPathBySpecifier: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		jsCount: 0,
+		cssCount: 0
+	};
+	const modules = groupFilesByModule(files);
+	const validModules = Array.from(modules.values()).filter((moduleEntry) => (moduleEntry.files.js || moduleEntry.files.mjs) && moduleEntry.files.dts);
+	if (!validModules.length) return {
+		exports: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		originalPathBySpecifier: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		jsCount: 0,
+		cssCount: 0
+	};
+	const exportsObj = {};
+	const originalPathBySpecifier = {};
+	for (const distModuleEntry of validModules) {
+		const originalExportPath = toExportPath(distModuleEntry.path);
+		let exportPath = originalExportPath;
+		if (pathTransform) exportPath = pathTransform(exportPath);
+		const distPath = `./dist/${distModuleEntry.path}`;
+		const entry = { types: `${distPath}.d.ts` };
+		if (distModuleEntry.files.mjs) entry.import = `${distPath}.mjs`;
+		else if (distModuleEntry.files.js) entry.import = `${distPath}.js`;
+		if (distModuleEntry.files.cjs) entry.require = `${distPath}.cjs`;
+		exportsObj[exportPath] = entry;
+		originalPathBySpecifier[exportPath] = originalExportPath;
+	}
+	let sortedKeys = Object.keys(exportsObj).sort((pathA, pathB) => compareTuples(getSortTuple(pathA, pathTransform), getSortTuple(pathB, pathTransform)));
+	const sortedExports = {};
+	for (const exportKey of sortedKeys) sortedExports[exportKey] = exportsObj[exportKey];
+	const cssExports = await generateCssExports(fs, distDir, cssConfig ?? { enabled: true });
+	Object.assign(sortedExports, cssExports);
+	for (const [specifier, mappedPath] of Object.entries(customExports || {})) if (specifier !== "./package.json") sortedExports[specifier] = mappedPath;
+	for (const cssSpecifier of Object.keys(cssExports)) if (!(cssSpecifier in originalPathBySpecifier)) originalPathBySpecifier[cssSpecifier] = cssSpecifier;
+	for (const customSpecifier of Object.keys(customExports || {})) if (customSpecifier !== "./package.json" && !(customSpecifier in originalPathBySpecifier)) originalPathBySpecifier[customSpecifier] = customSpecifier;
+	sortedKeys = Object.keys(sortedExports).filter((exportKey) => exportKey !== PACKAGE_JSON_EXPORT).sort((pathA, pathB) => compareTuples(getSortTuple(pathA, pathTransform), getSortTuple(pathB, pathTransform)));
+	const finalExports = {};
+	for (const exportKey of sortedKeys) finalExports[exportKey] = sortedExports[exportKey];
+	finalExports[PACKAGE_JSON_EXPORT] = PACKAGE_JSON_EXPORT;
+	originalPathBySpecifier[PACKAGE_JSON_EXPORT] = PACKAGE_JSON_EXPORT;
+	return {
+		exports: finalExports,
+		originalPathBySpecifier,
+		jsCount: Object.keys(exportsObj).length,
+		cssCount: Object.keys(cssExports).length
+	};
+}
+//#endregion
+export { createPathTransform, generateExports };

package/dist/lib/mirror/application/sync.mjs

@@ -0,0 +1,162 @@
+import { messageFromCaughtUnknown } from "../../infra/caught-unknown-message.mjs";
+import { DIST_DIR, PACKAGE_JSON } from "../domain/constants.mjs";
+import { createPathTransform, generateExports } from "./engine.mjs";
+import { resolvePackageFilterUnderRoot } from "../infra/package-filter.mjs";
+import { configureMirrorColors, logPackageError, logPackageSuccess, logPrunedStaleExport, logSkippedWorkspacePackage, mirrorBanner, mirrorFatalError, mirrorNoPackages, mirrorProcessingMode, mirrorSummary, mirrorSummarySeparator } from "../presentation/reporter.mjs";
+import { resolvePackageDisplayName, writePackageJsonExportsAtomic } from "../infra/update-pkg.mjs";
+import { findWorkspacePackageRelPaths } from "../infra/workspace-packages.mjs";
+import path from "node:path";
+//#region src/lib/mirror/application/sync.ts
+function resolvePackageScopedConfig(configMap, pkgMeta) {
+	if (!configMap) return;
+	return configMap[pkgMeta.packageName];
+}
+function isPackageSkipped(skipPackagesArray, pkgMeta) {
+	if (!skipPackagesArray) return false;
+	return skipPackagesArray.includes(pkgMeta.packageName);
+}
+async function syncExportsForWorkspacePackage(fs, logger, rootDir, packagePathStr, index, total, config, verbose, stats) {
+	const packageDir = path.resolve(rootDir, packagePathStr);
+	const distDir = path.join(packageDir, DIST_DIR);
+	const packageJsonPath = path.join(packageDir, PACKAGE_JSON);
+	const folderBasename = path.basename(packageDir);
+	const pkgStats = {
+		name: folderBasename,
+		path: packageDir,
+		jsModules: 0,
+		cssExports: 0,
+		customExports: 0,
+		totalExports: 0,
+		hasTransform: false,
+		cssConfigStatus: "",
+		skipped: false,
+		skipReason: "",
+		error: null
+	};
+	if (!fs.existsSync(packageJsonPath)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "package.json not found";
+		stats.packagesSkipped++;
+		logSkippedWorkspacePackage(logger, index, total, folderBasename, pkgStats.skipReason);
+		return pkgStats;
+	}
+	let packageJsonParseError;
+	try {
+		const pkgContent = await fs.readFile(packageJsonPath, "utf8");
+		const raw = JSON.parse(pkgContent);
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new SyntaxError("package.json root must be a JSON object");
+		pkgStats.name = resolvePackageDisplayName(raw, folderBasename);
+	} catch (caughtError) {
+		pkgStats.name = folderBasename;
+		packageJsonParseError = caughtError;
+	}
+	const pkgMeta = { packageName: pkgStats.name };
+	if (isPackageSkipped(config.skipPackages, pkgMeta)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "configured to skip";
+		stats.packagesSkipped++;
+		logSkippedWorkspacePackage(logger, index, total, pkgStats.name, pkgStats.skipReason);
+		return pkgStats;
+	}
+	if (packageJsonParseError !== void 0) {
+		if (!fs.existsSync(distDir)) {
+			pkgStats.skipped = true;
+			pkgStats.skipReason = "dist/ not found";
+			stats.packagesSkipped++;
+			logSkippedWorkspacePackage(logger, index, total, pkgStats.name, pkgStats.skipReason);
+			return pkgStats;
+		}
+		pkgStats.error = messageFromCaughtUnknown(packageJsonParseError);
+		stats.packagesErrored++;
+		logPackageError(logger, index, total, pkgStats.name, packageJsonParseError, verbose);
+		return pkgStats;
+	}
+	if (!fs.existsSync(distDir)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "dist/ not found";
+		stats.packagesSkipped++;
+		logSkippedWorkspacePackage(logger, index, total, pkgStats.name, pkgStats.skipReason);
+		return pkgStats;
+	}
+	try {
+		const pathTransform = createPathTransform(config, pkgMeta);
+		pkgStats.hasTransform = !!pathTransform;
+		const cssConfig = resolvePackageScopedConfig(config.cssExports, pkgMeta);
+		if (cssConfig === false) pkgStats.cssConfigStatus = "disabled";
+		else if (cssConfig !== void 0) pkgStats.cssConfigStatus = "configured";
+		const customExports = resolvePackageScopedConfig(config.customExports, pkgMeta) || {};
+		const generatedExports = await generateExports(fs, distDir, pathTransform, cssConfig, customExports);
+		const { prunedKeys } = await writePackageJsonExportsAtomic(fs, packageJsonPath, {
+			generatedExports: generatedExports.exports,
+			managedExportSpecifiers: Object.keys(generatedExports.exports),
+			originalPathBySpecifier: generatedExports.originalPathBySpecifier
+		});
+		for (const exportSpecifier of prunedKeys) logPrunedStaleExport(logger, exportSpecifier);
+		pkgStats.jsModules = generatedExports.jsCount;
+		pkgStats.cssExports = generatedExports.cssCount;
+		pkgStats.customExports = Object.keys(customExports).length;
+		pkgStats.totalExports = Object.keys(generatedExports.exports).length;
+		stats.packagesProcessed++;
+		stats.totalExports += pkgStats.totalExports;
+		stats.totalJsModules += pkgStats.jsModules;
+		stats.totalCssExports += pkgStats.cssExports;
+		logPackageSuccess(logger, index, total, pkgStats, generatedExports, verbose);
+	} catch (caughtError) {
+		pkgStats.error = messageFromCaughtUnknown(caughtError);
+		stats.packagesErrored++;
+		logPackageError(logger, index, total, pkgStats.name, caughtError, verbose);
+	}
+	return pkgStats;
+}
+/** @returns Process exit code (0 or 1). */
+async function runMirrorSync(opts) {
+	const { fs, logger } = opts;
+	const config = opts.config ?? {};
+	configureMirrorColors(!!opts.noColor);
+	mirrorBanner(logger);
+	const startTime = performance.now();
+	const verbose = !!opts.verbose;
+	try {
+		const stats = {
+			packagesFound: 0,
+			packagesProcessed: 0,
+			packagesSkipped: 0,
+			packagesErrored: 0,
+			totalExports: 0,
+			totalJsModules: 0,
+			totalCssExports: 0,
+			packageDetails: []
+		};
+		let targetPackages = [];
+		if (opts.packageFilter) {
+			targetPackages = [resolvePackageFilterUnderRoot(opts.rootDir, opts.packageFilter)];
+			mirrorProcessingMode(logger, { kind: "single" });
+		} else {
+			const { relPaths, multiSource } = await findWorkspacePackageRelPaths(opts.rootDir, fs, logger);
+			targetPackages = relPaths;
+			mirrorProcessingMode(logger, {
+				kind: "multi",
+				source: multiSource
+			});
+		}
+		stats.packagesFound = targetPackages.length;
+		if (targetPackages.length === 0) {
+			mirrorNoPackages(logger);
+			return 0;
+		}
+		let nextPackageOrdinal = 1;
+		for (const pkgPath of targetPackages) {
+			const pkgStats = await syncExportsForWorkspacePackage(fs, logger, opts.rootDir, pkgPath, nextPackageOrdinal++, targetPackages.length, config, verbose, stats);
+			stats.packageDetails.push(pkgStats);
+		}
+		const elapsed = (performance.now() - startTime) / 1e3;
+		mirrorSummarySeparator(logger);
+		mirrorSummary(logger, stats, elapsed);
+		return stats.packagesErrored > 0 ? 1 : 0;
+	} catch (caughtError) {
+		mirrorFatalError(logger, caughtError);
+		return 1;
+	}
+}
+//#endregion
+export { runMirrorSync };

package/dist/lib/mirror/domain/constants.mjs

@@ -0,0 +1,12 @@
+//#region src/lib/mirror/domain/constants.ts
+const DIST_DIR = "dist";
+const PACKAGE_JSON = "package.json";
+const VALID_JS_EXTENSIONS = new Set([
+	".js",
+	".mjs",
+	".cjs"
+]);
+const DTS_EXTENSION = ".d.ts";
+const PACKAGE_JSON_EXPORT = "./package.json";
+//#endregion
+export { DIST_DIR, DTS_EXTENSION, PACKAGE_JSON, PACKAGE_JSON_EXPORT, VALID_JS_EXTENSIONS };

package/dist/lib/mirror/domain/errors.mjs

@@ -0,0 +1,15 @@
+//#region src/lib/mirror/domain/errors.ts
+const MirrorErrorCode = {
+	FATAL: "FATAL",
+	PACKAGE_WRITE: "PACKAGE_WRITE"
+};
+var MirrorError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "MirrorError";
+		this.code = code;
+	}
+};
+//#endregion
+export { MirrorError, MirrorErrorCode };

package/dist/lib/mirror/domain/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lib/mirror/index.mjs

@@ -0,0 +1,2 @@
+import { runMirrorSync } from "./application/sync.mjs";
+export { runMirrorSync };

package/dist/lib/mirror/infra/dirent-list.mjs

@@ -0,0 +1,14 @@
+//#region src/lib/mirror/infra/dirent-list.ts
+/**
+* Narrow `fs.promises.readdir` overload result to `Dirent[]` when `withFileTypes: true`.
+* Accepts both historical checks (`isFile` / `isDirectory`) in one guard.
+* Returning `true` for an empty array is intentional: callers treat empty lists
+* the same regardless of the element type, so `[]` is safely accepted as `Dirent[]`.
+*/
+function isDirentList(x) {
+	if (x.length === 0) return true;
+	const first = x[0];
+	return typeof first === "object" && first !== null && "isFile" in first && "isDirectory" in first;
+}
+//#endregion
+export { isDirentList };

package/dist/lib/mirror/infra/package-filter.mjs

@@ -0,0 +1,26 @@
+import { normalizePath } from "./path-normalizer.mjs";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+//#region src/lib/mirror/infra/package-filter.ts
+function tryRealpath(entryPath) {
+	try {
+		return realpathSync.native(entryPath);
+	} catch {
+		return path.resolve(entryPath);
+	}
+}
+/**
+* Resolve `packageFilter` to a POSIX-ish path relative to `rootDir`, without using
+* `process.cwd()`. Use for programmatic `runMirrorSync` calls.
+*
+* @throws If the resolved path is not a strict subdirectory of `rootDir`.
+*/
+function resolvePackageFilterUnderRoot(rootDir, packageFilter) {
+	const rootReal = tryRealpath(path.resolve(rootDir));
+	const resolved = path.isAbsolute(packageFilter) ? tryRealpath(path.resolve(packageFilter)) : tryRealpath(path.join(rootReal, packageFilter));
+	const normalized = normalizePath(path.relative(rootReal, resolved));
+	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized === "" || normalized === ".") throw new Error(`Package path must be a subdirectory under monorepo root: ${rootDir}`);
+	return normalized;
+}
+//#endregion
+export { resolvePackageFilterUnderRoot };

package/dist/lib/mirror/infra/path-normalizer.mjs

@@ -0,0 +1,7 @@
+import path from "node:path";
+//#region src/lib/mirror/infra/path-normalizer.ts
+function normalizePath(pathString) {
+	return pathString.split(path.sep).join("/").replace(/\\/g, "/");
+}
+//#endregion
+export { normalizePath };

package/dist/lib/mirror/infra/update-pkg.mjs

@@ -0,0 +1,105 @@
+import { messageFromCaughtUnknown } from "../../infra/caught-unknown-message.mjs";
+import { PACKAGE_JSON_EXPORT } from "../domain/constants.mjs";
+import { MirrorError, MirrorErrorCode } from "../domain/errors.mjs";
+//#region src/lib/mirror/infra/update-pkg.ts
+function containsDistTarget(value) {
+	if (typeof value === "string") return value.startsWith("./dist/");
+	if (Array.isArray(value)) return value.some((entryValue) => containsDistTarget(entryValue));
+	if (value && typeof value === "object") return Object.values(value).some((entryValue) => containsDistTarget(entryValue));
+	return false;
+}
+/**
+* Keep `./package.json` at the very end for aesthetics by default.
+* If a catch-all `./*` exists, move `./package.json` before wildcards so it remains reachable.
+*/
+function exportSpecifierRank(exportSpecifier, hasCatchAllWildcard) {
+	if (exportSpecifier === ".") return 0;
+	if (exportSpecifier === "./package.json") return hasCatchAllWildcard ? 2 : 4;
+	if (exportSpecifier.includes("*")) return 3;
+	return 1;
+}
+function compareExportSpecifiers(leftSpecifier, rightSpecifier, originalPathBySpecifier, hasCatchAllWildcard) {
+	const leftRank = exportSpecifierRank(leftSpecifier, hasCatchAllWildcard);
+	const rightRank = exportSpecifierRank(rightSpecifier, hasCatchAllWildcard);
+	if (leftRank !== rightRank) return leftRank - rightRank;
+	const leftOriginalPath = originalPathBySpecifier[leftSpecifier] ?? leftSpecifier;
+	const rightOriginalPath = originalPathBySpecifier[rightSpecifier] ?? rightSpecifier;
+	const originalPathComparison = leftOriginalPath.localeCompare(rightOriginalPath);
+	if (originalPathComparison !== 0) return originalPathComparison;
+	return leftSpecifier.localeCompare(rightSpecifier);
+}
+/** Shared rule: show `package.json#name` when it is a non-empty string; else folder basename. */
+function resolvePackageDisplayName(packageJson, folderBasename) {
+	const declaredName = packageJson.name;
+	return typeof declaredName === "string" && declaredName.length > 0 ? declaredName : folderBasename;
+}
+async function readPackageJsonDisplayName(fs, packageJsonPath, folderBasename) {
+	if (!fs.existsSync(packageJsonPath)) return folderBasename;
+	try {
+		const raw = await fs.readFile(packageJsonPath, "utf8");
+		return resolvePackageDisplayName(JSON.parse(raw), folderBasename);
+	} catch {
+		return folderBasename;
+	}
+}
+/**
+* Writes `exports` into `package.json` via a temp file + rename (atomic on same volume).
+* Preserves a trailing newline after JSON.
+*/
+async function writePackageJsonExportsAtomic(fs, packageJsonPath, mergeInput) {
+	const raw = await fs.readFile(packageJsonPath, "utf8");
+	const packageJson = JSON.parse(raw);
+	const existingExports = packageJson.exports;
+	const existingExportMap = existingExports && typeof existingExports === "object" && !Array.isArray(existingExports) ? existingExports : {};
+	const managedSpecifiers = new Set(mergeInput.managedExportSpecifiers);
+	const originalPathBySpecifier = { ...mergeInput.originalPathBySpecifier };
+	const mergedExportMap = {};
+	const prunedKeys = [];
+	for (const [exportSpecifier, exportValue] of Object.entries(existingExportMap)) {
+		if (exportSpecifier === "./package.json") {
+			mergedExportMap[exportSpecifier] = exportValue;
+			if (!(exportSpecifier in originalPathBySpecifier)) originalPathBySpecifier[exportSpecifier] = exportSpecifier;
+			continue;
+		}
+		if (!managedSpecifiers.has(exportSpecifier)) if (containsDistTarget(exportValue)) prunedKeys.push(exportSpecifier);
+		else {
+			mergedExportMap[exportSpecifier] = exportValue;
+			if (!(exportSpecifier in originalPathBySpecifier)) originalPathBySpecifier[exportSpecifier] = exportSpecifier;
+		}
+	}
+	for (const [exportSpecifier, exportValue] of Object.entries(mergeInput.generatedExports)) mergedExportMap[exportSpecifier] = exportValue;
+	if (!("./package.json" in mergedExportMap)) mergedExportMap[PACKAGE_JSON_EXPORT] = PACKAGE_JSON_EXPORT;
+	originalPathBySpecifier[PACKAGE_JSON_EXPORT] = PACKAGE_JSON_EXPORT;
+	const rootExport = mergedExportMap["."];
+	if (rootExport && typeof rootExport === "object" && !Array.isArray(rootExport)) {
+		const rootEntry = rootExport;
+		const requirePath = typeof rootEntry.require === "string" ? rootEntry.require : void 0;
+		const importPath = typeof rootEntry.import === "string" ? rootEntry.import : void 0;
+		const typesPath = typeof rootEntry.types === "string" ? rootEntry.types : void 0;
+		if (requirePath || importPath) packageJson.main = requirePath ?? importPath;
+		if (importPath && importPath.endsWith(".mjs")) packageJson.module = importPath;
+		if (typesPath) packageJson.types = typesPath;
+	}
+	const filesField = packageJson.files;
+	if (Array.isArray(filesField)) {
+		const normalizedFiles = filesField.filter((entry) => typeof entry === "string");
+		if (!normalizedFiles.includes("dist")) normalizedFiles.push("dist");
+		packageJson.files = normalizedFiles;
+	} else packageJson.files = ["dist"];
+	const sortedExportMap = {};
+	const hasCatchAllWildcard = "./*" in mergedExportMap;
+	for (const exportSpecifier of Object.keys(mergedExportMap).sort((leftSpecifier, rightSpecifier) => compareExportSpecifiers(leftSpecifier, rightSpecifier, originalPathBySpecifier, hasCatchAllWildcard))) sortedExportMap[exportSpecifier] = mergedExportMap[exportSpecifier];
+	packageJson.exports = sortedExportMap;
+	const serialized = JSON.stringify(packageJson, null, 2) + "\n";
+	const tmpPath = `${packageJsonPath}.tmp`;
+	await fs.writeFile(tmpPath, serialized, "utf8");
+	try {
+		await fs.rename(tmpPath, packageJsonPath);
+	} catch (caughtRenameError) {
+		await fs.unlink(tmpPath).catch(() => {});
+		throw new MirrorError(MirrorErrorCode.PACKAGE_WRITE, `Failed to atomically update ${packageJsonPath}: ${messageFromCaughtUnknown(caughtRenameError)}`, caughtRenameError instanceof Error ? { cause: caughtRenameError } : void 0);
+	}
+	return { prunedKeys };
+}
+//#endregion
+export { readPackageJsonDisplayName, resolvePackageDisplayName, writePackageJsonExportsAtomic };