@codefast/cli 0.3.13-canary.0 → 0.3.13-canary.1

package/dist/lib/mirror/index.mjs

@@ -1,3 +1,2 @@
-import { t as runMirrorSync } from "../../sync-e1Sp-shi.mjs";
-import "../../mirror-CbGiLXKT.mjs";
+import { runMirrorSync } from "./application/sync.mjs";
 export { runMirrorSync };

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

@@ -1,2 +1,14 @@
-import { t as isDirentList } from "../../../dirent-list-BSDeRG5i.mjs";
+//#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

@@ -1,2 +1,26 @@
-import { t as resolvePackageFilterUnderRoot } from "../../../package-filter-C_8ryqvz.mjs";
+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

@@ -1,2 +1,7 @@
-import { t as normalizePath } from "../../../path-normalizer-D4ceBO3l.mjs";
+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

@@ -1,2 +1,105 @@
-import { n as resolvePackageDisplayName, r as writePackageJsonExportsAtomic, t as readPackageJsonDisplayName } from "../../../update-pkg-CnGfjWBy.mjs";
+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 };

package/dist/lib/mirror/infra/workspace-packages.mjs

@@ -1,2 +1,159 @@
-import { i as workspacePatternToPackageJsonGlob, n as parsePnpmWorkspaceDocument, r as splitWorkspacePackageEntries, t as findWorkspacePackageRelPaths } from "../../../workspace-packages-K2NYTHJq.mjs";
+import { messageFromCaughtUnknown } from "../../infra/caught-unknown-message.mjs";
+import { normalizePath } from "./path-normalizer.mjs";
+import { mirrorGlobWarning } from "../presentation/reporter.mjs";
+import { globSync } from "node:fs";
+import path from "node:path";
+import picomatch from "picomatch";
+import { parse } from "yaml";
+//#region src/lib/mirror/infra/workspace-packages.ts
+const PNPM_WORKSPACE = "pnpm-workspace.yaml";
+/** Default when the workspace file is missing or has no `packages` key. */
+const DEFAULT_INCLUDE = ["packages/*"];
+function toPosix(filePath) {
+	return filePath.split(path.sep).join("/");
+}
+function isGlobPermissionError(caughtError) {
+	if (typeof caughtError !== "object" || caughtError === null || !("code" in caughtError)) return false;
+	const code = caughtError.code;
+	return code === "EACCES" || code === "EPERM";
+}
+/** Turn a pnpm `packages` glob into a `globSync` pattern that finds `package.json` files. */
+function workspacePatternToPackageJsonGlob(pattern) {
+	const normalizedPattern = toPosix(pattern.trim()).replace(/\/+$/, "");
+	if (!normalizedPattern) return "**/package.json";
+	return `${normalizedPattern}/package.json`;
+}
+function splitWorkspacePackageEntries(raw) {
+	const include = [];
+	const exclude = [];
+	if (!Array.isArray(raw)) return {
+		include,
+		exclude
+	};
+	for (const entry of raw) {
+		if (typeof entry !== "string") continue;
+		const trimmed = entry.trim();
+		if (!trimmed) continue;
+		if (trimmed.startsWith("!")) exclude.push(trimmed.slice(1).trim());
+		else include.push(trimmed);
+	}
+	return {
+		include,
+		exclude
+	};
+}
+/**
+* Reads `packages` from a parsed pnpm workspace document.
+* @throws If the document is invalid or `packages` is present but not an array.
+*/
+function parsePnpmWorkspaceDocument(doc) {
+	if (doc === null || doc === void 0) throw new Error(`${PNPM_WORKSPACE} root document must be an object (got empty or null)`);
+	if (typeof doc !== "object" || Array.isArray(doc)) throw new Error(`${PNPM_WORKSPACE} root must be a mapping, not an array or scalar`);
+	const parsedDoc = doc;
+	if (!Object.prototype.hasOwnProperty.call(parsedDoc, "packages")) return {
+		include: [],
+		exclude: [],
+		hasPackagesKey: false,
+		isEmptyPackagesArray: false
+	};
+	const pkgs = parsedDoc.packages;
+	if (!Array.isArray(pkgs)) throw new Error(`${PNPM_WORKSPACE} field "packages" must be an array`);
+	if (pkgs.length === 0) return {
+		include: [],
+		exclude: [],
+		hasPackagesKey: true,
+		isEmptyPackagesArray: true
+	};
+	return {
+		...splitWorkspacePackageEntries(pkgs),
+		hasPackagesKey: true,
+		isEmptyPackagesArray: false
+	};
+}
+async function readWorkspaceYaml(rootDir, fs) {
+	const workspaceYamlPath = path.join(rootDir, PNPM_WORKSPACE);
+	if (!fs.existsSync(workspaceYamlPath)) return { exists: false };
+	let raw;
+	try {
+		raw = await fs.readFile(workspaceYamlPath, "utf8");
+	} catch (caughtReadError) {
+		throw new Error(`Failed to read ${PNPM_WORKSPACE}: ${messageFromCaughtUnknown(caughtReadError)}`);
+	}
+	let doc;
+	try {
+		doc = parse(raw);
+	} catch (caughtYamlParseError) {
+		throw new Error(`Failed to parse ${PNPM_WORKSPACE}: ${messageFromCaughtUnknown(caughtYamlParseError)}`);
+	}
+	if (doc === null || doc === void 0) throw new Error(`${PNPM_WORKSPACE} must define a mapping at the document root`);
+	return {
+		exists: true,
+		doc
+	};
+}
+/**
+* Workspace package directories relative to `rootDir` (POSIX slashes), sorted.
+* Reads `pnpm-workspace.yaml` when present; otherwise uses `packages/*`.
+* Only paths with a `package.json` are returned (same practical rule as pnpm).
+*/
+async function findWorkspacePackageRelPaths(rootDir, fs, logger) {
+	const workspaceYaml = await readWorkspaceYaml(rootDir, fs);
+	let include;
+	let exclude;
+	let multiSource;
+	if (!workspaceYaml.exists) {
+		include = [...DEFAULT_INCLUDE];
+		exclude = [];
+		multiSource = "default-patterns";
+	} else {
+		const parsed = parsePnpmWorkspaceDocument(workspaceYaml.doc);
+		if (!parsed.hasPackagesKey) {
+			include = [...DEFAULT_INCLUDE];
+			exclude = [];
+			multiSource = "default-patterns";
+		} else if (parsed.isEmptyPackagesArray) return {
+			relPaths: [],
+			multiSource: "declared-empty"
+		};
+		else {
+			include = parsed.include;
+			exclude = parsed.exclude;
+			multiSource = "pnpm-workspace-yaml";
+		}
+	}
+	const found = /* @__PURE__ */ new Set();
+	const globOpts = {
+		cwd: rootDir,
+		posix: true,
+		...path.sep === "\\" ? { windowsPathsNoEscape: true } : {}
+	};
+	for (const pattern of include) {
+		const globPat = workspacePatternToPackageJsonGlob(pattern);
+		let matches;
+		try {
+			matches = globSync(globPat, globOpts);
+		} catch (caughtGlobError) {
+			if (isGlobPermissionError(caughtGlobError)) {
+				mirrorGlobWarning(logger, `Skipping workspace glob "${pattern}" (${messageFromCaughtUnknown(caughtGlobError)})`);
+				continue;
+			}
+			throw new Error(`Invalid workspace glob "${pattern}": ${messageFromCaughtUnknown(caughtGlobError)}`);
+		}
+		for (const matchedPath of matches) {
+			const posix = toPosix(matchedPath);
+			if (!posix.endsWith("/package.json")) continue;
+			const rel = posix.slice(0, -13);
+			if (!rel) continue;
+			found.add(normalizePath(rel));
+		}
+	}
+	const excludeMatchers = exclude.map((pat) => picomatch(pat, { dot: true }));
+	const relPaths = [...found].filter((rel) => !excludeMatchers.some((isMatch) => isMatch(rel)));
+	relPaths.sort((a, b) => a.localeCompare(b));
+	return {
+		relPaths,
+		multiSource
+	};
+}
+//#endregion
 export { findWorkspacePackageRelPaths, parsePnpmWorkspaceDocument, splitWorkspacePackageEntries, workspacePatternToPackageJsonGlob };

