@cbnventures/nova 0.13.0 → 0.14.0

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

@@ -1,1212 +0,0 @@
-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