@cbnventures/nova 0.12.0 → 0.13.0

package/build/src/cli/recipe/sync-packages.js

@@ -0,0 +1,1212 @@
+import { dirname, join, relative, sep, } from 'path';
+import chalk from 'chalk';
+import { NodeReleases } from '../../api/node-releases.js';
+import { SpdxLicenses } from '../../api/spdx-licenses.js';
+import { itemPackageJsonKeysBundler, itemPackageJsonKeysCorepack, itemPackageJsonKeysNodeJs, itemPackageJsonKeysNpm, itemPackageJsonSortOrder, } from '../../lib/item.js';
+import { NovaConfig } from '../../lib/nova-config.js';
+import { PATTERN_DIGITS, PATTERN_NAME_AT_VERSION, PATTERN_RANGE_CAPTURE_REMAINDER, PATTERN_RANGE_GREATER_EQUAL_MAJOR, PATTERN_RANGE_MAJOR, PATTERN_SEMVER_STRICT, } from '../../lib/regex.js';
+import { isPlainObject, isProjectRoot, loadWorkspaceManifests, pathExists, saveWorkspaceManifest, } from '../../lib/utility.js';
+import { Logger } from '../../toolkit/index.js';
+export class CLIRecipeSyncPackages {
+    static async run(options) {
+        const currentDirectory = process.cwd();
+        const isAtProjectRoot = await isProjectRoot(currentDirectory);
+        if (isAtProjectRoot !== true) {
+            process.exitCode = 1;
+            return;
+        }
+        const isDryRun = options.dryRun === true;
+        const isIgnoreUnknown = options.ignoreUnknown === true;
+        const isReplaceFile = options.replaceFile === true;
+        if (isDryRun === true) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.run',
+                purpose: 'options',
+            }).warn('Dry run enabled. File changes will not be made in this session.');
+        }
+        if (isIgnoreUnknown === true) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.run',
+                purpose: 'options',
+            }).warn('Ignore unknown enabled. Unknown keys from the "package.json" file will ignored.');
+        }
+        if (isReplaceFile === true) {
+            const replaceFileNotice = (isDryRun) ? 'This option has no effect during a dry run session.' : 'Backup file will not be created.';
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.run',
+                purpose: 'options',
+            }).warn(`Replace file enabled. ${replaceFileNotice}`);
+        }
+        const novaConfig = new NovaConfig();
+        const workingFile = await novaConfig.load();
+        const workingFileWorkspaces = Object.entries(workingFile.workspaces ?? {});
+        if (workingFileWorkspaces.length === 0) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.run',
+                purpose: 'workspaces',
+            }).warn('Skipping package sync. No workspaces detected in the "nova.config.json" file.');
+            return;
+        }
+        const workspaces = await loadWorkspaceManifests({
+            projectRoot: currentDirectory,
+            workspaces: workingFileWorkspaces,
+        });
+        if (workspaces.length === 0) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.run',
+                purpose: 'workspaces',
+            }).warn('Skipping package sync. No accessible "package.json" files were found for the configured workspaces.');
+            return;
+        }
+        Logger.customize({
+            name: 'CLIRecipeSyncPackages.run',
+            purpose: 'summary',
+        }).info(`Prepared ${workspaces.length} workspace "package.json" file(s) for syncing.`);
+        for (const workspace of workspaces) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.run',
+                purpose: 'iteration',
+            }).info(`Syncing the "${workspace.manifest.name}" workspace ...`);
+            if (isIgnoreUnknown !== true) {
+                CLIRecipeSyncPackages.handleUnknown(workspace);
+            }
+            await CLIRecipeSyncPackages.handleIdentity(workspace, workingFile);
+            CLIRecipeSyncPackages.handleOwnership(workspace, workingFile);
+            CLIRecipeSyncPackages.handleRuntime(workspace);
+            await CLIRecipeSyncPackages.handleArtifacts(workspace);
+            await CLIRecipeSyncPackages.handlePublish(workspace);
+            await CLIRecipeSyncPackages.handleTooling(workspace);
+            CLIRecipeSyncPackages.handleCorepack(workspace);
+            await CLIRecipeSyncPackages.handleEnvironment(workspace);
+            await CLIRecipeSyncPackages.handleDependencies(workspace);
+            CLIRecipeSyncPackages.handleBundler(workspace);
+            CLIRecipeSyncPackages.handleReorder(workspace);
+            if (isDryRun === true) {
+                continue;
+            }
+            await saveWorkspaceManifest(workspace, isReplaceFile);
+        }
+    }
+    static async handleIdentity(workspace, workingFile) {
+        const { fileContents, filePath, manifest } = workspace;
+        const packageName = fileContents['name'];
+        const packageVersion = fileContents['version'];
+        const packageDescription = fileContents['description'];
+        const packageKeywords = fileContents['keywords'];
+        const packageLicense = fileContents['license'];
+        if (typeof packageName !== 'string'
+            || packageName !== manifest.name) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleIdentity',
+                purpose: 'name',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "name" from workspace manifest ...`);
+            Reflect.set(fileContents, 'name', manifest.name);
+        }
+        if (typeof packageVersion !== 'string'
+            || !PATTERN_SEMVER_STRICT.test(packageVersion)
+            || (['freezable'].includes(manifest.policy)
+                && packageVersion !== '0.0.0') || (['trackable', 'distributable'].includes(manifest.policy)
+            && packageVersion === '0.0.0')) {
+            const validVersion = (manifest.policy === 'freezable') ? '0.0.0' : '0.0.1';
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleIdentity',
+                purpose: 'version',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Invalid version detected. Setting it to "${validVersion}" ...`);
+            Reflect.set(fileContents, 'version', validVersion);
+        }
+        if (packageDescription !== undefined
+            && manifest.policy !== 'distributable') {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleIdentity',
+                purpose: 'description',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "description". Workspace policy "${manifest.policy}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'description');
+        }
+        else {
+            const validDescription = (workingFile.project !== undefined && workingFile.project.description !== undefined) ? workingFile.project.description.short : undefined;
+            if ((manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('description')
+                && validDescription !== undefined)
+                && (typeof packageDescription !== 'string'
+                    || packageDescription !== validDescription)) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleIdentity',
+                    purpose: 'description',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "description" from workspace manifest ...`);
+                Reflect.set(fileContents, 'description', validDescription);
+            }
+            if (manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('description')
+                && validDescription === undefined) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleIdentity',
+                    purpose: 'description',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "description". No description is defined.`);
+                Reflect.deleteProperty(fileContents, 'description');
+            }
+        }
+        if (packageKeywords !== undefined
+            && manifest.policy !== 'distributable') {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleIdentity',
+                purpose: 'keywords',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "keywords". Workspace policy "${manifest.policy}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'keywords');
+        }
+        else {
+            const validKeywords = (workingFile.project !== undefined) ? workingFile.project.keywords : undefined;
+            if ((manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('keywords')
+                && validKeywords !== undefined)
+                && (JSON.stringify(packageKeywords) !== JSON.stringify(validKeywords))) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleIdentity',
+                    purpose: 'keywords',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "keywords" from workspace manifest ...`);
+                Reflect.set(fileContents, 'keywords', validKeywords);
+            }
+            if (manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('keywords')
+                && validKeywords === undefined) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleIdentity',
+                    purpose: 'keywords',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "keywords". No keywords are defined.`);
+                Reflect.deleteProperty(fileContents, 'keywords');
+            }
+        }
+        const spdxLicenses = await SpdxLicenses.fetchLicenses();
+        if (typeof packageLicense !== 'string'
+            || (spdxLicenses !== undefined && !spdxLicenses.has(packageLicense))) {
+            const packageDirectory = dirname(filePath);
+            const projectRoot = process.cwd();
+            const licenseCandidates = [
+                join(packageDirectory, 'LICENSE'),
+                join(packageDirectory, 'LICENSE.md'),
+                join(projectRoot, 'LICENSE'),
+                join(projectRoot, 'LICENSE.md'),
+            ];
+            let resolvedLicensePath;
+            for (const candidate of licenseCandidates) {
+                if (await pathExists(candidate)) {
+                    resolvedLicensePath = candidate;
+                    break;
+                }
+            }
+            const relativeLicensePath = (resolvedLicensePath !== undefined) ? relative(packageDirectory, resolvedLicensePath) : undefined;
+            let normalizedLicenseReference;
+            if (relativeLicensePath !== undefined) {
+                normalizedLicenseReference = (relativeLicensePath.startsWith('.')) ? relativeLicensePath : `./${relativeLicensePath}`;
+            }
+            const fallbackLicense = (normalizedLicenseReference !== undefined) ? `SEE LICENSE IN ${normalizedLicenseReference}` : 'UNLICENSED';
+            if (packageLicense === fallbackLicense) {
+                return;
+            }
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleIdentity',
+                purpose: 'license',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "license" to "${fallbackLicense}" ...`);
+            Reflect.set(fileContents, 'license', fallbackLicense);
+        }
+    }
+    static async handleArtifacts(workspace) {
+        const { fileContents, manifest } = workspace;
+        const packageFiles = fileContents['files'];
+        const packageBin = fileContents['bin'];
+        const packageMan = fileContents['man'];
+        const packageDirectories = fileContents['directories'];
+        if (packageFiles !== undefined
+            && !['package', 'tool'].includes(manifest.role)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleArtifacts',
+                purpose: 'files',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "files". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'files');
+        }
+        else {
+            if ((manifest.role === 'package' || manifest.role === 'tool')
+                && packageFiles !== undefined
+                && CLIRecipeSyncPackages.isEmpty(packageFiles)) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleArtifacts',
+                    purpose: 'files',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "files" ...`);
+                Reflect.deleteProperty(fileContents, 'files');
+            }
+        }
+        if (packageBin !== undefined
+            && !['package', 'tool'].includes(manifest.role)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleArtifacts',
+                purpose: 'bin',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "bin". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'bin');
+        }
+        else {
+            if ((manifest.role === 'package' || manifest.role === 'tool')
+                && packageBin !== undefined) {
+                if (typeof packageBin === 'string') {
+                    const packageName = manifest.name;
+                    const binName = (packageName.includes('/')) ? packageName.split('/').pop() : packageName;
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleArtifacts',
+                        purpose: 'bin',
+                    }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Normalizing "bin" from string to object ...`);
+                    Reflect.set(fileContents, 'bin', {
+                        [binName ?? packageName]: packageBin,
+                    });
+                }
+                else if (CLIRecipeSyncPackages.isEmpty(packageBin)) {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleArtifacts',
+                        purpose: 'bin',
+                    }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "bin" ...`);
+                    Reflect.deleteProperty(fileContents, 'bin');
+                }
+            }
+        }
+        if (packageMan !== undefined
+            && !['package', 'tool'].includes(manifest.role)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleArtifacts',
+                purpose: 'man',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "man". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'man');
+        }
+        else {
+            if ((manifest.role === 'package' || manifest.role === 'tool')
+                && packageMan !== undefined) {
+                if (typeof packageMan === 'string') {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleArtifacts',
+                        purpose: 'man',
+                    }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Normalizing "man" from string to array ...`);
+                    Reflect.set(fileContents, 'man', [packageMan]);
+                }
+                else if (CLIRecipeSyncPackages.isEmpty(packageMan)) {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleArtifacts',
+                        purpose: 'man',
+                    }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "man" ...`);
+                    Reflect.deleteProperty(fileContents, 'man');
+                }
+            }
+        }
+        if (packageDirectories !== undefined
+            && !['package', 'tool'].includes(manifest.role)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleArtifacts',
+                purpose: 'directories',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "directories". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'directories');
+        }
+        else {
+            if ((manifest.role === 'package' || manifest.role === 'tool')
+                && packageDirectories !== undefined
+                && CLIRecipeSyncPackages.isEmpty(packageDirectories)) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleArtifacts',
+                    purpose: 'directories',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "directories" ...`);
+                Reflect.deleteProperty(fileContents, 'directories');
+            }
+        }
+    }
+    static async handlePublish(workspace) {
+        const { fileContents, manifest } = workspace;
+        const packagePrivate = fileContents['private'];
+        const packagePublishConfig = fileContents['publishConfig'];
+        if (typeof packagePrivate !== 'boolean'
+            || (manifest.policy === 'distributable'
+                && packagePrivate)
+            || (manifest.policy !== 'distributable'
+                && !packagePrivate)) {
+            const privateValue = (manifest.policy !== 'distributable');
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handlePublish',
+                purpose: 'private',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "private" to "${privateValue}" ...`);
+            Reflect.set(fileContents, 'private', privateValue);
+        }
+        if (packagePublishConfig !== undefined
+            && manifest.policy !== 'distributable') {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handlePublish',
+                purpose: 'publishConfig',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "publishConfig". Workspace policy "${manifest.policy}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'publishConfig');
+        }
+        else {
+            if (manifest.policy === 'distributable'
+                && packagePublishConfig !== undefined
+                && CLIRecipeSyncPackages.isEmpty(packagePublishConfig)) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handlePublish',
+                    purpose: 'publishConfig',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "publishConfig" ...`);
+                Reflect.deleteProperty(fileContents, 'publishConfig');
+            }
+        }
+    }
+    static async handleTooling(workspace) {
+        const { fileContents, filePath, manifest } = workspace;
+        const packageScripts = fileContents['scripts'];
+        const packageGypfile = fileContents['gypfile'];
+        const packageConfig = fileContents['config'];
+        const packageWorkspaces = fileContents['workspaces'];
+        const hasBindingGyp = await pathExists(join(dirname(filePath), 'binding.gyp'));
+        if (packageScripts === undefined) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleTooling',
+                purpose: 'scripts',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Adding "scripts" as an empty object ...`);
+            Reflect.set(fileContents, 'scripts', {});
+        }
+        if (packageGypfile !== undefined
+            && !hasBindingGyp) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleTooling',
+                purpose: 'gypfile',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "gypfile". No "binding.gyp" file is found.`);
+            Reflect.deleteProperty(fileContents, 'gypfile');
+        }
+        else {
+            if (packageGypfile === undefined
+                && hasBindingGyp
+                && (!isPlainObject(packageScripts)
+                    || (isPlainObject(packageScripts)
+                        && packageScripts['preinstall'] === undefined
+                        && packageScripts['install'] === undefined))) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleTooling',
+                    purpose: 'gypfile',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Adding "gypfile" as the npm default ...`);
+                Reflect.set(fileContents, 'gypfile', true);
+            }
+        }
+        if (packageConfig !== undefined
+            && CLIRecipeSyncPackages.isEmpty(packageConfig)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleTooling',
+                purpose: 'config',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "config" ...`);
+            Reflect.deleteProperty(fileContents, 'config');
+        }
+        if (packageWorkspaces !== undefined
+            && manifest.role !== 'project') {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleTooling',
+                purpose: 'workspaces',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "workspaces". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'workspaces');
+        }
+        else {
+            if (manifest.role === 'project'
+                && packageWorkspaces === undefined) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleTooling',
+                    purpose: 'workspaces',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Adding "workspaces" as an empty array ...`);
+                Reflect.set(fileContents, 'workspaces', []);
+            }
+        }
+    }
+    static async handleEnvironment(workspace) {
+        const { fileContents, manifest } = workspace;
+        const packageEngines = fileContents['engines'];
+        const packageOs = fileContents['os'];
+        const packageCpu = fileContents['cpu'];
+        const packageLibc = fileContents['libc'];
+        const packageDevEngines = fileContents['devEngines'];
+        const ltsConstraint = await NodeReleases.fetchLtsVersions();
+        if (packageEngines === undefined) {
+            if (ltsConstraint !== undefined) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleEnvironment',
+                    purpose: 'engines',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Adding "engines" with "node" set to "${ltsConstraint}" ...`);
+                Reflect.set(fileContents, 'engines', {
+                    node: ltsConstraint,
+                });
+            }
+            else {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleEnvironment',
+                    purpose: 'engines',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Adding "engines" as an empty object ...`);
+                Reflect.set(fileContents, 'engines', {});
+            }
+        }
+        else {
+            if (isPlainObject(packageEngines)
+                && packageEngines['node'] === undefined
+                && ltsConstraint !== undefined) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleEnvironment',
+                    purpose: 'engines',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Adding "engines.node" set to "${ltsConstraint}" ...`);
+                Reflect.set(packageEngines, 'node', ltsConstraint);
+            }
+        }
+        if (manifest.syncLtsEngines === true
+            && isPlainObject(fileContents['engines'])
+            && typeof fileContents['engines']['node'] === 'string'
+            && ltsConstraint !== undefined) {
+            const existingNode = fileContents['engines']['node'];
+            const ltsMatches = [...ltsConstraint.matchAll(new RegExp(PATTERN_DIGITS.source, 'g'))];
+            if (ltsMatches.length > 0) {
+                const ltsMajors = ltsMatches.map((match) => parseInt(match[0], 10));
+                const branches = existingNode.split('||').map((branch) => branch.trim());
+                const coversAll = ltsMajors.every((major) => {
+                    return branches.some((branch) => {
+                        if (branch === '*') {
+                            return true;
+                        }
+                        const geMatch = branch.match(PATTERN_RANGE_GREATER_EQUAL_MAJOR);
+                        if (geMatch !== null) {
+                            return parseInt(geMatch[1] ?? '', 10) <= major;
+                        }
+                        const majorMatch = branch.match(PATTERN_RANGE_MAJOR);
+                        if (majorMatch !== null) {
+                            return parseInt(majorMatch[1] ?? '', 10) === major;
+                        }
+                        return false;
+                    });
+                });
+                if (coversAll !== true) {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleEnvironment',
+                        purpose: 'engines',
+                    }).warn(`${chalk.magenta(`"${manifest.name}" workspace`)} → "engines.node" is "${existingNode}" but must cover all active LTS versions (${ltsMajors.join(', ')}). Run "nova recipe sync-lts-engines" to update.`);
+                }
+            }
+        }
+        if (packageOs !== undefined
+            && CLIRecipeSyncPackages.isEmpty(packageOs)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleEnvironment',
+                purpose: 'os',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "os" ...`);
+            Reflect.deleteProperty(fileContents, 'os');
+        }
+        if (packageCpu !== undefined
+            && CLIRecipeSyncPackages.isEmpty(packageCpu)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleEnvironment',
+                purpose: 'cpu',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "cpu" ...`);
+            Reflect.deleteProperty(fileContents, 'cpu');
+        }
+        if (packageLibc !== undefined
+            && !(Array.isArray(fileContents['os'])
+                && fileContents['os'].includes('linux'))) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleEnvironment',
+                purpose: 'libc',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "libc". Package "os" does not include "linux".`);
+            Reflect.deleteProperty(fileContents, 'libc');
+        }
+        else {
+            if (packageLibc === undefined
+                && (Array.isArray(fileContents['os'])
+                    && fileContents['os'].includes('linux'))) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleEnvironment',
+                    purpose: 'libc',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Adding "libc" as "glibc" ...`);
+                Reflect.set(fileContents, 'libc', ['glibc']);
+            }
+        }
+        if (packageDevEngines !== undefined
+            && CLIRecipeSyncPackages.isEmpty(packageDevEngines)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleEnvironment',
+                purpose: 'devEngines',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "devEngines" ...`);
+            Reflect.deleteProperty(fileContents, 'devEngines');
+        }
+    }
+    static async handleDependencies(workspace) {
+        const { fileContents, manifest } = workspace;
+        const packageDependencies = fileContents['dependencies'];
+        const packageDevDependencies = fileContents['devDependencies'];
+        const packagePeerDependencies = fileContents['peerDependencies'];
+        const packagePeerDependenciesMeta = fileContents['peerDependenciesMeta'];
+        const packageBundleDependencies = fileContents['bundleDependencies'];
+        const packageBundledDependencies = fileContents['bundledDependencies'];
+        const packageOptionalDependencies = fileContents['optionalDependencies'];
+        const packageOverrides = fileContents['overrides'];
+        if (packageDependencies !== undefined
+            && CLIRecipeSyncPackages.isEmpty(packageDependencies)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleDependencies',
+                purpose: 'dependencies',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "dependencies" ...`);
+            Reflect.deleteProperty(fileContents, 'dependencies');
+        }
+        if (packageDevDependencies !== undefined
+            && CLIRecipeSyncPackages.isEmpty(packageDevDependencies)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleDependencies',
+                purpose: 'devDependencies',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "devDependencies" ...`);
+            Reflect.deleteProperty(fileContents, 'devDependencies');
+        }
+        if (packagePeerDependencies !== undefined
+            && CLIRecipeSyncPackages.isEmpty(packagePeerDependencies)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleDependencies',
+                purpose: 'peerDependencies',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "peerDependencies" ...`);
+            Reflect.deleteProperty(fileContents, 'peerDependencies');
+        }
+        if (packagePeerDependenciesMeta !== undefined
+            && CLIRecipeSyncPackages.isEmpty(packagePeerDependenciesMeta)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleDependencies',
+                purpose: 'peerDependenciesMeta',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "peerDependenciesMeta" ...`);
+            Reflect.deleteProperty(fileContents, 'peerDependenciesMeta');
+        }
+        if (packageBundledDependencies !== undefined) {
+            const bundleDependencies = Array.isArray(packageBundleDependencies) ? packageBundleDependencies : [];
+            const bundledDependencies = Array.isArray(packageBundledDependencies) ? packageBundledDependencies : [];
+            const mergedBundleDependencies = [...new Set([...bundleDependencies, ...bundledDependencies])];
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleDependencies',
+                purpose: 'bundleDependencies',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Merging "bundledDependencies" into "bundleDependencies" ...`);
+            Reflect.set(fileContents, 'bundleDependencies', mergedBundleDependencies);
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleDependencies',
+                purpose: 'bundledDependencies',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "bundledDependencies". "bundledDependencies" is an alias of "bundleDependencies".`);
+            Reflect.deleteProperty(fileContents, 'bundledDependencies');
+        }
+        if (fileContents['bundleDependencies'] !== undefined
+            && CLIRecipeSyncPackages.isEmpty(fileContents['bundleDependencies'])) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleDependencies',
+                purpose: 'bundleDependencies',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "bundleDependencies" ...`);
+            Reflect.deleteProperty(fileContents, 'bundleDependencies');
+        }
+        if (packageOptionalDependencies !== undefined
+            && CLIRecipeSyncPackages.isEmpty(packageOptionalDependencies)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleDependencies',
+                purpose: 'optionalDependencies',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "optionalDependencies" ...`);
+            Reflect.deleteProperty(fileContents, 'optionalDependencies');
+        }
+        if (packageOverrides !== undefined
+            && CLIRecipeSyncPackages.isEmpty(packageOverrides)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleDependencies',
+                purpose: 'overrides',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing empty "overrides" ...`);
+            Reflect.deleteProperty(fileContents, 'overrides');
+        }
+        if (manifest.pinVersions === true) {
+            const depGroups = [
+                'dependencies',
+                'devDependencies',
+            ];
+            for (const depGroup of depGroups) {
+                const deps = fileContents[depGroup];
+                if (!isPlainObject(deps)) {
+                    continue;
+                }
+                for (const [depName, depVersion] of Object.entries(deps)) {
+                    if (typeof depVersion !== 'string') {
+                        continue;
+                    }
+                    if (PATTERN_RANGE_CAPTURE_REMAINDER.test(depVersion)) {
+                        Logger.customize({
+                            name: 'CLIRecipeSyncPackages.handleDependencies',
+                            purpose: depGroup,
+                        }).warn(`${chalk.magenta(`"${manifest.name}" workspace`)} → "${depName}" has unpinned version "${depVersion}". Run "nova recipe pin-versions" to fix.`);
+                    }
+                }
+            }
+        }
+    }
+    static handleUnknown(workspace) {
+        const allowedKeys = new Set([
+            ...itemPackageJsonKeysBundler,
+            ...itemPackageJsonKeysCorepack,
+            ...itemPackageJsonKeysNodeJs,
+            ...itemPackageJsonKeysNpm,
+        ]);
+        const manifestContents = workspace.fileContents ?? {};
+        const manifestKeys = Object.keys(manifestContents);
+        const unknownKeys = manifestKeys.filter((key) => !allowedKeys.has(key));
+        if (unknownKeys.length === 0) {
+            return;
+        }
+        Logger.customize({
+            name: 'CLIRecipeSyncPackages.handleUnknown',
+            purpose: 'unsupported',
+        }).warn([
+            `Workspace "${workspace.manifest.name}" contains unsupported "package.json" key(s).`,
+            'The unsupported keys are:',
+            `- "${unknownKeys.join('"\n- "')}"`,
+            'Review the references below:',
+            '- https://cbnventures.github.io/nova/docs/cli/recipes/sync-packages#unsupported-keys',
+        ].join('\n'));
+        for (const unknownKey of unknownKeys) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleUnknown',
+                purpose: 'removal',
+            }).info(`Removing unsupported key "${unknownKey}" from workspace "${workspace.manifest.name}".`);
+            Reflect.deleteProperty(manifestContents, unknownKey);
+        }
+    }
+    static handleOwnership(workspace, workingFile) {
+        const { fileContents, manifest } = workspace;
+        const packageHomepage = fileContents['homepage'];
+        const packageBugs = fileContents['bugs'];
+        const packageAuthor = fileContents['author'];
+        const packageContributors = fileContents['contributors'];
+        const packageFundingSources = fileContents['funding'];
+        const packageRepository = fileContents['repository'];
+        if (packageHomepage !== undefined
+            && manifest.policy !== 'distributable') {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleOwnership',
+                purpose: 'homepage',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "homepage". Workspace policy "${manifest.policy}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'homepage');
+        }
+        else {
+            const validHomepage = (workingFile.urls !== undefined) ? workingFile.urls.homepage : undefined;
+            if ((manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('homepage')
+                && validHomepage !== undefined)
+                && (typeof packageHomepage !== 'string'
+                    || packageHomepage !== validHomepage)) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'homepage',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "homepage" from workspace manifest ...`);
+                Reflect.set(fileContents, 'homepage', validHomepage);
+            }
+            if (manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('homepage')
+                && validHomepage === undefined) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'homepage',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "homepage". No homepage is defined.`);
+                Reflect.deleteProperty(fileContents, 'homepage');
+            }
+        }
+        if (packageBugs !== undefined
+            && manifest.policy !== 'distributable') {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleOwnership',
+                purpose: 'bugs',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "bugs". Workspace policy "${manifest.policy}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'bugs');
+        }
+        else {
+            const validBugs = {
+                email: (workingFile.emails !== undefined) ? workingFile.emails.bugs : undefined,
+                url: (workingFile.urls !== undefined) ? workingFile.urls.bugs : undefined,
+            };
+            if ((manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('bugs')
+                && (validBugs.email !== undefined
+                    || validBugs.url !== undefined))
+                && (JSON.stringify(packageBugs) !== JSON.stringify(validBugs))) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'bugs',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "bugs" from workspace manifest ...`);
+                Reflect.set(fileContents, 'bugs', validBugs);
+            }
+            if (manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('bugs')
+                && (validBugs.email === undefined
+                    && validBugs.url === undefined)) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'bugs',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "bugs". No bug contacts are defined.`);
+                Reflect.deleteProperty(fileContents, 'bugs');
+            }
+        }
+        if (packageAuthor !== undefined
+            && manifest.policy !== 'distributable') {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleOwnership',
+                purpose: 'author',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "author". Workspace policy "${manifest.policy}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'author');
+        }
+        else {
+            const validAuthor = (() => {
+                const entity = (workingFile.entities !== undefined) ? workingFile.entities.find((entity) => {
+                    return Array.isArray(entity.roles) && entity.roles.includes('author');
+                }) : undefined;
+                if (entity === undefined) {
+                    return {
+                        name: undefined,
+                        email: undefined,
+                        url: undefined,
+                    };
+                }
+                return {
+                    name: entity.name,
+                    email: entity.email,
+                    url: entity.url,
+                };
+            })();
+            if ((manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('author')
+                && (validAuthor.name !== undefined
+                    || validAuthor.email !== undefined
+                    || validAuthor.url !== undefined))
+                && (JSON.stringify(packageAuthor) !== JSON.stringify(validAuthor))) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'author',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "author" from workspace manifest ...`);
+                Reflect.set(fileContents, 'author', validAuthor);
+            }
+            if (manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('author')
+                && (validAuthor.name === undefined
+                    && validAuthor.email === undefined
+                    && validAuthor.url === undefined)) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'author',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "author". No author is defined.`);
+                Reflect.deleteProperty(fileContents, 'author');
+            }
+        }
+        if (packageContributors !== undefined
+            && manifest.policy !== 'distributable') {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleOwnership',
+                purpose: 'contributors',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "contributors". Workspace policy "${manifest.policy}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'contributors');
+        }
+        else {
+            const validContributors = (() => {
+                const entities = workingFile.entities ?? [];
+                return entities
+                    .filter((entity) => Array.isArray(entity.roles) && entity.roles.includes('contributor'))
+                    .map((entity) => ({
+                    name: entity.name,
+                    email: entity.email,
+                    url: entity.url,
+                }))
+                    .filter((entity) => entity.name !== undefined || entity.email !== undefined || entity.url !== undefined);
+            })();
+            if ((manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('contributors')
+                && (validContributors.length > 0))
+                && (JSON.stringify(packageContributors) !== JSON.stringify(validContributors))) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'contributors',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "contributors" from workspace manifest ...`);
+                Reflect.set(fileContents, 'contributors', validContributors);
+            }
+            if (manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('contributors')
+                && (validContributors.length === 0)) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'contributors',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "contributors". No contributors are defined.`);
+                Reflect.deleteProperty(fileContents, 'contributors');
+            }
+        }
+        if (packageFundingSources !== undefined
+            && manifest.policy !== 'distributable') {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleOwnership',
+                purpose: 'funding',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "funding". Workspace policy "${manifest.policy}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'funding');
+        }
+        else {
+            const validFundingSources = (workingFile.urls !== undefined) ? workingFile.urls.fundSources : undefined;
+            if ((manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('funding')
+                && validFundingSources !== undefined)
+                && (JSON.stringify(packageFundingSources) !== JSON.stringify(validFundingSources))) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'funding',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "funding" from workspace manifest ...`);
+                Reflect.set(fileContents, 'funding', validFundingSources);
+            }
+            if (manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('funding')
+                && validFundingSources === undefined) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'funding',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "funding". No funding sources are defined.`);
+                Reflect.deleteProperty(fileContents, 'funding');
+            }
+        }
+        if (packageRepository !== undefined
+            && manifest.policy !== 'distributable') {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleOwnership',
+                purpose: 'repository',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "repository". Workspace policy "${manifest.policy}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'repository');
+        }
+        else {
+            const validRepository = (() => {
+                const repositoryUrl = (workingFile.urls !== undefined) ? workingFile.urls.repository : undefined;
+                if (repositoryUrl === undefined) {
+                    return undefined;
+                }
+                const projectRoot = process.cwd();
+                const packageDirectory = dirname(workspace.filePath);
+                const repositoryDirectory = relative(projectRoot, packageDirectory).replaceAll(sep, '/');
+                return {
+                    type: 'git',
+                    url: repositoryUrl,
+                    ...(repositoryDirectory !== '' && repositoryDirectory !== '.' ? {
+                        directory: repositoryDirectory,
+                    } : {}),
+                };
+            })();
+            if ((manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('repository')
+                && validRepository !== undefined)
+                && (JSON.stringify(packageRepository) !== JSON.stringify(validRepository))) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'repository',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "repository" from workspace manifest ...`);
+                Reflect.set(fileContents, 'repository', validRepository);
+            }
+            if (manifest.policy === 'distributable'
+                && manifest.syncProperties !== undefined
+                && manifest.syncProperties.includes('repository')
+                && validRepository === undefined) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleOwnership',
+                    purpose: 'repository',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "repository". No repository url is defined.`);
+                Reflect.deleteProperty(fileContents, 'repository');
+            }
+        }
+    }
+    static handleRuntime(workspace) {
+        const { fileContents, manifest } = workspace;
+        const packageExports = fileContents['exports'];
+        const packageMain = fileContents['main'];
+        const packageType = fileContents['type'];
+        const packageBrowser = fileContents['browser'];
+        const packageImports = fileContents['imports'];
+        if (packageExports !== undefined
+            && !['config', 'package', 'tool'].includes(manifest.role)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleRuntime',
+                purpose: 'exports',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "exports". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'exports');
+        }
+        else {
+            if (manifest.role === 'config'
+                || manifest.role === 'package'
+                || manifest.role === 'tool') {
+                if (typeof packageExports === 'string') {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleRuntime',
+                        purpose: 'exports',
+                    }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Normalizing "exports" from string to object ...`);
+                    Reflect.set(fileContents, 'exports', {
+                        '.': {
+                            default: packageExports,
+                        },
+                    });
+                }
+            }
+        }
+        if (packageMain !== undefined
+            && !['config', 'app', 'package', 'tool'].includes(manifest.role)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleRuntime',
+                purpose: 'main',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "main". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'main');
+        }
+        else {
+            if (manifest.role === 'config'
+                || manifest.role === 'app'
+                || manifest.role === 'package'
+                || manifest.role === 'tool') {
+                const currentPackageExports = fileContents['exports'];
+                if (typeof packageMain === 'string'
+                    && (isPlainObject(currentPackageExports)
+                        && isPlainObject(currentPackageExports['.'])
+                        && typeof currentPackageExports['.']['require'] === 'string')
+                    && packageMain !== currentPackageExports['.']['require']) {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleRuntime',
+                        purpose: 'main',
+                    }).warn(`${chalk.magenta(`"${manifest.name}" workspace`)} → "main" differs from "exports['.'].require". No changes applied.`);
+                }
+                else if (typeof packageMain === 'string'
+                    && (isPlainObject(currentPackageExports)
+                        && isPlainObject(currentPackageExports['.']))
+                    && typeof currentPackageExports['.']['require'] !== 'string') {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleRuntime',
+                        purpose: 'main',
+                    }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "exports['.'].require" from "main" ...`);
+                    Reflect.set(currentPackageExports['.'], 'require', packageMain);
+                }
+                else if ((isPlainObject(currentPackageExports)
+                    && isPlainObject(currentPackageExports['.'])
+                    && typeof currentPackageExports['.']['require'] === 'string')
+                    && typeof packageMain !== 'string') {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleRuntime',
+                        purpose: 'main',
+                    }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "main" from "exports['.'].require" ...`);
+                    Reflect.set(fileContents, 'main', currentPackageExports['.']['require']);
+                }
+                else if (typeof packageMain === 'string'
+                    && isPlainObject(currentPackageExports)
+                    && typeof currentPackageExports['.'] === 'string') {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleRuntime',
+                        purpose: 'main',
+                    }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Normalizing "exports['.']" from string to object ...`);
+                    Reflect.set(currentPackageExports, '.', {
+                        default: currentPackageExports['.'],
+                        require: packageMain,
+                    });
+                }
+            }
+        }
+        if (packageType !== undefined
+            && !['config', 'app', 'package', 'tool'].includes(manifest.role)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleRuntime',
+                purpose: 'type',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "type". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'type');
+        }
+        if (packageBrowser !== undefined
+            && !['package'].includes(manifest.role)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleRuntime',
+                purpose: 'browser',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "browser". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'browser');
+        }
+        else {
+            if (manifest.role === 'package') {
+                const currentPackageExports = fileContents['exports'];
+                if (typeof packageBrowser === 'string'
+                    && (isPlainObject(currentPackageExports)
+                        && isPlainObject(currentPackageExports['.'])
+                        && typeof currentPackageExports['.']['browser'] === 'string')
+                    && packageBrowser !== currentPackageExports['.']['browser']) {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleRuntime',
+                        purpose: 'browser',
+                    }).warn(`${chalk.magenta(`"${manifest.name}" workspace`)} → "browser" differs from "exports['.'].browser". No changes applied.`);
+                }
+                else if (typeof packageBrowser === 'string'
+                    && (isPlainObject(currentPackageExports)
+                        && isPlainObject(currentPackageExports['.']))
+                    && typeof currentPackageExports['.']['browser'] !== 'string') {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleRuntime',
+                        purpose: 'browser',
+                    }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "exports['.'].browser" from "browser" ...`);
+                    Reflect.set(currentPackageExports['.'], 'browser', packageBrowser);
+                }
+                else if ((isPlainObject(currentPackageExports)
+                    && isPlainObject(currentPackageExports['.'])
+                    && typeof currentPackageExports['.']['browser'] === 'string')
+                    && typeof packageBrowser !== 'string'
+                    && !isPlainObject(packageBrowser)) {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleRuntime',
+                        purpose: 'browser',
+                    }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Syncing "browser" from "exports['.'].browser" ...`);
+                    Reflect.set(fileContents, 'browser', currentPackageExports['.']['browser']);
+                }
+                else if (typeof packageBrowser === 'string'
+                    && isPlainObject(currentPackageExports)
+                    && typeof currentPackageExports['.'] === 'string') {
+                    Logger.customize({
+                        name: 'CLIRecipeSyncPackages.handleRuntime',
+                        purpose: 'browser',
+                    }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Normalizing "exports['.']" from string to object ...`);
+                    Reflect.set(currentPackageExports, '.', {
+                        default: currentPackageExports['.'],
+                        browser: packageBrowser,
+                    });
+                }
+            }
+        }
+        if (packageImports !== undefined
+            && !['config', 'app', 'package', 'tool'].includes(manifest.role)) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleRuntime',
+                purpose: 'imports',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "imports". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'imports');
+        }
+    }
+    static handleCorepack(workspace) {
+        const { fileContents, manifest } = workspace;
+        const packageManager = fileContents['packageManager'];
+        if (packageManager !== undefined
+            && manifest.role !== 'project') {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleCorepack',
+                purpose: 'packageManager',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "packageManager". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'packageManager');
+        }
+        else {
+            if (manifest.role === 'project'
+                && packageManager !== undefined
+                && (typeof packageManager !== 'string'
+                    || !PATTERN_NAME_AT_VERSION.test(packageManager))) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleCorepack',
+                    purpose: 'packageManager',
+                }).warn(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "packageManager". Invalid format detected.`);
+                Reflect.deleteProperty(fileContents, 'packageManager');
+            }
+        }
+    }
+    static handleBundler(workspace) {
+        const { fileContents, manifest } = workspace;
+        const packageTypes = fileContents['types'];
+        const packageTypings = fileContents['typings'];
+        const packageModule = fileContents['module'];
+        const packageSideEffects = fileContents['sideEffects'];
+        const packageEsnext = fileContents['esnext'];
+        if (packageTypings !== undefined) {
+            if (packageTypes !== undefined) {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleBundler',
+                    purpose: 'typings',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Merging "typings" into "types". Keeping existing "types" value.`);
+            }
+            else {
+                Logger.customize({
+                    name: 'CLIRecipeSyncPackages.handleBundler',
+                    purpose: 'typings',
+                }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Renaming "typings" to "types" ...`);
+                Reflect.set(fileContents, 'types', packageTypings);
+            }
+            Reflect.deleteProperty(fileContents, 'typings');
+        }
+        const allowsTypesModule = ['config', 'package', 'tool'].includes(manifest.role);
+        const allowsSideEffectsEsnext = ['package'].includes(manifest.role);
+        if (fileContents['types'] !== undefined
+            && !allowsTypesModule) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleBundler',
+                purpose: 'types',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "types". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'types');
+        }
+        if (packageModule !== undefined
+            && !allowsTypesModule) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleBundler',
+                purpose: 'module',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "module". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'module');
+        }
+        if (packageSideEffects !== undefined
+            && !allowsSideEffectsEsnext) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleBundler',
+                purpose: 'sideEffects',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "sideEffects". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'sideEffects');
+        }
+        if (packageEsnext !== undefined
+            && !allowsSideEffectsEsnext) {
+            Logger.customize({
+                name: 'CLIRecipeSyncPackages.handleBundler',
+                purpose: 'esnext',
+            }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Removing "esnext". Workspace role "${manifest.role}" does not allow it.`);
+            Reflect.deleteProperty(fileContents, 'esnext');
+        }
+    }
+    static handleReorder(workspace) {
+        const { fileContents, manifest } = workspace;
+        const sortedKeys = new Set(itemPackageJsonSortOrder);
+        const currentKeys = Object.keys(fileContents);
+        const reordered = {};
+        for (const key of itemPackageJsonSortOrder) {
+            if (key in fileContents) {
+                reordered[key] = fileContents[key];
+            }
+        }
+        for (const key of currentKeys) {
+            if (!sortedKeys.has(key)) {
+                reordered[key] = fileContents[key];
+            }
+        }
+        const reorderedKeys = Object.keys(reordered);
+        if (currentKeys.every((key, index) => key === reorderedKeys[index])) {
+            return;
+        }
+        Logger.customize({
+            name: 'CLIRecipeSyncPackages.handleReorder',
+            purpose: 'reorder',
+        }).info(`${chalk.magenta(`"${manifest.name}" workspace`)} → Reordering "package.json" keys ...`);
+        for (const key of currentKeys) {
+            Reflect.deleteProperty(fileContents, key);
+        }
+        for (const [key, value] of Object.entries(reordered)) {
+            Reflect.set(fileContents, key, value);
+        }
+    }
+    static isEmpty(value) {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        if (typeof value === 'string') {
+            return value.trim() === '';
+        }
+        if (Array.isArray(value)) {
+            return value.length === 0;
+        }
+        if (typeof value === 'object') {
+            return Object.keys(value).length === 0;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=sync-packages.js.map