package/dist/lib/mirror/presentation/reporter.mjs

@@ -1,2 +1,111 @@
-import { a as mirrorBanner, c as mirrorNoPackages, d as mirrorSummarySeparator, f as printMirrorConfigWarnings, i as logSkippedWorkspacePackage, l as mirrorProcessingMode, n as logPackageError, o as mirrorFatalError, r as logPackageSuccess, s as mirrorGlobWarning, t as configureMirrorColors, u as mirrorSummary } from "../../../reporter-CwIe_tAM.mjs";
-export { configureMirrorColors, logPackageError, logPackageSuccess, logSkippedWorkspacePackage, mirrorBanner, mirrorFatalError, mirrorGlobWarning, mirrorNoPackages, mirrorProcessingMode, mirrorSummary, mirrorSummarySeparator, printMirrorConfigWarnings };
+import { messageFromCaughtUnknown } from "../../infra/caught-unknown-message.mjs";
+import { printConfigSchemaWarnings } from "../../infra/config-reporter.mjs";
+import process from "node:process";
+//#region src/lib/mirror/presentation/reporter.ts
+const Colors = {
+	RESET: "\x1B[0m",
+	BOLD: "\x1B[1m",
+	DIM: "\x1B[2m",
+	GREEN: "\x1B[32m",
+	YELLOW: "\x1B[33m",
+	CYAN: "\x1B[36m",
+	GRAY: "\x1B[90m",
+	MAGENTA: "\x1B[35m",
+	BRIGHT_GREEN: "\x1B[92m",
+	BRIGHT_YELLOW: "\x1B[93m",
+	BRIGHT_CYAN: "\x1B[96m",
+	disable() {
+		for (const key of Object.keys(this)) if (typeof this[key] === "string") this[key] = "";
+	}
+};
+function configureMirrorColors(noColor) {
+	if (!process.stdout.isTTY || noColor) Colors.disable();
+}
+function printMirrorConfigWarnings(logger, warnings) {
+	printConfigSchemaWarnings(logger, warnings);
+}
+function mirrorGlobWarning(logger, message) {
+	const { out } = logger;
+	out(`${Colors.YELLOW}⚠ ${message}${Colors.RESET}`);
+}
+function logSkippedWorkspacePackage(logger, index, total, displayName, reason) {
+	const { out } = logger;
+	out(`${`${Colors.DIM}[${index}/${total}]${Colors.RESET}`} ${Colors.GRAY}○${Colors.RESET} ${Colors.DIM}${displayName}${Colors.RESET}`);
+	out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.GRAY}Skipped: ${reason}${Colors.RESET}`);
+	out("");
+}
+function mirrorBanner(logger) {
+	const { out } = logger;
+	out(`\n${Colors.BOLD}${Colors.CYAN}📦 Mirror — package exports${Colors.RESET}`);
+	out(`${Colors.DIM}${"═".repeat(60)}${Colors.RESET}\n`);
+}
+function mirrorProcessingMode(logger, mode) {
+	const { out } = logger;
+	if (mode.kind === "single") {
+		out(`${Colors.DIM}Processing single package...${Colors.RESET}\n`);
+		return;
+	}
+	switch (mode.source) {
+		case "default-patterns":
+			out(`${Colors.DIM}Discovering workspace packages using default patterns (packages/*)…${Colors.RESET}\n`);
+			break;
+		case "pnpm-workspace-yaml":
+			out(`${Colors.DIM}Discovering workspace packages from pnpm-workspace.yaml…${Colors.RESET}\n`);
+			break;
+		case "declared-empty":
+			out(`${Colors.DIM}pnpm-workspace.yaml declares an empty workspace package list.${Colors.RESET}\n`);
+			break;
+	}
+}
+function mirrorNoPackages(logger) {
+	logger.out(`${Colors.YELLOW}⚠ No packages found${Colors.RESET}`);
+}
+function logPackageSuccess(logger, index, total, pkgStats, generatedDistAssetCounts, verbose) {
+	const { out } = logger;
+	out(`${`${Colors.DIM}[${index}/${total}]${Colors.RESET}`} ${Colors.BRIGHT_GREEN}✓${Colors.RESET} ${Colors.BOLD}${pkgStats.name}${Colors.RESET}`);
+	if (verbose) {
+		out(`  ${Colors.DIM}├─${Colors.RESET} Path: ${pkgStats.path}`);
+		if (pkgStats.hasTransform) out(`  ${Colors.DIM}├─${Colors.RESET} ${Colors.CYAN}Custom path transformation${Colors.RESET}`);
+		if (pkgStats.cssConfigStatus) out(`  ${Colors.DIM}├─${Colors.RESET} ${Colors.CYAN}${pkgStats.cssConfigStatus === "disabled" ? "CSS disabled" : "CSS configured"}${Colors.RESET}`);
+	}
+	const breakdown = [];
+	if (generatedDistAssetCounts.jsCount > 0) breakdown.push(`${Colors.GREEN}${generatedDistAssetCounts.jsCount} modules${Colors.RESET}`);
+	if (generatedDistAssetCounts.cssCount > 0) breakdown.push(`${Colors.MAGENTA}${generatedDistAssetCounts.cssCount} CSS${Colors.RESET}`);
+	if (pkgStats.customExports > 0) breakdown.push(`${Colors.YELLOW}${pkgStats.customExports} custom${Colors.RESET}`);
+	if (breakdown.length > 0) out(`  ${Colors.DIM}└─${Colors.RESET} ${breakdown.join(" + ")} = ${Colors.BRIGHT_CYAN}${pkgStats.totalExports} exports${Colors.RESET}`);
+	else out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.BRIGHT_CYAN}${pkgStats.totalExports} exports${Colors.RESET}`);
+	out("");
+}
+function logPrunedStaleExport(logger, exportSpecifier) {
+	logger.out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.GRAY}Pruned stale export: ${exportSpecifier}${Colors.RESET}`);
+}
+function logPackageError(logger, index, total, displayName, errValue, verbose) {
+	const { out, err: errLine } = logger;
+	out(`${Colors.DIM}[${index}/${total}]${Colors.RESET} ${Colors.YELLOW}✗${Colors.RESET} ${Colors.BOLD}${displayName}${Colors.RESET}`);
+	out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.YELLOW}Error: ${messageFromCaughtUnknown(errValue)}${Colors.RESET}\n`);
+	if (verbose) errLine(errValue instanceof Error && errValue.stack ? errValue.stack : messageFromCaughtUnknown(errValue));
+}
+function mirrorSummarySeparator(logger) {
+	logger.out(`${Colors.DIM}${"═".repeat(60)}${Colors.RESET}`);
+}
+function mirrorSummary(logger, stats, elapsedSeconds) {
+	const { out } = logger;
+	out(`${Colors.BOLD}📊 Summary${Colors.RESET} ${Colors.DIM}(completed in ${elapsedSeconds.toFixed(2)}s)${Colors.RESET}\n`);
+	out(`  ${Colors.BOLD}Packages:${Colors.RESET}`);
+	out(`  ${Colors.DIM}├─${Colors.RESET} Processed: ${Colors.GREEN}${stats.packagesProcessed}${Colors.RESET}`);
+	if (stats.packagesSkipped > 0) out(`  ${Colors.DIM}├─${Colors.RESET} Skipped: ${Colors.GRAY}${stats.packagesSkipped}${Colors.RESET}`);
+	if (stats.packagesErrored > 0) out(`  ${Colors.DIM}├─${Colors.RESET} Errors: ${Colors.YELLOW}${stats.packagesErrored}${Colors.RESET}`);
+	out(`  ${Colors.DIM}└─${Colors.RESET} Total found: ${stats.packagesFound}\n`);
+	out(`  ${Colors.BOLD}Exports:${Colors.RESET}`);
+	out(`  ${Colors.DIM}├─${Colors.RESET} JS Modules: ${Colors.CYAN}${stats.totalJsModules}${Colors.RESET}`);
+	out(`  ${Colors.DIM}├─${Colors.RESET} CSS Files: ${Colors.MAGENTA}${stats.totalCssExports}${Colors.RESET}`);
+	out(`  ${Colors.DIM}└─${Colors.RESET} Total: ${Colors.BRIGHT_CYAN}${stats.totalExports}${Colors.RESET}\n`);
+	out(`${Colors.DIM}${"═".repeat(60)}${Colors.RESET}\n`);
+}
+function mirrorFatalError(logger, caughtError) {
+	const { out, err: errLine } = logger;
+	out(`${Colors.YELLOW}Fatal error: ${messageFromCaughtUnknown(caughtError)}${Colors.RESET}`);
+	errLine(caughtError instanceof Error && caughtError.stack ? caughtError.stack : messageFromCaughtUnknown(caughtError));
+}
+//#endregion
+export { configureMirrorColors, logPackageError, logPackageSuccess, logPrunedStaleExport, logSkippedWorkspacePackage, mirrorBanner, mirrorFatalError, mirrorGlobWarning, mirrorNoPackages, mirrorProcessingMode, mirrorSummary, mirrorSummarySeparator, printMirrorConfigWarnings };