@codefast/cli 0.3.15 → 0.3.16-canary.0

package/dist/core/workspace/typescript-walk.mjs

@@ -0,0 +1,36 @@
+import path from "node:path";
+//#region src/core/workspace/typescript-walk.ts
+const defaultSkipDirectoryNames = new Set([
+	"node_modules",
+	"dist",
+	".git",
+	".turbo",
+	".next",
+	".cache",
+	"out",
+	"build",
+	"coverage",
+	".vercel",
+	".output"
+]);
+/**
+* @since 0.3.16-canary.0
+*/
+function walkTsxFiles(rootDirectoryPath, fs) {
+	const result = [];
+	visitTsxPaths(result, rootDirectoryPath, fs);
+	return result;
+}
+function visitTsxPaths(result, entryPath, fs) {
+	if (fs.statSync(entryPath).isDirectory()) {
+		for (const childName of fs.readdirSync(entryPath)) {
+			if (defaultSkipDirectoryNames.has(childName)) continue;
+			visitTsxPaths(result, path.join(entryPath, childName), fs);
+		}
+		return;
+	}
+	if (entryPath.endsWith(".d.ts")) return;
+	if (entryPath.endsWith(".tsx") || entryPath.endsWith(".ts")) result.push(entryPath);
+}
+//#endregion
+export { walkTsxFiles };

package/dist/{domains/mirror/application/mirror-sync-cli-result.mjs → mirror/cli-result.mjs}

