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

package/dist/lib/arrange/presentation/report.mjs

@@ -1,2 +1,24 @@
-import { t as printAnalyzeReport } from "../../../report-DYxvw34T.mjs";
+import "../domain/constants.mjs";
+import path from "node:path";
+//#region src/lib/arrange/presentation/report.ts
+function printAnalyzeReport(analyzeRootDirectoryPath, analyzeReport, logger) {
+	const { out } = logger;
+	out(`Path: ${path.resolve(analyzeRootDirectoryPath)}`);
+	out(`.ts/.tsx files: ${analyzeReport.files}`);
+	out(`cn(...) call sites: ${analyzeReport.cnCallExpressions}`);
+	out(`tv(...) call sites: ${analyzeReport.tvCallExpressions}`);
+	out(`\nLong cn(...) string literals (≥18 tokens — consider splitting arguments): ${analyzeReport.longCnStringLiterals.length}`);
+	for (const findingEntry of analyzeReport.longCnStringLiterals.slice(0, 40)) out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+	if (analyzeReport.longCnStringLiterals.length > 40) out(`  … and ${analyzeReport.longCnStringLiterals.length - 40} more`);
+	out(`\nLong tv({...}) string literals in base/variants/… (≥18 tokens): ${analyzeReport.longTvStringLiterals.length}`);
+	for (const findingEntry of analyzeReport.longTvStringLiterals.slice(0, 40)) out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+	if (analyzeReport.longTvStringLiterals.length > 40) out(`  … and ${analyzeReport.longTvStringLiterals.length - 40} more`);
+	out(`\nJSX className="..." or className={'...'} (static strings, ≥18 tokens): ${analyzeReport.longJsxClassNameLiterals.length}`);
+	for (const findingEntry of analyzeReport.longJsxClassNameLiterals.slice(0, 40)) out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+	if (analyzeReport.longJsxClassNameLiterals.length > 40) out(`  … and ${analyzeReport.longJsxClassNameLiterals.length - 40} more`);
+	out(`\ncn(...) nested inside tv({...}) (prefer a string or array — preview/apply can rewrite): ${analyzeReport.cnInsideTvCalls.length}`);
+	for (const findingEntry of analyzeReport.cnInsideTvCalls.slice(0, 40)) out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.argCount} args)  ${findingEntry.preview}`);
+	if (analyzeReport.cnInsideTvCalls.length > 40) out(`  … and ${analyzeReport.cnInsideTvCalls.length - 40} more`);
+}
+//#endregion
 export { printAnalyzeReport };

package/dist/lib/config/domain/schema.mjs

@@ -1,2 +1,25 @@
-import { a as mirrorConfigSchema, i as hookSchema, n as codefastConfigSchema, r as codefastTagConfigSchema, t as codefastArrangeConfigSchema } from "../../../schema-Or8RAARd.mjs";
+import { z } from "zod";
+//#region src/lib/config/domain/schema.ts
+const hookSchema = z.custom((value) => typeof value === "function", { message: "Expected a function" });
+const mirrorConfigSchema = z.object({
+	skipPackages: z.array(z.string()).optional(),
+	pathTransformations: z.record(z.string(), z.object({ removePrefix: z.string().optional() }).strict()).optional(),
+	customExports: z.record(z.string(), z.record(z.string(), z.string())).optional(),
+	cssExports: z.record(z.string(), z.union([z.boolean(), z.object({
+		enabled: z.boolean().optional(),
+		customExports: z.record(z.string(), z.string()).optional(),
+		forceExportFiles: z.boolean().optional()
+	}).strict()])).optional()
+}).strict();
+const codefastTagConfigSchema = z.object({
+	skipPackages: z.array(z.string()).optional(),
+	onAfterWrite: hookSchema.optional()
+}).strict();
+const codefastArrangeConfigSchema = z.object({ onAfterWrite: hookSchema.optional() }).strict();
+const codefastConfigSchema = z.object({
+	mirror: mirrorConfigSchema.optional(),
+	tag: codefastTagConfigSchema.optional(),
+	arrange: codefastArrangeConfigSchema.optional()
+}).strict();
+//#endregion
 export { codefastArrangeConfigSchema, codefastConfigSchema, codefastTagConfigSchema, hookSchema, mirrorConfigSchema };

package/dist/lib/config/index.mjs

@@ -1,4 +1,3 @@
-import { a as mirrorConfigSchema, i as hookSchema, n as codefastConfigSchema, r as codefastTagConfigSchema, t as codefastArrangeConfigSchema } from "../../schema-Or8RAARd.mjs";
-import { n as resetConfigLoaderCacheForTests, t as loadConfig } from "../../loader-DpN-zl5g.mjs";
-import "../../config-DVia_f9a.mjs";
+import { codefastArrangeConfigSchema, codefastConfigSchema, codefastTagConfigSchema, hookSchema, mirrorConfigSchema } from "./domain/schema.mjs";
+import { loadConfig, resetConfigLoaderCacheForTests } from "./infra/loader.mjs";
 export { codefastArrangeConfigSchema, codefastConfigSchema, codefastTagConfigSchema, hookSchema, loadConfig, mirrorConfigSchema, resetConfigLoaderCacheForTests };

package/dist/lib/config/infra/loader.mjs

@@ -1,2 +1,78 @@
-import { n as resetConfigLoaderCacheForTests, t as loadConfig } from "../../../loader-DpN-zl5g.mjs";
+import { codefastConfigSchema } from "../domain/schema.mjs";
+import process from "node:process";
+import path from "node:path";
+import jiti from "jiti";
+import { ZodError } from "zod";
+//#region src/lib/config/infra/loader.ts
+const CONFIG_JS_PRIORITY = [
+	"codefast.config.mjs",
+	"codefast.config.js",
+	"codefast.config.cjs"
+];
+const CONFIG_JSON = "codefast.config.json";
+const cachedLoads = /* @__PURE__ */ new Map();
+function formatZodError(error, filePath) {
+	const formatted = error.issues.map((issue) => {
+		return `  - ${issue.path.length > 0 ? issue.path.join(".") : "<root>"}: ${issue.message}`;
+	}).join("\n");
+	return `Invalid config schema in ${path.basename(filePath)}:\n${formatted}`;
+}
+function parseLoadedConfig(raw, filePath) {
+	try {
+		return codefastConfigSchema.parse(raw);
+	} catch (caughtError) {
+		if (caughtError instanceof ZodError) throw new Error(formatZodError(caughtError, filePath));
+		throw caughtError;
+	}
+}
+function listConfigCandidates(startDir, fs) {
+	const candidates = [];
+	let current = path.resolve(startDir);
+	while (true) {
+		for (const name of CONFIG_JS_PRIORITY) {
+			const candidate = path.join(current, name);
+			if (fs.existsSync(candidate)) candidates.push(candidate);
+		}
+		const jsonCandidate = path.join(current, CONFIG_JSON);
+		if (fs.existsSync(jsonCandidate)) candidates.push(jsonCandidate);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return candidates;
+}
+async function readConfigFromPath(filePath, fs) {
+	if (path.extname(filePath) === ".json") {
+		const content = await fs.readFile(filePath, "utf8");
+		return parseLoadedConfig(JSON.parse(content), filePath);
+	}
+	const moduleConfig = jiti(process.cwd(), {
+		interopDefault: true,
+		moduleCache: false
+	})(filePath);
+	return parseLoadedConfig(typeof moduleConfig === "object" && moduleConfig !== null && "default" in moduleConfig ? moduleConfig.default : moduleConfig, filePath);
+}
+async function loadOnce(fs, startDir) {
+	const warnings = [];
+	const configPaths = listConfigCandidates(startDir, fs);
+	if (configPaths.length === 0) return {
+		config: {},
+		warnings
+	};
+	const configPath = configPaths[0];
+	return {
+		config: await readConfigFromPath(configPath, fs),
+		warnings,
+		configPath
+	};
+}
+async function loadConfig(fs, startDir = process.cwd()) {
+	const cacheKey = path.resolve(startDir);
+	if (!cachedLoads.has(cacheKey)) cachedLoads.set(cacheKey, loadOnce(fs, cacheKey));
+	return cachedLoads.get(cacheKey);
+}
+function resetConfigLoaderCacheForTests() {
+	cachedLoads.clear();
+}
+//#endregion
 export { loadConfig, resetConfigLoaderCacheForTests };

package/dist/lib/infra/caught-unknown-message.mjs

@@ -1,2 +1,20 @@
-import { t as messageFromCaughtUnknown } from "../../caught-unknown-message-CRhkDWO7.mjs";
+//#region src/lib/infra/caught-unknown-message.ts
+/**
+* Stable, user-facing text for values caught as `unknown`.
+* Avoids `String(unknown)` / `[object Object]` and satisfies strict `no-base-to-string`.
+*/
+function messageFromCaughtUnknown(value) {
+	if (value instanceof Error) return value.message;
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
+	if (typeof value === "symbol") return String(value);
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	try {
+		const serialized = JSON.stringify(value);
+		if (typeof serialized === "string") return serialized;
+	} catch {}
+	return "[unserializable non-Error value]";
+}
+//#endregion
 export { messageFromCaughtUnknown };

package/dist/lib/infra/config-reporter.mjs

@@ -1,2 +1,10 @@
-import { t as printConfigSchemaWarnings } from "../../config-reporter-SCcWDZc1.mjs";
+//#region src/lib/infra/config-reporter.ts
+const YELLOW = "\x1B[33m";
+const RESET = "\x1B[0m";
+/** User-visible lines for non-fatal issues returned with a successfully parsed config. */
+function printConfigSchemaWarnings(logger, warnings) {
+	const { out } = logger;
+	for (const warningMessage of warnings) out(`${YELLOW}\u26A0\uFE0F ${warningMessage}${RESET}`);
+}
+//#endregion
 export { printConfigSchemaWarnings };

package/dist/lib/infra/node-io.mjs

@@ -1,2 +1,30 @@
-import { n as createNodeCliLogger, t as createNodeCliFs } from "../../node-io-DFRbHO6m.mjs";
+import process from "node:process";
+import fsSync from "node:fs";
+import fsPromises from "node:fs/promises";
+//#region src/lib/infra/node-io.ts
+function createNodeCliFs() {
+	return {
+		existsSync: fsSync.existsSync,
+		statSync: fsSync.statSync,
+		readFileSync: fsSync.readFileSync,
+		writeFileSync: fsSync.writeFileSync,
+		readdirSync: fsSync.readdirSync,
+		readFile: (p, enc) => fsPromises.readFile(p, enc),
+		writeFile: (p, data, enc) => fsPromises.writeFile(p, data, enc),
+		readdir: (p, opts) => fsPromises.readdir(p, opts),
+		rename: (oldPath, newPath) => fsPromises.rename(oldPath, newPath),
+		unlink: (p) => fsPromises.unlink(p)
+	};
+}
+function createNodeCliLogger() {
+	return {
+		out: (line) => {
+			process.stdout.write(`${line}\n`);
+		},
+		err: (line) => {
+			process.stderr.write(`${line}\n`);
+		}
+	};
+}
+//#endregion
 export { createNodeCliFs, createNodeCliLogger };

package/dist/lib/infra/workspace/repo-root.mjs

@@ -1,2 +1,22 @@
-import { t as findRepoRoot } from "../../../repo-root-HmtIEm6J.mjs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/lib/infra/workspace/repo-root.ts
+/**
+* Resolve the monorepo root (directory containing `pnpm-workspace.yaml`).
+* Tries the compiled package location first, then `process.cwd()`.
+*/
+function findRepoRoot(fs) {
+	const candidates = [path.dirname(fileURLToPath(import.meta.url)), process.cwd()];
+	for (const start of candidates) {
+		let dir = path.resolve(start);
+		for (;;) {
+			if (fs.existsSync(path.join(dir, "pnpm-workspace.yaml"))) return dir;
+			const parent = path.dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+	}
+	throw new Error(`Could not locate monorepo root (missing pnpm-workspace.yaml). Searched from: ${candidates.join(", ")}`);
+}
+//#endregion
 export { findRepoRoot };

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

@@ -1,2 +1,248 @@
-import { n as generateExports, t as createPathTransform } from "../../../engine-DRTdkc5u.mjs";
+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

@@ -1,2 +1,162 @@
-import { t as runMirrorSync } from "../../../sync-e1Sp-shi.mjs";
+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

@@ -1,2 +1,12 @@
-import { a as VALID_JS_EXTENSIONS, i as PACKAGE_JSON_EXPORT, n as DTS_EXTENSION, r as PACKAGE_JSON, t as DIST_DIR } from "../../../constants-Bq5wdyLC.mjs";
+//#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

@@ -1,2 +1,15 @@
-import { n as MirrorErrorCode, t as MirrorError } from "../../../errors-CFH4w6ic.mjs";
+//#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 };