@@ -1,8 +1,14 @@
-import "../../../shell/domain/cli-exit-codes.domain.mjs";
-//#region src/domains/mirror/application/mirror-sync-cli-result.ts
+import "../core/exit-codes.mjs";
+//#region src/mirror/cli-result.ts
+/**
+* @since 0.3.16-canary.0
+*/
 function exitCodeForMirrorSyncResult(stats) {
 	return stats.packagesErrored > 0 ? 1 : 0;
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function formatMirrorSyncJsonOutput(stats, elapsedSeconds) {
 	return JSON.stringify({
 		schemaVersion: 1,

package/dist/{domains/mirror/presentation/presenters/mirror-cli.schema.mjs → mirror/cli-schema.mjs}

@@ -1,5 +1,8 @@
 import { z } from "zod";
-//#region src/domains/mirror/presentation/presenters/mirror-cli.schema.ts
+//#region src/mirror/cli-schema.ts
+/**
+* @since 0.3.16-canary.0
+*/
 const mirrorSyncRunRequestSchema = z.object({
 	rootDir: z.string().min(1),
 	packageFilter: z.string().optional(),

package/dist/mirror/command.mjs

@@ -0,0 +1,57 @@
+import { parseWithSchema } from "../core/schema-parse.mjs";
+import { logger } from "../core/logger.mjs";
+import { consumeCliAppError } from "../core/cli/result-handle.mjs";
+import { nodeFilesystem } from "../core/filesystem/node.mjs";
+import { readOptionalPositionalArg } from "../core/cli/positional.mjs";
+import { globalCliCommanderOptionsSchema } from "../core/cli/global-options.mjs";
+import { prepareMirrorSync } from "./prepare.mjs";
+import { runMirrorSync } from "./sync.mjs";
+import { mirrorSyncRunRequestSchema } from "./cli-schema.mjs";
+import { exitCodeForMirrorSyncResult, formatMirrorSyncJsonOutput } from "./cli-result.mjs";
+import { MirrorSyncProgressPresenter } from "./output.mjs";
+import process from "node:process";
+import { Command } from "commander";
+//#region src/mirror/command.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function createMirrorCommand() {
+	const cmd = new Command("mirror").description("Keep package manifests aligned with what you ship");
+	cmd.command("sync").description("Write package.json exports from dist/ for workspace packages").argument("[package]", "Optional package path relative to repo root (e.g. packages/ui)").option("-v, --verbose", "Print extra diagnostics", false).option("--json", "Print one JSON summary on stdout (suppresses human progress)", false).action(async (packageArg, opts, command) => {
+		const globalOptionsOutcome = parseWithSchema(globalCliCommanderOptionsSchema, command.optsWithGlobals?.() ?? command.opts());
+		if (!consumeCliAppError(globalOptionsOutcome)) return;
+		const prelude = await prepareMirrorSync(nodeFilesystem, {
+			currentWorkingDirectory: process.cwd(),
+			packageArg: readOptionalPositionalArg(packageArg),
+			globals: globalOptionsOutcome.value
+		});
+		if (!consumeCliAppError(prelude)) return;
+		const { rootDir, config, packageFilter } = prelude.value;
+		const parsed = parseWithSchema(mirrorSyncRunRequestSchema, {
+			rootDir,
+			config: config.mirror ?? {},
+			packageFilter
+		});
+		if (!consumeCliAppError(parsed)) return;
+		const json = !!opts.json;
+		const noColor = globalOptionsOutcome.value.color === false;
+		const verbose = !!opts.verbose;
+		const progressPresenter = new MirrorSyncProgressPresenter();
+		const listener = json ? void 0 : progressPresenter;
+		if (!json) progressPresenter.configure({
+			noColor,
+			verbose
+		});
+		const startTime = performance.now();
+		const outcome = await runMirrorSync(nodeFilesystem, {
+			...parsed.value,
+			listener
+		});
+		if (!consumeCliAppError(outcome)) return;
+		if (json) logger.out(formatMirrorSyncJsonOutput(outcome.value, (performance.now() - startTime) / 1e3));
+		process.exitCode = exitCodeForMirrorSyncResult(outcome.value);
+	});
+	return cmd;
+}
+//#endregion
+export { createMirrorCommand };

package/dist/mirror/dist-filesystem-impl.mjs

@@ -0,0 +1,42 @@
+import { normalizePath } from "./domain/path-normalizer.mjs";
+import { isDirentList } from "./domain/dirent-guard.mjs";
+import path from "node:path";
+//#region src/mirror/dist-filesystem-impl.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function createMirrorDistFilesystem(fs) {
+	return {
+		async listRelativeFilesRecursively(dirPath) {
+			try {
+				const raw = await fs.readdir(dirPath, {
+					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(dirPath, fullPath));
+				});
+			} catch (caughtError) {
+				if (isKnownReadDirError(caughtError)) return [];
+				throw caughtError;
+			}
+		},
+		async isDirectoryCssOnly(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 isKnownReadDirError(caughtError) {
+	return typeof caughtError === "object" && caughtError !== null && "code" in caughtError && (caughtError.code === "ENOENT" || caughtError.code === "EACCES");
+}
+//#endregion
+export { createMirrorDistFilesystem };

package/dist/{domains/mirror/domain/constants.domain.mjs → mirror/domain/constants.mjs}

@@ -1,16 +1,31 @@
-//#region src/domains/mirror/domain/constants.domain.ts
+//#region src/mirror/domain/constants.ts
+/**
+* @since 0.3.16-canary.0
+*/
 const DIST_DIR = "dist";
+/**
+* @since 0.3.16-canary.0
+*/
 const PACKAGE_JSON = "package.json";
+/**
+* @since 0.3.16-canary.0
+*/
 const VALID_JS_EXTENSIONS = new Set([
 	".js",
 	".mjs",
 	".cjs"
 ]);
+/**
+* @since 0.3.16-canary.0
+*/
 const VALID_DTS_EXTENSIONS = new Set([
 	".d.ts",
 	".d.mts",
 	".d.cts"
 ]);
+/**
+* @since 0.3.16-canary.0
+*/
 const PACKAGE_JSON_EXPORT = "./package.json";
 //#endregion
 export { DIST_DIR, PACKAGE_JSON, PACKAGE_JSON_EXPORT, VALID_DTS_EXTENSIONS, VALID_JS_EXTENSIONS };

package/dist/{domains/mirror/infrastructure/guards/dirent-list.guard.mjs → mirror/domain/dirent-guard.mjs}

@@ -1,10 +1,13 @@
-//#region src/domains/mirror/infrastructure/guards/dirent-list.guard.ts
+//#region src/mirror/domain/dirent-guard.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) {
+*
+* @since 0.3.16-canary.0
+*/
+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;

package/dist/{domains/mirror/domain/errors.domain.mjs → mirror/domain/errors.mjs}

@@ -1,8 +1,14 @@
-//#region src/domains/mirror/domain/errors.domain.ts
+//#region src/mirror/domain/errors.ts
+/**
+* @since 0.3.16-canary.0
+*/
 const MirrorErrorCode = {
 	FATAL: "FATAL",
 	PACKAGE_WRITE: "PACKAGE_WRITE"
 };
+/**
+* @since 0.3.16-canary.0
+*/
 var MirrorError = class extends Error {
 	code;
 	constructor(code, message, options) {

package/dist/{domains/mirror/domain/generate-mirror-exports.domain-service.mjs → mirror/domain/exports.mjs}

@@ -1,10 +1,11 @@
-import { PACKAGE_JSON_EXPORT, VALID_DTS_EXTENSIONS, VALID_JS_EXTENSIONS } from "./constants.domain.mjs";
-//#region src/domains/mirror/domain/generate-mirror-exports.domain-service.ts
+import { PACKAGE_JSON_EXPORT, VALID_DTS_EXTENSIONS, VALID_JS_EXTENSIONS } from "./constants.mjs";
+import * as nodePath from "node:path";
+//#region src/mirror/domain/exports.ts
 function resolvePackageScopedConfig(configMap, pkgMeta) {
 	if (!configMap) return;
 	return configMap[pkgMeta.packageName];
 }
-function groupFilesByModule(files, pathService) {
+function groupFilesByModule(files) {
 	const modules = /* @__PURE__ */ new Map();
 	for (const file of files) {
 		let ext;
@@ -14,11 +15,11 @@ function groupFilesByModule(files, pathService) {
 			ext = dtsExt;
 			modulePath = file.slice(0, -dtsExt.length);
 		} else {
-			ext = pathService.extname(file);
+			ext = nodePath.extname(file);
 			if (!VALID_JS_EXTENSIONS.has(ext)) continue;
 			modulePath = file.slice(0, -ext.length);
 		}
-		if (!pathService.basename(modulePath)) continue;
+		if (!nodePath.basename(modulePath)) continue;
 		let distModule = modules.get(modulePath);
 		if (!distModule) {
 			distModule = {
@@ -103,6 +104,9 @@ function getExportGroup(exportPath, pathTransform) {
 		1
 	];
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function createPathTransform(config, pkgMeta) {
 	const pathConfig = resolvePackageScopedConfig(config?.pathTransformations, pkgMeta);
 	if (!pathConfig) return null;
@@ -131,7 +135,7 @@ function compareTuples(left, right) {
 	if (left[3] !== right[3]) return left[3] < right[3] ? -1 : 1;
 	return 0;
 }
-async function generateCssExports(pathService, fileSystemService, distDir, cssConfig) {
+async function generateCssExports(fileSystemService, distDir, cssConfig) {
 	if (cssConfig === false) return {};
 	if (cssConfig === true) cssConfig = { enabled: true };
 	if (!cssConfig || cssConfig.enabled === false) return {};
@@ -141,7 +145,7 @@ async function generateCssExports(pathService, fileSystemService, distDir, cssCo
 	const cssByDir = /* @__PURE__ */ new Map();
 	const rootCss = [];
 	for (const file of cssFiles) {
-		const dirName = pathService.dirname(file).split(pathService.separator).join("/");
+		const dirName = nodePath.dirname(file).split(nodePath.sep).join("/");
 		if (dirName === ".") rootCss.push(file);
 		else {
 			const arr = cssByDir.get(dirName) || [];
@@ -164,7 +168,10 @@ async function generateCssExports(pathService, fileSystemService, distDir, cssCo
 }
 /**
 * Compute `package.json#exports` from a built `dist/` tree. No logging; no writes.
-*/ async function generateExports(pathService, fileSystemService, distDir, pathTransform, cssConfig, customExports) {
+*
+* @since 0.3.16-canary.0
+*/
+async function generateExports(fileSystemService, distDir, pathTransform, cssConfig, customExports) {
 	const files = await fileSystemService.listRelativeFilesRecursively(distDir);
 	if (!files.length) return {
 		exports: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
@@ -172,7 +179,7 @@ async function generateCssExports(pathService, fileSystemService, distDir, cssCo
 		jsCount: 0,
 		cssCount: 0
 	};
-	const modules = groupFilesByModule(files, pathService);
+	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 },
@@ -198,7 +205,7 @@ async function generateCssExports(pathService, fileSystemService, distDir, cssCo
 	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(pathService, fileSystemService, distDir, cssConfig ?? { enabled: true });
+	const cssExports = await generateCssExports(fileSystemService, 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;

package/dist/{domains/mirror/domain/package-display-name.policy.mjs → mirror/domain/package-display-name.mjs}

@@ -1,7 +1,10 @@
-//#region src/domains/mirror/domain/package-display-name.policy.ts
+//#region src/mirror/domain/package-display-name.ts
 /**
 * Domain rule: prefer `package.json#name` when it is present, otherwise use folder basename.
-*/ function resolvePackageDisplayName(packageJson, folderBasename) {
+*
+* @since 0.3.16-canary.0
+*/
+function resolvePackageDisplayName(packageJson, folderBasename) {
 	const declaredName = packageJson.name;
 	return typeof declaredName === "string" && declaredName.length > 0 ? declaredName : folderBasename;
 }

package/dist/{domains/mirror/domain/path-normalizer.value-object.mjs → mirror/domain/path-normalizer.mjs}

@@ -1,5 +1,8 @@
 import path from "node:path";
-//#region src/domains/mirror/domain/path-normalizer.value-object.ts
+//#region src/mirror/domain/path-normalizer.ts
+/**
+* @since 0.3.16-canary.0
+*/
 function normalizePath(pathString) {
 	return pathString.split(path.sep).join("/").replace(/\\/g, "/");
 }

package/dist/mirror/output.mjs

@@ -0,0 +1,45 @@
+import { logger } from "../core/logger.mjs";
+import { MirrorSyncReporter } from "./sync-reporter.mjs";
+//#region src/mirror/output.ts
+const cliLogger = logger;
+/**
+* @since 0.3.16-canary.0
+*/
+var MirrorSyncProgressPresenter = class {
+	reporter = new MirrorSyncReporter();
+	verbose = false;
+	configure(options) {
+		this.verbose = options.verbose;
+		this.reporter.configureMirrorColors(options.noColor);
+	}
+	onBanner() {
+		this.reporter.mirrorBanner(cliLogger);
+	}
+	onProcessingMode(mode) {
+		this.reporter.mirrorProcessingMode(cliLogger, mode);
+	}
+	onNoPackages() {
+		this.reporter.mirrorNoPackages(cliLogger);
+	}
+	onPackageComplete(pkgStats, ordinal, total) {
+		if (pkgStats.skipped) {
+			this.reporter.logSkippedWorkspacePackage(cliLogger, ordinal, total, pkgStats.name, pkgStats.skipReason);
+			return;
+		}
+		if (pkgStats.error !== null) {
+			this.reporter.logPackageError(cliLogger, ordinal, total, pkgStats.name, pkgStats.error, this.verbose);
+			return;
+		}
+		for (const exportSpecifier of pkgStats.prunedExportKeys) this.reporter.logPrunedStaleExport(cliLogger, exportSpecifier);
+		this.reporter.logPackageSuccess(cliLogger, ordinal, total, pkgStats, {
+			jsCount: pkgStats.jsModules,
+			cssCount: pkgStats.cssExports
+		}, this.verbose);
+	}
+	onComplete(stats, elapsedSeconds) {
+		this.reporter.mirrorSummarySeparator(cliLogger);
+		this.reporter.mirrorSummary(cliLogger, stats, elapsedSeconds);
+	}
+};
+//#endregion
+export { MirrorSyncProgressPresenter };

package/dist/mirror/package-path.mjs

@@ -0,0 +1,32 @@
+import { AppError } from "../core/errors.mjs";
+import { err, ok } from "../core/result.mjs";
+import { normalizePath } from "./domain/path-normalizer.mjs";
+import path from "node:path";
+//#region src/mirror/package-path.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function resolveMirrorPackageFromCliArg(fs, args) {
+	const { rootDir, packageArg, currentWorkingDirectory } = args;
+	if (!packageArg) return ok(void 0);
+	const rootReal = fs.canonicalPathSync(path.resolve(rootDir));
+	const cwdReal = fs.canonicalPathSync(currentWorkingDirectory);
+	const resolved = path.isAbsolute(packageArg) ? path.resolve(packageArg) : path.resolve(cwdReal, packageArg);
+	const targetReal = fs.canonicalPathSync(resolved);
+	const normalized = normalizePath(path.relative(rootReal, targetReal));
+	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized === "" || normalized === ".") return err(new AppError("VALIDATION_ERROR", `Package path must be a subdirectory under monorepo root: ${rootDir}`));
+	return ok(normalized);
+}
+/**
+* @since 0.3.16-canary.0
+*/
+function resolvePackageFilterUnderRoot(fs, rootDir, packageFilter) {
+	const rootResolved = path.resolve(rootDir);
+	const rootReal = fs.canonicalPathSync(rootResolved);
+	const resolved = path.isAbsolute(packageFilter) ? fs.canonicalPathSync(path.resolve(packageFilter)) : fs.canonicalPathSync(path.join(rootReal, packageFilter));
+	const normalized = normalizePath(path.relative(rootReal, resolved));
+	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized === "" || normalized === ".") return err(new AppError("VALIDATION_ERROR", `Package path must be a subdirectory under monorepo root: ${rootDir}`));
+	return ok(normalized);
+}
+//#endregion
+export { resolveMirrorPackageFromCliArg, resolvePackageFilterUnderRoot };

package/dist/mirror/prepare.mjs

@@ -0,0 +1,33 @@
+import { AppError, messageFrom } from "../core/errors.mjs";
+import { err, ok } from "../core/result.mjs";
+import { loadCodefastConfig } from "../core/config.mjs";
+import { findRepoRoot } from "../core/workspace/resolver.mjs";
+import { resolveMirrorPackageFromCliArg } from "./package-path.mjs";
+//#region src/mirror/prepare.ts
+/**
+* @since 0.3.16-canary.0
+*/
+async function prepareMirrorSync(fs, args) {
+	let rootDir;
+	try {
+		rootDir = findRepoRoot(args.currentWorkingDirectory, fs);
+	} catch (caughtError) {
+		return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+	}
+	const filterOutcome = resolveMirrorPackageFromCliArg(fs, {
+		rootDir,
+		packageArg: args.packageArg,
+		currentWorkingDirectory: args.currentWorkingDirectory
+	});
+	if (!filterOutcome.ok) return filterOutcome;
+	const loadedOutcome = await loadCodefastConfig(rootDir, fs);
+	if (!loadedOutcome.ok) return loadedOutcome;
+	return ok({
+		globals: args.globals,
+		rootDir,
+		config: loadedOutcome.value.config,
+		packageFilter: filterOutcome.value
+	});
+}
+//#endregion
+export { prepareMirrorSync };

package/dist/mirror/sync-reporter.mjs

@@ -0,0 +1,104 @@
+import { messageFrom } from "../core/errors.mjs";
+import process from "node:process";
+//#region src/mirror/sync-reporter.ts
+const ANSI = {
+	reset: "\x1B[0m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	cyan: "\x1B[36m",
+	gray: "\x1B[90m",
+	magenta: "\x1B[35m",
+	brightGreen: "\x1B[92m",
+	brightCyan: "\x1B[96m"
+};
+/**
+* Console implementation: ANSI styling and layout for mirror sync.
+*
+* @since 0.3.16-canary.0
+*/
+var MirrorSyncReporter = class {
+	colorsAreEnabled = true;
+	configureMirrorColors(noColor) {
+		this.colorsAreEnabled = !!process.stdout.isTTY && !noColor;
+	}
+	mirrorBanner(logger) {
+		logger.out(`\n${this.paint("📦 Mirror — package exports", ANSI.bold + ANSI.cyan)}`);
+		logger.out(`${this.paint("═".repeat(60), ANSI.dim)}\n`);
+	}
+	mirrorProcessingMode(logger, mode) {
+		if (mode.kind === "single") {
+			logger.out(`${this.paint("Processing single package...", ANSI.dim)}\n`);
+			return;
+		}
+		if (mode.source === "default-patterns") {
+			logger.out(`${this.paint("Discovering workspace packages using default patterns (packages/*)…", ANSI.dim)}\n`);
+			return;
+		}
+		if (mode.source === "pnpm-workspace-yaml") {
+			logger.out(`${this.paint("Discovering workspace packages from pnpm-workspace.yaml…", ANSI.dim)}\n`);
+			return;
+		}
+		logger.out(`${this.paint("pnpm-workspace.yaml declares an empty workspace package list.", ANSI.dim)}\n`);
+	}
+	mirrorNoPackages(logger) {
+		logger.out(this.paint("⚠ No packages found", ANSI.yellow));
+	}
+	logSkippedWorkspacePackage(logger, index, total, displayName, reason) {
+		const progress = this.paint(`[${index}/${total}]`, ANSI.dim);
+		logger.out(`${progress} ${this.paint("○", ANSI.gray)} ${this.paint(displayName, ANSI.dim)}`);
+		logger.out(`  ${this.paint("└─", ANSI.dim)} ${this.paint(`Skipped: ${reason}`, ANSI.gray)}`);
+		logger.out("");
+	}
+	logPackageSuccess(logger, index, total, pkgStats, generatedDistAssetCounts, verbose) {
+		const progress = this.paint(`[${index}/${total}]`, ANSI.dim);
+		logger.out(`${progress} ${this.paint("✓", ANSI.brightGreen)} ${this.paint(pkgStats.name, ANSI.bold)}`);
+		if (verbose) {
+			logger.out(`  ${this.paint("├─", ANSI.dim)} Path: ${pkgStats.path}`);
+			if (pkgStats.hasTransform) logger.out(`  ${this.paint("├─", ANSI.dim)} ${this.paint("Custom path transformation", ANSI.cyan)}`);
+			if (pkgStats.cssConfigStatus) {
+				const status = pkgStats.cssConfigStatus === "disabled" ? "CSS disabled" : "CSS configured";
+				logger.out(`  ${this.paint("├─", ANSI.dim)} ${this.paint(status, ANSI.cyan)}`);
+			}
+		}
+		const breakdown = [];
+		if (generatedDistAssetCounts.jsCount > 0) breakdown.push(this.paint(`${generatedDistAssetCounts.jsCount} modules`, ANSI.green));
+		if (generatedDistAssetCounts.cssCount > 0) breakdown.push(this.paint(`${generatedDistAssetCounts.cssCount} CSS`, ANSI.magenta));
+		if (pkgStats.customExports > 0) breakdown.push(this.paint(`${pkgStats.customExports} custom`, ANSI.yellow));
+		const totalExportsText = this.paint(`${pkgStats.totalExports} exports`, ANSI.brightCyan);
+		if (breakdown.length === 0) logger.out(`  ${this.paint("└─", ANSI.dim)} ${totalExportsText}`);
+		else logger.out(`  ${this.paint("└─", ANSI.dim)} ${breakdown.join(" + ")} = ${totalExportsText}`);
+		logger.out("");
+	}
+	logPrunedStaleExport(logger, exportSpecifier) {
+		logger.out(`  ${this.paint("└─", ANSI.dim)} ${this.paint(`Pruned stale export: ${exportSpecifier}`, ANSI.gray)}`);
+	}
+	logPackageError(logger, index, total, displayName, errorValue, verbose) {
+		logger.out(`${this.paint(`[${index}/${total}]`, ANSI.dim)} ${this.paint("✗", ANSI.yellow)} ${this.paint(displayName, ANSI.bold)}`);
+		logger.out(`  ${this.paint("└─", ANSI.dim)} ${this.paint(`Error: ${messageFrom(errorValue)}`, ANSI.yellow)}\n`);
+		if (verbose) logger.err(errorValue instanceof Error && errorValue.stack ? errorValue.stack : messageFrom(errorValue));
+	}
+	mirrorSummarySeparator(logger) {
+		logger.out(this.paint("═".repeat(60), ANSI.dim));
+	}
+	mirrorSummary(logger, stats, elapsedSeconds) {
+		logger.out(`${this.paint("📊 Summary", ANSI.bold)} ${this.paint(`(completed in ${elapsedSeconds.toFixed(2)}s)`, ANSI.dim)}\n`);
+		logger.out(`  ${this.paint("Packages:", ANSI.bold)}`);
+		logger.out(`  ${this.paint("├─", ANSI.dim)} Processed: ${this.paint(String(stats.packagesProcessed), ANSI.green)}`);
+		if (stats.packagesSkipped > 0) logger.out(`  ${this.paint("├─", ANSI.dim)} Skipped: ${this.paint(String(stats.packagesSkipped), ANSI.gray)}`);
+		if (stats.packagesErrored > 0) logger.out(`  ${this.paint("├─", ANSI.dim)} Errors: ${this.paint(String(stats.packagesErrored), ANSI.yellow)}`);
+		logger.out(`  ${this.paint("└─", ANSI.dim)} Total found: ${stats.packagesFound}\n`);
+		logger.out(`  ${this.paint("Exports:", ANSI.bold)}`);
+		logger.out(`  ${this.paint("├─", ANSI.dim)} JS Modules: ${this.paint(String(stats.totalJsModules), ANSI.cyan)}`);
+		logger.out(`  ${this.paint("├─", ANSI.dim)} CSS Files: ${this.paint(String(stats.totalCssExports), ANSI.magenta)}`);
+		logger.out(`  ${this.paint("└─", ANSI.dim)} Total: ${this.paint(String(stats.totalExports), ANSI.brightCyan)}\n`);
+		logger.out(`${this.paint("═".repeat(60), ANSI.dim)}\n`);
+	}
+	paint(text, openSequence) {
+		if (!this.colorsAreEnabled) return text;
+		return `${openSequence}${text}${ANSI.reset}`;
+	}
+};
+//#endregion
+export { MirrorSyncReporter };

package/dist/mirror/sync-workspace-package.mjs

@@ -0,0 +1,103 @@
+import { messageFrom } from "../core/errors.mjs";
+import { DIST_DIR, PACKAGE_JSON } from "./domain/constants.mjs";
+import { createPathTransform, generateExports } from "./domain/exports.mjs";
+import { resolvePackageDisplayName } from "./domain/package-display-name.mjs";
+import { writePackageJsonExportsAtomic } from "./write-exports.mjs";
+import { createMirrorDistFilesystem } from "./dist-filesystem-impl.mjs";
+import path from "node:path";
+//#region src/mirror/sync-workspace-package.ts
+/**
+* @since 0.3.16-canary.0
+*/
+async function syncExportsForWorkspacePackage(fs, rootDir, packagePathStr, config) {
+	const pathJoin = path.join;
+	const pathResolve = path.resolve;
+	const pathBasename = path.basename;
+	const packageDir = pathResolve(rootDir, packagePathStr);
+	const distDir = pathJoin(packageDir, DIST_DIR);
+	const packageJsonPath = pathJoin(packageDir, PACKAGE_JSON);
+	const folderBasename = pathBasename(packageDir);
+	const distFilesystem = createMirrorDistFilesystem(fs);
+	const pkgStats = {
+		name: folderBasename,
+		path: packageDir,
+		jsModules: 0,
+		cssExports: 0,
+		customExports: 0,
+		totalExports: 0,
+		hasTransform: false,
+		cssConfigStatus: "",
+		skipped: false,
+		skipReason: "",
+		error: null,
+		prunedExportKeys: []
+	};
+	if (!fs.existsSync(packageJsonPath)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "package.json not found";
+		return pkgStats;
+	}
+	let packageJsonParseError;
+	let parsedPackageJson;
+	try {
+		const packageContent = await fs.readFile(packageJsonPath, "utf8");
+		const rawPackageJson = JSON.parse(packageContent);
+		if (rawPackageJson === null || typeof rawPackageJson !== "object" || Array.isArray(rawPackageJson)) throw new SyntaxError("package.json root must be a JSON object");
+		parsedPackageJson = rawPackageJson;
+		pkgStats.name = resolvePackageDisplayName(parsedPackageJson, folderBasename);
+	} catch (caughtError) {
+		pkgStats.name = folderBasename;
+		packageJsonParseError = caughtError;
+	}
+	const packageMeta = { packageName: pkgStats.name };
+	if (isPackageSkipped(config.skipPackages, packageMeta)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "configured to skip";
+		return pkgStats;
+	}
+	if (packageJsonParseError !== void 0) {
+		if (!fs.existsSync(distDir)) {
+			pkgStats.skipped = true;
+			pkgStats.skipReason = "dist/ not found";
+			return pkgStats;
+		}
+		pkgStats.error = messageFrom(packageJsonParseError);
+		return pkgStats;
+	}
+	if (!fs.existsSync(distDir)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "dist/ not found";
+		return pkgStats;
+	}
+	try {
+		const pathTransform = createPathTransform(config, packageMeta);
+		pkgStats.hasTransform = !!pathTransform;
+		const cssConfig = resolvePackageScopedConfig(config.cssExports, packageMeta);
+		if (cssConfig === false) pkgStats.cssConfigStatus = "disabled";
+		else if (cssConfig !== void 0) pkgStats.cssConfigStatus = "configured";
+		const customExports = resolvePackageScopedConfig(config.customExports, packageMeta) || {};
+		const generatedExports = await generateExports(distFilesystem, distDir, pathTransform, cssConfig, customExports);
+		const { prunedKeys } = await writePackageJsonExportsAtomic(fs, packageJsonPath, {
+			generatedExports: generatedExports.exports,
+			managedExportSpecifiers: Object.keys(generatedExports.exports),
+			originalPathBySpecifier: generatedExports.originalPathBySpecifier
+		});
+		pkgStats.jsModules = generatedExports.jsCount;
+		pkgStats.cssExports = generatedExports.cssCount;
+		pkgStats.customExports = Object.keys(customExports).length;
+		pkgStats.totalExports = Object.keys(generatedExports.exports).length;
+		pkgStats.prunedExportKeys = prunedKeys;
+	} catch (caughtError) {
+		pkgStats.error = messageFrom(caughtError);
+	}
+	return pkgStats;
+}
+function resolvePackageScopedConfig(configMap, packageMeta) {
+	if (!configMap) return;
+	return configMap[packageMeta.packageName];
+}
+function isPackageSkipped(skipPackagesList, packageMeta) {
+	return !!skipPackagesList?.includes(packageMeta.packageName);
+}
+//#endregion
+export { syncExportsForWorkspacePackage };