"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.InstallReason = exports.NpmAccess = exports.NodePackageManager = exports.NodePackage = exports.CodeArtifactAuthProvider = void 0;
exports.defaultNpmToken = defaultNpmToken;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const fs_1 = require("fs");
const path_1 = require("path");
const semver = __importStar(require("semver"));
const pnpm_workspace_1 = require("./pnpm-workspace");
const util_1 = require("./util");
const yarnrc_1 = require("./yarnrc");
const _resolve_1 = require("../_resolve");
const component_1 = require("../component");
const dependencies_1 = require("../dependencies");
const json_1 = require("../json");
const release_1 = require("../release");
const util_2 = require("../util");
const UNLICENSED = "UNLICENSED";
const DEFAULT_NPM_REGISTRY_URL = "https://registry.npmjs.org/";
const GITHUB_PACKAGES_REGISTRY = "npm.pkg.github.com";
const DEFAULT_NPM_TOKEN_SECRET = "NPM_TOKEN";
const DEFAULT_GITHUB_TOKEN_SECRET = "GITHUB_TOKEN";
const DEFAULT_PNPM_VERSION = "10.33.0";
const DEFAULT_YARN_BERRY_VERSION = "4.13.0";
const DEFAULT_YARN_CLASSIC_VERSION = "1.22.22";
/**
 * Options for authorizing requests to a AWS CodeArtifact npm repository.
 */
var CodeArtifactAuthProvider;
(function (CodeArtifactAuthProvider) {
    /**
     * Fixed credentials provided via Github secrets.
     */
    CodeArtifactAuthProvider["ACCESS_AND_SECRET_KEY_PAIR"] = "ACCESS_AND_SECRET_KEY_PAIR";
    /**
     * Ephemeral credentials provided via Github's OIDC integration with an IAM role.
     * See:
     * https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html
     * https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services
     */
    CodeArtifactAuthProvider["GITHUB_OIDC"] = "GITHUB_OIDC";
})(CodeArtifactAuthProvider || (exports.CodeArtifactAuthProvider = CodeArtifactAuthProvider = {}));
/**
 * Represents the npm `package.json` file.
 */
class NodePackage extends component_1.Component {
    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.javascript.NodePackage", version: "0.104.8" };
    /**
     * Returns the `NodePackage` instance associated with a project or `undefined` if
     * there is no NodePackage.
     * @param project The project
     * @returns A NodePackage, or undefined
     */
    static of(project) {
        const isIt = (o) => o instanceof NodePackage;
        return project.components.find(isIt);
    }
    /**
     * The name of the npm package.
     */
    packageName;
    /**
     * The module's entrypoint (e.g. `lib/index.js`).
     */
    entrypoint;
    /**
     * Allow project to take library dependencies.
     */
    allowLibraryDependencies;
    /**
     * The package manager to use.
     */
    packageManager;
    /**
     * @deprecated use `addField(x, y)`
     */
    manifest;
    /**
     * The minimum node version required by this package to function.
     *
     * This value indicates the package is incompatible with older versions.
     */
    minNodeVersion;
    /**
     * Maximum node version supported by this package.
     *
     * The value indicates the package is incompatible with newer versions.
     */
    maxNodeVersion;
    /**
     * The version of PNPM to use if using PNPM as a package manager.
     *
     * @returns `undefined` if the package manager is not PNPM.
     */
    get pnpmVersion() {
        return this.packageManager === NodePackageManager.PNPM
            ? this._pnpmVersion
            : undefined;
    }
    /**
     * The version of Bun to use if using Bun as a package manager.
     *
     * @returns `undefined` if the package manager is not Bun.
     */
    get bunVersion() {
        return this.packageManager === NodePackageManager.BUN
            ? this._bunVersion
            : undefined;
    }
    /**
     * The version of Yarn to use if using Yarn as a package manager.
     *
     * @returns `undefined` if the package manager is not Yarn.
     */
    get yarnVersion() {
        if ((0, util_1.isYarnBerry)(this.packageManager)) {
            return this._yarnBerryVersion;
        }
        if ((0, util_1.isYarnClassic)(this.packageManager)) {
            return DEFAULT_YARN_CLASSIC_VERSION;
        }
        return undefined;
    }
    _pnpmVersion;
    _bunVersion;
    _yarnBerryVersion;
    _options;
    /**
     * The SPDX license of this module. `undefined` if this package is not licensed.
     */
    license;
    /**
     * npm registry (e.g. `https://registry.npmjs.org`). Use `npmRegistryHost` to get just the host name.
     */
    npmRegistryUrl;
    /**
     * The npm registry host (e.g. `registry.npmjs.org`).
     */
    npmRegistry;
    /**
     * GitHub secret which contains the NPM token to use when publishing packages.
     */
    npmTokenSecret;
    /**
     * Options for npm packages using AWS CodeArtifact.
     * This is required if publishing packages to, or installing scoped packages from AWS CodeArtifact
     *
     * @default - undefined
     */
    codeArtifactOptions;
    /**
     * Options for privately hosted scoped packages
     *
     * @default undefined
     */
    scopedPackagesOptions;
    /**
     * npm package access level.
     */
    npmAccess;
    /**
     * Should provenance statements be generated when package is published.
     */
    npmProvenance;
    /**
     * The name of the lock file.
     */
    lockFile;
    /**
     * The task for installing project dependencies (non-frozen).
     */
    installTask;
    /**
     * The task for installing project dependencies (frozen).
     */
    installCiTask;
    /**
     * The task for deduplicating project dependencies, if configured.
     */
    dedupeTask;
    /**
     * The package.json file.
     */
    file;
    scripts = {};
    scriptsToBeRemoved = new Set();
    keywords = new Set();
    allowedScripts = new Set();
    bin = {};
    engines = {};
    peerDependencyOptions;
    _prev;
    _renderedDeps;
    _packageManagerExplicit;
    constructor(project, options = {}) {
        super(project);
        this.packageName = options.packageName ?? project.name;
        this.peerDependencyOptions = {
            pinnedDevDependency: true,
            ...options.peerDependencyOptions,
        };
        this.allowLibraryDependencies = options.allowLibraryDependencies ?? true;
        // Read previous package.json early so we can use it for inference
        this._prev = this.readPackageJson();
        // Resolve package manager: explicit > inferred from package.json > fallback
        if (options.packageManager) {
            this.packageManager = options.packageManager;
            this._packageManagerExplicit = true;
        }
        else {
            this._packageManagerExplicit = false;
            const fromPkgJson = inferPackageManagerFromPkgJson(this._prev, project.outdir);
            if (fromPkgJson) {
                this.packageManager = fromPkgJson;
            }
            else {
                this.project.logger.warn(`[DEPRECATED] "packageManager" is not set in projenrc, defaulting to "${NodePackageManager.YARN_CLASSIC}". ` +
                    `This will become a required option in a future version. Please set it explicitly.`);
                this.packageManager = NodePackageManager.YARN_CLASSIC;
            }
        }
        this.entrypoint = options.entrypoint ?? "lib/index.js";
        this.lockFile = determineLockfile(this.packageManager);
        // Clean up lockfiles from other package managers during migration
        if (options.deleteOrphanedLockFiles !== false) {
            this.deleteOrphanedLockFiles();
        }
        this.project.annotateGenerated(`/${this.lockFile}`);
        const { npmAccess, npmRegistry, npmRegistryUrl, npmTokenSecret, codeArtifactOptions, scopedPackagesOptions, npmProvenance, } = this.parseNpmOptions(options);
        this.npmAccess = npmAccess;
        this.npmRegistry = npmRegistry;
        this.npmRegistryUrl = npmRegistryUrl;
        this.npmTokenSecret = npmTokenSecret;
        this.codeArtifactOptions = codeArtifactOptions;
        this.scopedPackagesOptions = scopedPackagesOptions;
        this.npmProvenance = npmProvenance;
        this.processDeps(options);
        // empty objects are here to preserve order for backwards compatibility
        this.manifest = {
            name: this.packageName,
            description: options.description,
            repository: !options.repository
                ? undefined
                : {
                    type: "git",
                    url: options.repository,
                    directory: options.repositoryDirectory,
                },
            bin: () => this.renderBin(),
            scripts: () => this.renderScripts(),
            author: this.renderAuthor(options),
            devDependencies: {},
            peerDependencies: {},
            dependencies: {},
            bundledDependencies: [],
            ...this.renderPackageResolutions(),
            keywords: () => this.renderKeywords(),
            config: options.config,
            engines: () => this.renderEngines(),
            devEngines: () => this.renderDevEngines(),
            main: this.entrypoint !== "" ? this.entrypoint : undefined,
            license: () => this.license ?? UNLICENSED,
            homepage: options.homepage,
            stability: options.stability,
            publishConfig: () => this.renderPublishConfig(),
            typesVersions: this._prev?.typesVersions,
            allowScripts: this.packageManager === NodePackageManager.NPM
                ? () => this.renderNpmAllowScripts()
                : undefined,
            trustedDependencies: this.packageManager === NodePackageManager.BUN
                ? () => this.renderBunTrustedDependencies()
                : undefined,
            dependenciesMeta: (0, util_1.isYarnBerry)(this.packageManager)
                ? () => this.renderYarnBerryDependenciesMeta()
                : undefined,
            // in release CI builds we bump the version before we run "build" so we want
            // to preserve the version number. otherwise, we always set it to 0.0.0
            version: this.determineVersion(this._prev?.version),
            bugs: options.bugsEmail || options.bugsUrl
                ? {
                    email: options.bugsEmail,
                    url: options.bugsUrl,
                }
                : undefined,
        };
        // Resolve package manager versions
        this._options = options;
        this._pnpmVersion = options.pnpmVersion ?? DEFAULT_PNPM_VERSION;
        this._bunVersion = options.bunVersion ?? "latest";
        this._yarnBerryVersion =
            options.yarnBerryOptions?.version ?? DEFAULT_YARN_BERRY_VERSION;
        this.addAllowedScripts(...(options.allowScripts ?? []));
        // Configure Yarn Berry if using
        if ((0, util_1.isYarnBerry)(this.packageManager)) {
            this.configureYarnBerry(project, options);
        }
        // Configure pnpm if using
        if (this.packageManager === NodePackageManager.PNPM) {
            this.configurePnpm(project, options);
        }
        this.file = new json_1.JsonFile(this, "package.json", {
            obj: this.manifest,
            readonly: false, // we want "yarn add" to work and we have anti-tamper
            newline: true, // all package managers prefer a newline, see https://github.com/projen/projen/issues/2076
            committed: true, // needs to be committed so users can install the dependencies
        });
        this.addKeywords(...(options.keywords ?? []));
        this.addBin(options.bin ?? {});
        // automatically add all executable files under "bin"
        if (options.autoDetectBin ?? true) {
            this.autoDiscoverBinaries();
        }
        // node version
        this.minNodeVersion = options.minNodeVersion;
        this.maxNodeVersion = options.maxNodeVersion;
        this.addNodeEngine();
        this.configureCorepack();
        this.addCodeArtifactLoginScript();
        // license
        if (options.licensed ?? true) {
            this.license = options.license ?? "Apache-2.0";
        }
        this.installTask = project.addTask("install", {
            description: "Install project dependencies and update lockfile (non-frozen)",
            exec: this.installAndUpdateLockfileCommand,
        });
        this.installCiTask = project.addTask("install:ci", {
            description: "Install project dependencies using frozen lockfile",
            exec: this.installCommand,
        });
        // Needs to happen after the install tasks have been added
        this.dedupeTask = this.maybeAddDedupeTask(options);
    }
    /**
     * Adds a `dedupe` task if enabled via `dedupeDeps` or implied by
     * `yarnBerryOptions.dedupePackages`.
     *
     * @returns the dedupe task, or `undefined` if not enabled.
     */
    maybeAddDedupeTask(options) {
        const yarnBerryDedupePackages = options.yarnBerryOptions?.dedupePackages;
        if (!(options.dedupeDeps ?? yarnBerryDedupePackages !== undefined)) {
            return undefined;
        }
        if (this.packageManager === NodePackageManager.BUN) {
            throw new Error("The 'dedupeDeps' option is not supported for Bun: bun does not provide a dedupe command.");
        }
        const dedupeTask = this.project.addTask("dedupe", {
            description: "Deduplicate project dependencies",
        });
        if ((0, util_1.isYarnClassic)(this.packageManager)) {
            // Yarn Classic always deduplicates as part of `yarn install`
            dedupeTask.say("The dedupe command isn't necessary. `yarn install` will already dedupe.");
        }
        else {
            dedupeTask.execArgs((0, util_1.isYarnBerry)(this.packageManager)
                ? ["yarn", "dedupe", ...(yarnBerryDedupePackages ?? [])]
                : [this.packageManager, "dedupe"]);
            // Add dedupe to mutable install task
            this.installTask.spawn(dedupeTask);
        }
        return dedupeTask;
    }
    /**
     * Defines normal dependencies.
     *
     * @param deps Names modules to install. By default, the the dependency will
     * be installed in the next `pnpm projen` run and the version will be recorded
     * in your `package.json` file. You can upgrade manually or using `pnpm
     * add/update`. If you wish to specify a version range use this syntax:
     * `module@^7`.
     */
    addDeps(...deps) {
        for (const dep of deps) {
            this.project.deps.addDependency(dep, dependencies_1.DependencyType.RUNTIME);
        }
    }
    /**
     * Defines development/test dependencies.
     *
     * @param deps Names modules to install. By default, the the dependency will
     * be installed in the next `pnpm projen` run and the version will be recorded
     * in your `package.json` file. You can upgrade manually or using `pnpm
     * add/update`. If you wish to specify a version range use this syntax:
     * `module@^7`.
     */
    addDevDeps(...deps) {
        for (const dep of deps) {
            this.project.deps.addDependency(dep, dependencies_1.DependencyType.BUILD);
        }
    }
    /**
     * Defines peer dependencies.
     *
     * When adding peer dependencies, a devDependency will also be added on the
     * pinned version of the declared peer. This will ensure that you are testing
     * your code against the minimum version required from your consumers.
     *
     * @param deps Names modules to install. By default, the the dependency will
     * be installed in the next `pnpm projen` run and the version will be recorded
     * in your `package.json` file. You can upgrade manually or using `pnpm
     * add/update`. If you wish to specify a version range use this syntax:
     * `module@^7`.
     */
    addPeerDeps(...deps) {
        if (Object.keys(deps).length && !this.allowLibraryDependencies) {
            throw new Error(`cannot add peer dependencies to an APP project: ${Object.keys(deps).join(",")}`);
        }
        for (const dep of deps) {
            this.project.deps.addDependency(dep, dependencies_1.DependencyType.PEER);
        }
    }
    /**
     * Defines bundled dependencies.
     *
     * Bundled dependencies will be added as normal dependencies as well as to the
     * `bundledDependencies` section of your `package.json`.
     *
     * @param deps Names modules to install. By default, the the dependency will
     * be installed in the next `pnpm projen` run and the version will be recorded
     * in your `package.json` file. You can upgrade manually or using `pnpm
     * add/update`. If you wish to specify a version range use this syntax:
     * `module@^7`.
     */
    addBundledDeps(...deps) {
        if (deps.length && !this.allowLibraryDependencies) {
            throw new Error(`cannot add bundled dependencies to an APP project: ${deps.join(",")}`);
        }
        for (const dep of deps) {
            this.project.deps.addDependency(dep, dependencies_1.DependencyType.BUNDLED);
        }
    }
    /**
     * Adds an `engines` requirement to your package.
     * @param engine The engine (e.g. `node`)
     * @param version The semantic version requirement (e.g. `^10`)
     */
    addEngine(engine, version) {
        this.engines[engine] = version;
    }
    /**
     * Adds keywords to package.json (deduplicated)
     * @param keywords The keywords to add
     */
    addKeywords(...keywords) {
        for (const k of keywords) {
            this.keywords.add(k);
        }
    }
    /**
     * Allows the given dependency (package) names to run lifecycle install
     * scripts (`preinstall`, `install`, `postinstall`, `prepare`), in addition
     * to any already allowed via the `allowScripts` option or previous calls.
     *
     * Useful for project types that want to allowlist a package by default
     * while still letting consumers add further packages via `allowScripts`.
     *
     * @param packages The dependency (package) names to allow.
     * @see NodePackageOptions.allowScripts
     */
    addAllowedScripts(...packages) {
        for (const pkg of packages) {
            this.allowedScripts.add(pkg);
        }
    }
    /**
     * Removes the given dependency (package) names from the `allowScripts`
     * allowlist, whether they were added via the `allowScripts` option, a
     * project type default, or a previous call to `addAllowedScripts`.
     *
     * @param packages The dependency (package) names to remove.
     * @see NodePackageOptions.allowScripts
     */
    removeAllowedScripts(...packages) {
        for (const pkg of packages) {
            this.allowedScripts.delete(pkg);
        }
    }
    addBin(bins) {
        for (const [k, v] of Object.entries(bins)) {
            this.bin[k] = v;
        }
    }
    /**
     * Add a npm package.json script.
     *
     * @param name The script name
     * @param command The command to execute, run by the package manager's shell.
     */
    setScript(name, command) {
        this.scripts[name] = command;
    }
    /**
     * Removes an npm script (always successful).
     *
     * @param name The name of the script.
     */
    removeScript(name) {
        // need to keep track in case there's a task of the same name
        this.scriptsToBeRemoved.add(name);
        delete this.scripts[name];
    }
    /**
     * Directly set fields in `package.json`.
     * @escape
     * @param name field name
     * @param value field value
     */
    addField(name, value) {
        this.manifest[name] = value;
    }
    /**
     * Sets the package version.
     * @param version Package version.
     */
    addVersion(version) {
        this.manifest.version = version;
    }
    /**
     * Defines resolutions for dependencies to change the normally resolved
     * version of a dependency to something else.
     *
     * @param resolutions Names resolutions to be added. Specify a version or
     * range with this syntax:
     * `module@^7`
     */
    addPackageResolutions(...resolutions) {
        for (const resolution of resolutions) {
            this.project.deps.addDependency(resolution, dependencies_1.DependencyType.OVERRIDE);
        }
    }
    /**
     * Returns the package manager's immutable install command with a frozen lockfile, e.g. `npm ci` or `pnpm ci`.
     *
     * Prefer using `NodePackage.installCiTask`. The raw command string is intended for bootstrapping.
     */
    get installCommand() {
        return this.renderInstallCommand(true);
    }
    /**
     * Returns the package manager's mutable install command with lockfile update, e.g. `npm install` or `pnpm install`.
     *
     * Prefer using `NodePackage.installTask`. The raw command string is intended for bootstrapping.
     */
    get installAndUpdateLockfileCommand() {
        return this.renderInstallCommand(false);
    }
    /**
     * Attempt to resolve the currently installed version for a given dependency.
     *
     * @remarks
     * This method will first look through the current project's dependencies.
     * If found and semantically valid (not '*'), that will be used.
     * Otherwise, it will fall back to locating a `package.json` manifest for the dependency
     * through node's internal resolution reading the version from there.
     *
     * @param dependencyName Dependency to resolve for.
     */
    tryResolveDependencyVersion(dependencyName) {
        try {
            const fromDeps = this.project.deps.tryGetDependency(dependencyName);
            const version = semver.coerce(fromDeps?.version, { loose: true });
            if (version) {
                return version.format();
            }
        }
        catch { }
        return (0, util_1.tryResolveDependencyVersion)(dependencyName, {
            paths: [this.project.outdir],
        });
    }
    // ---------------------------------------------------------------------------------------
    synthesize() {
        this._renderedDeps = this.renderDependencies();
        super.synthesize();
    }
    postSynthesize() {
        super.postSynthesize();
        // Phase 1: install if package.json changed or node_modules is missing
        const initialTrigger = this.determineInitialInstallTrigger();
        if (initialTrigger) {
            this.logInstallTrigger(initialTrigger);
            this.installDependencies(initialTrigger);
        }
        // Phase 2: resolve "*" deps and install again if versions changed
        const resolutions = this.resolveDepsAndWritePackageJson();
        if (resolutions?.length) {
            const trigger = {
                reason: InstallReason.DEPS_RESOLVED,
                resolutions,
            };
            this.logInstallTrigger(trigger);
            this.installDependencies(trigger);
        }
    }
    /**
     * Checks whether dependencies need to be installed before dependency
     * resolution.
     *
     * @returns a structured trigger describing the reason, or `undefined` if
     * no install is needed.
     */
    determineInitialInstallTrigger() {
        const hasNodeModules = (0, fs_1.existsSync)((0, path_1.join)(this.project.outdir, "node_modules"));
        if (this.file.changed) {
            return {
                reason: InstallReason.PACKAGE_JSON_CHANGED,
                diff: this.file.diff(true),
            };
        }
        if (!hasNodeModules) {
            return { reason: InstallReason.NO_NODE_MODULES };
        }
        return undefined;
    }
    /**
     * Logs user-facing information about why dependencies are being installed.
     * Emits an info-level summary and debug-level details (reason, diff, resolutions).
     */
    logInstallTrigger(trigger) {
        this.project.logger.info("Installing dependencies... (use --debug for details)");
        this.project.logger.debug(`Install reason: ${trigger.reason}`);
        if (trigger.diff) {
            this.project.logger.debug(`package.json diff:\n${trigger.diff.join("\n")}`);
        }
        if (trigger.resolutions?.length) {
            this.project.logger.info(`Resolved dependency versions:\n${trigger.resolutions.map((r) => `  ${r}`).join("\n")}`);
        }
    }
    /**
     * The command prefix to use when executing binary commands for this package
     * manager (e.g. `npx`, `pnpm exec`, `yarn`, `bunx`).
     */
    get execCommand() {
        return (0, util_1.execCommand)(this.packageManager);
    }
    /**
     * Returns `true` if we are running within a CI build.
     */
    get isAutomatedBuild() {
        return (0, util_2.isTruthy)(process.env.CI);
    }
    determineVersion(currVersion) {
        if (!this.isReleaseBuild) {
            return "0.0.0";
        }
        return currVersion ?? "0.0.0";
    }
    /**
     * Returns `true` if this is a CI release build.
     */
    get isReleaseBuild() {
        return (0, util_2.isTruthy)(process.env.RELEASE);
    }
    // -------------------------------------------------------------------------------------------
    parseNpmOptions(options) {
        const npmRegistryUrl = options.npmRegistryUrl;
        const npmr = new URL(npmRegistryUrl ?? DEFAULT_NPM_REGISTRY_URL);
        if (!npmr || !npmr.hostname || !npmr.href) {
            throw new Error(`unable to determine npm registry host from url ${npmRegistryUrl}. Is this really a URL?`);
        }
        const npmAccess = options.npmAccess ?? defaultNpmAccess(this.packageName);
        if (!isScoped(this.packageName) && npmAccess === NpmAccess.RESTRICTED) {
            throw new Error(`"npmAccess" cannot be RESTRICTED for non-scoped npm package "${this.packageName}"`);
        }
        const npmProvenance = options.npmProvenance ?? npmAccess === NpmAccess.PUBLIC;
        if (npmProvenance && npmAccess !== NpmAccess.PUBLIC) {
            throw new Error(`"npmProvenance" can only be enabled for public packages`);
        }
        const isAwsCodeArtifact = (0, release_1.isAwsCodeArtifactRegistry)(npmRegistryUrl);
        const hasScopedPackage = options.scopedPackagesOptions &&
            options.scopedPackagesOptions.length !== 0;
        if (isAwsCodeArtifact) {
            if (options.npmTokenSecret) {
                throw new Error('"npmTokenSecret" must not be specified when publishing AWS CodeArtifact.');
            }
            else if (options.codeArtifactOptions?.authProvider ===
                CodeArtifactAuthProvider.GITHUB_OIDC) {
                if (options.codeArtifactOptions.accessKeyIdSecret ||
                    options.codeArtifactOptions.secretAccessKeySecret) {
                    throw new Error("access and secret key pair should not be provided when using GITHUB_OIDC auth provider for AWS CodeArtifact");
                }
                else if (!options.codeArtifactOptions.roleToAssume) {
                    throw new Error('"roleToAssume" property is required when using GITHUB_OIDC for AWS CodeArtifact options');
                }
            }
        }
        else {
            if ((options.codeArtifactOptions?.accessKeyIdSecret ||
                options.codeArtifactOptions?.secretAccessKeySecret ||
                options.codeArtifactOptions?.roleToAssume) &&
                !hasScopedPackage) {
                throw new Error("codeArtifactOptions must only be specified when publishing AWS CodeArtifact or used in scoped packages.");
            }
        }
        // apply defaults for AWS CodeArtifact
        let codeArtifactOptions;
        if (isAwsCodeArtifact || hasScopedPackage) {
            const authProvider = options.codeArtifactOptions?.authProvider ??
                CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR;
            const isAccessSecretKeyPairAuth = authProvider === CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR;
            codeArtifactOptions = {
                authProvider,
                accessKeyIdSecret: options.codeArtifactOptions?.accessKeyIdSecret ??
                    (isAccessSecretKeyPairAuth ? "AWS_ACCESS_KEY_ID" : undefined),
                secretAccessKeySecret: options.codeArtifactOptions?.secretAccessKeySecret ??
                    (isAccessSecretKeyPairAuth ? "AWS_SECRET_ACCESS_KEY" : undefined),
                roleToAssume: options.codeArtifactOptions?.roleToAssume,
            };
        }
        return {
            npmAccess,
            npmRegistry: npmr.hostname + this.renderNpmRegistryPath(npmr.pathname),
            npmRegistryUrl: npmr.href,
            npmTokenSecret: options.npmTrustedPublishing
                ? undefined
                : defaultNpmToken(options.npmTokenSecret, npmr.hostname),
            codeArtifactOptions,
            scopedPackagesOptions: this.parseScopedPackagesOptions(options.scopedPackagesOptions),
            npmProvenance,
        };
    }
    parseScopedPackagesOptions(scopedPackagesOptions) {
        if (!scopedPackagesOptions) {
            return undefined;
        }
        return scopedPackagesOptions.map((option) => {
            if (!isScoped(option.scope)) {
                throw new Error(`Scope must start with "@" in options, found ${option.scope}`);
            }
            if (!(0, release_1.isAwsCodeArtifactRegistry)(option.registryUrl)) {
                throw new Error(`Only AWS Code artifact scoped registry is supported for now, found ${option.registryUrl}`);
            }
            const result = {
                registryUrl: option.registryUrl,
                scope: option.scope,
            };
            return result;
        });
    }
    addCodeArtifactLoginScript() {
        if (!this.scopedPackagesOptions ||
            this.scopedPackagesOptions.length === 0) {
            return;
        }
        this.project.addTask("ca:login", {
            steps: [
                { execArgs: ["which", "aws"] }, // check that AWS CLI is installed
                ...this.scopedPackagesOptions.flatMap((scopedPackagesOption) => {
                    const { registryUrl, scope } = scopedPackagesOption;
                    const { domain, region, accountId, registry } = (0, util_1.extractCodeArtifactDetails)(registryUrl);
                    // reference: https://docs.aws.amazon.com/codeartifact/latest/ug/npm-auth.html
                    const steps = [
                        {
                            execArgs: [
                                "npm",
                                "config",
                                "set",
                                `${scope}:registry`,
                                registryUrl,
                            ],
                        },
                        {
                            env: {
                                CODEARTIFACT_AUTH_TOKEN: `$(aws codeartifact get-authorization-token --domain ${domain} --region ${region} --domain-owner ${accountId} --query authorizationToken --output text)`,
                                CODEARTIFACT_AUTH_TOKEN_KEY: `//${registry}:_authToken`,
                            },
                            // needs a shell to expand env vars
                            exec: 'npm config set "$CODEARTIFACT_AUTH_TOKEN_KEY=$CODEARTIFACT_AUTH_TOKEN"',
                        },
                    ];
                    if (!this.minNodeVersion || semver.major(this.minNodeVersion) <= 16) {
                        steps.push({
                            execArgs: [
                                "npm",
                                "config",
                                "set",
                                `//${registry}:always-auth=true`,
                            ],
                        });
                    }
                    return steps;
                }),
            ],
        });
    }
    addNodeEngine() {
        if (!this.minNodeVersion && !this.maxNodeVersion) {
            return;
        }
        let nodeVersion = "";
        if (this.minNodeVersion) {
            nodeVersion += `>= ${this.minNodeVersion}`;
        }
        if (this.maxNodeVersion) {
            nodeVersion += ` <= ${this.maxNodeVersion}`;
        }
        this.addEngine("node", nodeVersion);
    }
    renderNpmRegistryPath(path) {
        if (!path || path == "/") {
            return "";
        }
        else {
            return path;
        }
    }
    renderInstallCommand(frozen) {
        switch (this.packageManager) {
            case NodePackageManager.YARN:
            case NodePackageManager.YARN_CLASSIC:
                return [
                    "yarn install",
                    "--check-files", // ensure all modules exist (especially projen which was just removed).
                    ...(frozen ? ["--frozen-lockfile"] : []),
                ].join(" ");
            case NodePackageManager.YARN2:
            case NodePackageManager.YARN_BERRY:
                return [
                    "yarn install",
                    ...(frozen ? ["--immutable"] : ["--no-immutable"]),
                ].join(" ");
            case NodePackageManager.NPM:
                return frozen ? "npm ci" : "npm install";
            case NodePackageManager.PNPM:
                return frozen
                    ? "pnpm i --frozen-lockfile"
                    : "pnpm i --no-frozen-lockfile";
            case NodePackageManager.BUN:
                return ["bun install", ...(frozen ? ["--frozen-lockfile"] : [])].join(" ");
            default:
                throw new Error(`unexpected package manager ${this.packageManager}`);
        }
    }
    processDeps(options) {
        this.addDeps(...(options.deps ?? []));
        this.addDevDeps(...(options.devDeps ?? []));
        this.addPeerDeps(...(options.peerDeps ?? []));
        this.addBundledDeps(...(options.bundledDeps ?? []));
    }
    renderDependencies() {
        const devDependencies = {};
        const peerDependencies = {};
        const dependencies = {};
        const bundledDependencies = new Array();
        // synthetic dependencies: add a pinned build dependency to ensure we are
        // testing against the minimum requirement of the peer.
        if (this.peerDependencyOptions.pinnedDevDependency) {
            for (const dep of this.project.deps.all.filter((d) => d.type === dependencies_1.DependencyType.PEER)) {
                let req = dep.name;
                // Skip if we already have a runtime dependency on this peer and no build dependency yet.
                // If there is a build dep already, we need to override its version.
                if (this.project.deps.tryGetDependency(dep.name, dependencies_1.DependencyType.RUNTIME) &&
                    !this.project.deps.tryGetDependency(dep.name, dependencies_1.DependencyType.BUILD)) {
                    continue;
                }
                if (dep.version) {
                    const ver = (0, util_1.minVersion)(dep.version);
                    if (!ver) {
                        throw new Error(`unable to determine minimum semver for peer dependency ${dep.name}@${dep.version}`);
                    }
                    req += "@" + ver;
                }
                this.addDevDeps(req);
            }
        }
        for (const dep of this.project.deps.all) {
            let version = dep.version ?? "*";
            let name = dep.name;
            if (name.startsWith("file:")) {
                const localDependencyPath = name.substring(5);
                const depPackageJson = (0, path_1.resolve)(this.project.outdir, localDependencyPath, "package.json");
                const pkgFile = (0, fs_1.readFileSync)(depPackageJson, "utf8");
                const pkg = JSON.parse(pkgFile);
                version = localDependencyPath;
                name = pkg.name;
            }
            switch (dep.type) {
                case dependencies_1.DependencyType.BUNDLED:
                    bundledDependencies.push(name);
                    const depDecls = this.project.deps.all.filter((d) => d.name === name);
                    if (depDecls.some((d) => d.type === dependencies_1.DependencyType.PEER)) {
                        throw new Error(`unable to bundle "${name}": it cannot appear as a peer dependency (bundled would always take precedence over peer)`);
                    }
                    // I've observed that at least npm 10.8.2 will silently fail to bundle
                    // a dependency if it is [also] part of `devDependencies`. It must exist in
                    // `dependencies` and `dependencies` only.
                    if (depDecls.some((d) => d.type === dependencies_1.DependencyType.BUILD)) {
                        throw new Error(`unable to bundle "${name}": it cannot appear as a devDependency (only prod dependencies are bundled, and any dependency appearing as a devDependency is considered to be not a prod dependency)`);
                    }
                    // also add as a runtime dependency
                    dependencies[name] = version;
                    break;
                case dependencies_1.DependencyType.PEER:
                    peerDependencies[name] = version;
                    break;
                case dependencies_1.DependencyType.RUNTIME:
                    dependencies[name] = version;
                    break;
                case dependencies_1.DependencyType.TEST:
                case dependencies_1.DependencyType.DEVENV:
                case dependencies_1.DependencyType.BUILD:
                    devDependencies[name] = version;
                    break;
            }
        }
        // returns a lazy value to normalize during synthesis
        const normalize = (obj) => () => (0, util_2.sorted)(obj);
        // update the manifest we are about to save into `package.json`
        this.manifest.devDependencies = normalize(devDependencies);
        this.manifest.peerDependencies = normalize(peerDependencies);
        this.manifest.dependencies = normalize(dependencies);
        this.manifest.bundledDependencies = (0, util_2.sorted)(bundledDependencies);
        // nothing further to do if package.json file does not exist
        if (!this._prev) {
            return { devDependencies, peerDependencies, dependencies };
        }
        const unmanagedRemoved = [];
        const readDeps = (user, current = {}) => {
            for (const [name, userVersion] of Object.entries(user)) {
                const currentVersion = current[name];
                // respect user version if it's not '*' or if current version is undefined
                if (userVersion !== "*" || !currentVersion || currentVersion === "*") {
                    continue;
                }
                // memoize current version in memory so it is preserved when saving
                user[name] = currentVersion;
            }
            // report removals
            for (const name of Object.keys(current ?? {})) {
                if (!user[name]) {
                    this.project.logger.verbose(`${name}: removed`);
                    unmanagedRemoved.push(name);
                }
            }
        };
        readDeps(devDependencies, this._prev.devDependencies);
        readDeps(dependencies, this._prev.dependencies);
        readDeps(peerDependencies, this._prev.peerDependencies);
        if (unmanagedRemoved.length > 0) {
            this.project.logger.warn(`Removing unmanaged dependencies not declared in .projenrc: ${unmanagedRemoved.join(", ")}. ` +
                "These were likely installed via a package manager (e.g. npm install). " +
                "To keep them, add them to your .projenrc and run projen again.");
        }
        return { devDependencies, dependencies, peerDependencies };
    }
    /**
     * Resolves any deps that do not have a specified version (e.g. `*`) and
     * updates `package.json` if needed. Does not log or install — the caller
     * is responsible for acting on the returned changes.
     *
     * @returns list of human-readable resolution changes, or `undefined` if
     * `package.json` does not exist. An empty array means no changes were made.
     */
    resolveDepsAndWritePackageJson() {
        const outdir = this.project.outdir;
        const rootPackageJson = (0, path_1.join)(outdir, "package.json");
        const original = (0, fs_1.readFileSync)(rootPackageJson, "utf8");
        const pkg = JSON.parse(original);
        const changes = [];
        const resolveDeps = (current, user) => {
            const result = {};
            current = current ?? {};
            user = user ?? {};
            for (const [name, currentDefinition] of Object.entries(user)) {
                // find actual version from node_modules
                let desiredVersion = currentDefinition;
                if (currentDefinition === "*") {
                    // we already know we don't have the version in project `deps`,
                    // so skip straight to checking manifest.
                    const resolvedVersion = (0, util_1.tryResolveDependencyVersion)(name, {
                        paths: [this.project.outdir],
                    });
                    if (!resolvedVersion) {
                        this.project.logger.warn(`unable to resolve version for ${name} from installed modules`);
                        continue;
                    }
                    desiredVersion = `^${resolvedVersion}`;
                }
                if (currentDefinition !== desiredVersion) {
                    changes.push(`${name}: ${currentDefinition} => ${desiredVersion}`);
                }
                result[name] = desiredVersion;
            }
            // collect removed packages
            for (const name of Object.keys(current)) {
                if (!result[name]) {
                    changes.push(`${name}: removed`);
                }
            }
            return result;
        };
        const rendered = this._renderedDeps;
        if (!rendered) {
            throw new Error("assertion failed");
        }
        const deps = resolveDeps(pkg.dependencies, rendered.dependencies);
        const devDeps = resolveDeps(pkg.devDependencies, rendered.devDependencies);
        const peerDeps = resolveDeps(pkg.peerDependencies, rendered.peerDependencies);
        if (this.peerDependencyOptions.pinnedDevDependency) {
            for (const [name, version] of Object.entries(peerDeps)) {
                // Skip if we already have a runtime dependency on this peer
                // or if devDependency version is already set.
                // Relies on the "*" devDependency added in the presynth step
                if (deps[name] || rendered.devDependencies[name] !== "*") {
                    continue;
                }
                // Take version and pin as dev dependency
                const ver = (0, util_1.minVersion)(version);
                if (!ver) {
                    throw new Error(`unable to determine minimum semver for peer dependency ${name}@${version}`);
                }
                devDeps[name] = ver;
            }
        }
        pkg.dependencies = (0, util_2.sorted)(deps);
        pkg.devDependencies = (0, util_2.sorted)(devDeps);
        pkg.peerDependencies = (0, util_2.sorted)(peerDeps);
        const updated = JSON.stringify(pkg, undefined, 2) + "\n";
        if (original === updated) {
            return [];
        }
        (0, util_2.writeFile)(rootPackageJson, updated);
        return changes;
    }
    renderPackageResolutions() {
        const render = () => {
            const overridingDependencies = this.project.deps.all.filter((dep) => dep.type === dependencies_1.DependencyType.OVERRIDE);
            if (!overridingDependencies.length) {
                return undefined;
            }
            return Object.fromEntries(overridingDependencies.map(({ name, version = "*" }) => [
                name,
                version,
            ]));
        };
        switch (this.packageManager) {
            case NodePackageManager.NPM:
            case NodePackageManager.BUN:
                return { overrides: render };
            case NodePackageManager.PNPM:
                return this.project.parent
                    ? undefined
                    : { pnpm: { overrides: render } };
            case NodePackageManager.YARN:
            case NodePackageManager.YARN2:
            case NodePackageManager.YARN_CLASSIC:
            case NodePackageManager.YARN_BERRY:
            default:
                return { resolutions: render };
        }
    }
    /**
     * Renders the native npm `allowScripts` field (`{ "pkg": true }`) from the
     * `allowScripts` allowlist.
     *
     * @see https://docs.npmjs.com/cli/v11/commands/npm-approve-scripts
     */
    renderNpmAllowScripts() {
        if (this.allowedScripts.size === 0) {
            return undefined;
        }
        return Object.fromEntries([...this.allowedScripts].sort().map((pkg) => [pkg, true]));
    }
    /**
     * Renders the native bun `trustedDependencies` field from the
     * `allowScripts` allowlist.
     *
     * @see https://bun.com/docs/pm/lifecycle
     */
    renderBunTrustedDependencies() {
        if (this.allowedScripts.size === 0) {
            return undefined;
        }
        return [...this.allowedScripts].sort();
    }
    /**
     * Renders the native yarn berry per-package script allowlist via
     * `dependenciesMeta.<pkg>.built = true`. Combined with the global
     * `enableScripts: false` yarnrc setting (set in `configureYarnBerry`),
     * this allows install scripts to run only for the listed packages.
     *
     * @see https://yarnpkg.com/configuration/manifest#dependenciesMeta.built
     * @see https://yarnpkg.com/features/security#postinstalls
     */
    renderYarnBerryDependenciesMeta() {
        if (this.allowedScripts.size === 0) {
            return undefined;
        }
        return Object.fromEntries([...this.allowedScripts].sort().map((pkg) => [pkg, { built: true }]));
    }
    /**
     * Validates and configures the `allowScripts` allowlist for the resolved
     * package manager, throwing a descriptive error for package managers that
     * have no native way to allowlist install scripts per-dependency.
     */
    configureAllowScripts() {
        if (this.allowedScripts.size === 0) {
            return;
        }
        switch (this.packageManager) {
            case NodePackageManager.NPM:
            case NodePackageManager.BUN:
                // handled via the `allowScripts` / `trustedDependencies` manifest fields
                return;
            case NodePackageManager.YARN2:
            case NodePackageManager.YARN_BERRY:
                // handled via `dependenciesMeta.<pkg>.built` + `enableScripts: false`
                // in `renderYarnBerryDependenciesMeta` and `configureYarnBerry`
                return;
            case NodePackageManager.PNPM:
                // handled via `configurePnpm`
                return;
            default:
                throw new Error(`"allowScripts" is not supported for packageManager "${this.packageManager}". ` +
                    "Switch to a modern package manager that supports this option.");
        }
    }
    /**
     * Configures the `PnpmWorkspaceYaml` component, merging `onlyBuiltDependencies`
     * from `allowScripts` and any explicit `pnpmOptions.workspaceYamlOptions`.
     * The merge is resolved lazily (at synthesis time), so calls to
     * `addAllowedScripts`/`removeAllowedScripts` made after this runs are
     * still reflected. The file is only written if it ends up with actual
     * content (see `omitEmpty`), so this is safe to call unconditionally for
     * every pnpm project.
     */
    configurePnpm(project, options) {
        const { workspaceYamlOptions = {} } = options.pnpmOptions ?? {};
        const renderOnlyBuiltDependencies = () => {
            const merged = new Set([
                ...this.allowedScripts,
                ...(workspaceYamlOptions.onlyBuiltDependencies ?? []),
            ]);
            return merged.size > 0 ? [...merged].sort() : undefined;
        };
        new pnpm_workspace_1.PnpmWorkspaceYaml(project, {
            ...workspaceYamlOptions,
            // `onlyBuiltDependencies` is typed as `string[]`, but defining it as a
            // getter lets us resolve the merged allowlist lazily (at synthesis
            // time), so `addAllowedScripts`/`removeAllowedScripts` calls made
            // after this runs are still reflected.
            get onlyBuiltDependencies() {
                return renderOnlyBuiltDependencies();
            },
        });
    }
    renderPublishConfig() {
        // When npm provenance is enabled, we need to always render the public access
        // But when npmAccess is the set to the default, we prefer to omit it
        const shouldOmitAccess = !this.npmProvenance &&
            this.npmAccess === defaultNpmAccess(this.packageName);
        // omit values if they are the same as the npm defaults
        return (0, _resolve_1.resolve)({
            registry: this.npmRegistryUrl !== DEFAULT_NPM_REGISTRY_URL
                ? this.npmRegistryUrl
                : undefined,
            access: shouldOmitAccess ? undefined : this.npmAccess,
        }, { omitEmpty: true });
    }
    renderKeywords() {
        const kwds = Array.from(this.keywords);
        return (0, util_2.sorted)(kwds.sort());
    }
    renderEngines() {
        return (0, util_2.sorted)(this.engines);
    }
    renderDevEngines() {
        const autoAdd = this._options.addPackageManagerToDevEngines !== false &&
            this._packageManagerExplicit;
        const base = autoAdd
            ? { packageManager: this.packageManagerToDevEngine() }
            : {};
        const merged = { ...base, ...this._options.devEngines };
        return Object.keys(merged).length > 0 ? merged : undefined;
    }
    deleteOrphanedLockFiles() {
        const ownLockFile = (0, path_1.join)(this.project.outdir, this.lockFile);
        if (!(0, fs_1.existsSync)(ownLockFile)) {
            return;
        }
        const allLockFiles = [
            "yarn.lock",
            "package-lock.json",
            "pnpm-lock.yaml",
            "bun.lockb",
        ];
        for (const lf of allLockFiles) {
            if (lf === this.lockFile) {
                continue;
            }
            const path = (0, path_1.join)(this.project.outdir, lf);
            if ((0, fs_1.existsSync)(path)) {
                this.project.logger.info(`Deleting orphaned lockfile: ${lf}`);
                (0, fs_1.unlinkSync)(path);
            }
        }
    }
    autoDiscoverBinaries() {
        const binrel = "bin";
        const bindir = (0, path_1.join)(this.project.outdir, binrel);
        if ((0, fs_1.existsSync)(bindir)) {
            for (const file of (0, fs_1.readdirSync)(bindir)) {
                try {
                    (0, fs_1.accessSync)((0, path_1.join)(bindir, file), fs_1.constants.X_OK);
                    const binPath = (0, path_1.join)(binrel, file);
                    const normalizedPath = (0, util_2.normalizePersistedPath)(binPath);
                    this.bin[file] = normalizedPath;
                }
                catch (e) {
                    // not executable, skip
                }
            }
        }
    }
    renderAuthor(options) {
        let author;
        if (options.authorName) {
            author = {
                name: options.authorName,
                email: options.authorEmail,
                url: options.authorUrl,
                organization: options.authorOrganization ?? false,
            };
        }
        else {
            if (options.authorEmail ||
                options.authorUrl ||
                options.authorOrganization !== undefined) {
                throw new Error('"authorName" is required if specifying "authorEmail" or "authorUrl"');
            }
        }
        return author;
    }
    renderBin() {
        const entries = Object.entries(this.bin);
        // Yarn Berry rewrites `"bin": {"name": "./path"}` to `"bin": "./path"`
        // when the key matches the package name, causing anti-tamper failures.
        // Render the string form directly to avoid this.
        // See: https://github.com/yarnpkg/berry/issues/6184
        const { name: binName } = parsePackageName(this.packageName);
        if ((0, util_1.isYarnBerry)(this.packageManager) && entries.length === 1) {
            const [key, value] = entries[0];
            if (key === binName) {
                return value;
            }
        }
        return (0, util_2.sorted)(this.bin);
    }
    renderScripts() {
        // Validate the `allowScripts` allowlist lazily (at synthesis time, since
        // `scripts` is always resolved regardless of package manager), so
        // `addAllowedScripts` calls made after construction are also checked.
        this.configureAllowScripts();
        const result = {};
        const tasks = this.project.tasks.all
            .filter((t) => 
        // Must remove to prevent overriding built-in npm command (which would loop)
        t.name !== this.installTask.name &&
            t.name !== this.installCiTask.name)
            .sort((x, y) => x.name.localeCompare(y.name));
        const scriptCommand = this.resolveScriptCommand();
        for (const task of tasks) {
            if (this.scriptsToBeRemoved.has(task.name)) {
                continue;
            }
            result[task.name] = `${scriptCommand} ${task.name}`;
        }
        return {
            ...result,
            ...this.scripts,
        };
    }
    /**
     * Determines the command to use for projen in package.json scripts.
     *
     * Since `node_modules/.bin` is always on PATH in npm scripts, we can use
     * bare `projen` unless the user has set a custom `projenCommand`.
     */
    resolveScriptCommand() {
        const cmd = this.project.projenCommand;
        const isDefault = [
            // NodeProject sets projenCommand based on the package manager
            (0, util_1.execCommand)(this.packageManager, "projen"),
            // Plain Project always defaults to "npx projen" regardless of package manager
            "npx projen",
        ].includes(cmd);
        return isDefault ? "projen" : cmd;
    }
    readPackageJson() {
        const file = (0, path_1.join)(this.project.outdir, "package.json");
        if (!(0, fs_1.existsSync)(file)) {
            return undefined;
        }
        return JSON.parse((0, fs_1.readFileSync)(file, "utf-8"));
    }
    /**
     * Runs the install or install:ci task. Does not log — the caller is
     * responsible for informing the user before calling this method.
     *
     * @param _trigger the reason for the install, available for subclasses to act on.
     */
    installDependencies(_trigger) {
        const taskToRun = this.isAutomatedBuild
            ? this.installCiTask
            : this.installTask;
        this.project.tasks.runTask(taskToRun.name);
    }
    /**
     * Sets the `packageManager` field in `package.json` for corepack-managed
     * package managers (yarn berry and pnpm).
     */
    configureCorepack() {
        if ((0, util_1.isYarnBerry)(this.packageManager)) {
            this.addField("packageManager", `yarn@${this._yarnBerryVersion}`);
        }
        else if (this.packageManager === NodePackageManager.PNPM) {
            this.addField("packageManager", `pnpm@${this._pnpmVersion}`);
        }
    }
    /**
     * Maps the current package manager to a `DevEngineDependency`.
     */
    packageManagerToDevEngine() {
        const onFail = "ignore";
        switch (this.packageManager) {
            case NodePackageManager.YARN:
            case NodePackageManager.YARN_CLASSIC:
                return {
                    name: "yarn",
                    version: DEFAULT_YARN_CLASSIC_VERSION,
                    onFail,
                };
            case NodePackageManager.YARN2:
            case NodePackageManager.YARN_BERRY:
                return {
                    name: "yarn",
                    version: this._options.yarnBerryOptions?.version ??
                        `>=${semver.major(this._yarnBerryVersion)}`,
                    onFail,
                };
            case NodePackageManager.NPM:
                return { name: "npm", onFail };
            case NodePackageManager.PNPM:
                return {
                    name: "pnpm",
                    version: this._options.pnpmVersion ?? `>=${semver.major(this._pnpmVersion)}`,
                    onFail,
                };
            case NodePackageManager.BUN:
                return { name: "bun", onFail };
        }
    }
    configureYarnBerry(project, options) {
        const { yarnRcOptions = {}, zeroInstalls = false } = options.yarnBerryOptions || {};
        this.checkForConflictingYarnOptions(yarnRcOptions);
        this.configureYarnBerryGitignore(zeroInstalls);
        // When an allowlist is provided, disable scripts globally so that only
        // the packages explicitly marked via `dependenciesMeta.<pkg>.built` are
        // allowed to run their install scripts. Resolved lazily (at synthesis
        // time, via a getter) so that later calls to
        // `addAllowedScripts`/`removeAllowedScripts` are reflected. Has no
        // effect if the user set `enableScripts` explicitly.
        const nodePackage = this;
        new yarnrc_1.Yarnrc(project, {
            get enableScripts() {
                return nodePackage.allowedScripts.size > 0 ? false : undefined;
            },
            ...yarnRcOptions,
        });
    }
    checkForConflictingYarnOptions(yarnRcOptions) {
        if (this.npmAccess &&
            yarnRcOptions.npmPublishAccess &&
            this.npmAccess.toString() !== yarnRcOptions.npmPublishAccess.toString()) {
            throw new Error(`Cannot set npmAccess (${this.npmAccess}) and yarnRcOptions.npmPublishAccess (${yarnRcOptions.npmPublishAccess}) to different values.`);
        }
        if (this.npmRegistryUrl &&
            yarnRcOptions.npmRegistryServer &&
            this.npmRegistryUrl !== yarnRcOptions.npmRegistryServer) {
            throw new Error(`Cannot set npmRegistryUrl (${this.npmRegistryUrl}) and yarnRcOptions.npmRegistryServer (${yarnRcOptions.npmRegistryServer}) to different values.`);
        }
    }
    /** See https://yarnpkg.com/getting-started/qa#which-files-should-be-gitignored */
    configureYarnBerryGitignore(zeroInstalls) {
        const { gitignore } = this.project;
        // These patterns are the same whether or not you're using zero-installs
        gitignore.exclude(".yarn/*");
        gitignore.include(".yarn/patches", ".yarn/plugins", ".yarn/releases", ".yarn/sdks", ".yarn/versions");
        if (zeroInstalls) {
            gitignore.include("!.yarn/cache");
        }
        else {
            gitignore.exclude(".pnp.*");
        }
    }
}
exports.NodePackage = NodePackage;
/**
 * The node package manager to use.
 */
var NodePackageManager;
(function (NodePackageManager) {
    /**
     * Use `yarn` as the package manager.
     *
     * @deprecated For `yarn` 1.x use `YARN_CLASSIC` for `yarn` >= 2 use `YARN_BERRY`. Currently, `NodePackageManager.YARN` means `YARN_CLASSIC`. In the future, we might repurpose it to mean `YARN_BERRY`.
     */
    NodePackageManager["YARN"] = "yarn";
    /**
     * Use `yarn` versions >= 2 as the package manager.
     *
     * @deprecated use YARN_BERRY instead
     */
    NodePackageManager["YARN2"] = "yarn2";
    /**
     * Use `yarn` 1.x as the package manager.
     */
    NodePackageManager["YARN_CLASSIC"] = "yarn_classic";
    /**
     * Use `yarn` versions >= 2 as the package manager.
     */
    NodePackageManager["YARN_BERRY"] = "yarn_berry";
    /**
     * Use `npm` as the package manager.
     */
    NodePackageManager["NPM"] = "npm";
    /**
     * Use `pnpm` as the package manager.
     */
    NodePackageManager["PNPM"] = "pnpm";
    /**
     * Use `bun` as the package manager
     */
    NodePackageManager["BUN"] = "bun";
})(NodePackageManager || (exports.NodePackageManager = NodePackageManager = {}));
/**
 * Npm package access level
 */
var NpmAccess;
(function (NpmAccess) {
    /**
     * Package is public.
     */
    NpmAccess["PUBLIC"] = "public";
    /**
     * Package can only be accessed with credentials.
     */
    NpmAccess["RESTRICTED"] = "restricted";
})(NpmAccess || (exports.NpmAccess = NpmAccess = {}));
/**
 * Why a dependency install was triggered during synthesis.
 */
var InstallReason;
(function (InstallReason) {
    /** The node_modules directory does not exist. */
    InstallReason["NO_NODE_MODULES"] = "node_modules is missing";
    /** The package.json file was modified during synthesis. */
    InstallReason["PACKAGE_JSON_CHANGED"] = "package.json has changed";
    /** Wildcard dependency versions were resolved to concrete ranges. */
    InstallReason["DEPS_RESOLVED"] = "resolved dependency versions changed";
})(InstallReason || (exports.InstallReason = InstallReason = {}));
/**
 * Determines if an npm package is "scoped" (i.e. it starts with "xxx@").
 */
function isScoped(packageName) {
    return packageName.startsWith("@");
}
function parsePackageName(packageName) {
    if (isScoped(packageName)) {
        const [scope, name] = packageName.split("/");
        return { scope, name };
    }
    return { name: packageName };
}
function defaultNpmAccess(packageName) {
    return isScoped(packageName) ? NpmAccess.RESTRICTED : NpmAccess.PUBLIC;
}
function defaultNpmToken(npmToken, registry) {
    // if we are publishing to AWS CodeArtifact, no NPM_TOKEN used (will be requested using AWS CLI later).
    if ((0, release_1.isAwsCodeArtifactRegistry)(registry)) {
        return undefined;
    }
    // if we are publishing to GitHub Packages, default to GITHUB_TOKEN.
    const isGitHubPackages = registry === GITHUB_PACKAGES_REGISTRY;
    return (npmToken ??
        (isGitHubPackages ? DEFAULT_GITHUB_TOKEN_SECRET : DEFAULT_NPM_TOKEN_SECRET));
}
function determineLockfile(packageManager) {
    switch (packageManager) {
        case NodePackageManager.YARN:
        case NodePackageManager.YARN_CLASSIC:
        case NodePackageManager.YARN2:
        case NodePackageManager.YARN_BERRY:
            return "yarn.lock";
        case NodePackageManager.NPM:
            return "package-lock.json";
        case NodePackageManager.PNPM:
            return "pnpm-lock.yaml";
        case NodePackageManager.BUN:
            return "bun.lockb";
        default:
            throw new Error(`unsupported package manager ${packageManager}`);
    }
}
/**
 * Maps a package manager name (as used in package.json `packageManager` and
 * `devEngines.packageManager` fields) to a `NodePackageManager` enum value.
 */
function packageManagerNameToEnum(name, majorVersion) {
    switch (name) {
        case "npm":
            return NodePackageManager.NPM;
        case "pnpm":
            return NodePackageManager.PNPM;
        case "bun":
            return NodePackageManager.BUN;
        case "yarn":
            if (majorVersion !== undefined && majorVersion >= 2) {
                return NodePackageManager.YARN_BERRY;
            }
            return NodePackageManager.YARN_CLASSIC;
        default:
            return undefined;
    }
}
/**
 * Infers the `NodePackageManager` from an existing `package.json`.
 *
 * Checks in order:
 * 1. `packageManager` field (corepack, e.g. `"yarn@4.1.0"`)
 * 2. `devEngines.packageManager` field (single entry only; arrays are
 *    ambiguous and skipped unless a lockfile disambiguates)
 *
 * @returns the inferred package manager, or `undefined`
 */
function inferPackageManagerFromPkgJson(prev, outdir) {
    if (!prev) {
        return undefined;
    }
    // 1. Corepack packageManager field: "yarn@4.1.0"
    const corepack = prev.packageManager;
    if (corepack) {
        const match = corepack.match(/^(\w+)@(\d+)/);
        if (match) {
            const result = packageManagerNameToEnum(match[1], Number(match[2]));
            if (result) {
                return result;
            }
        }
    }
    // 2. devEngines.packageManager
    const devEnginesPm = prev.devEngines?.packageManager;
    if (devEnginesPm) {
        if (!Array.isArray(devEnginesPm)) {
            // Single entry
            return packageManagerNameToEnum(devEnginesPm.name);
        }
        if (devEnginesPm.length === 1) {
            return packageManagerNameToEnum(devEnginesPm[0].name);
        }
        // Multiple entries — try to disambiguate with lockfile
        if (devEnginesPm.length > 1) {
            const fromLockfile = inferPackageManagerFromLockfile(outdir);
            if (fromLockfile) {
                return fromLockfile;
            }
        }
    }
    return undefined;
}
/**
 * Infers the `NodePackageManager` from the presence of a lockfile.
 */
function inferPackageManagerFromLockfile(outdir) {
    if ((0, fs_1.existsSync)((0, path_1.join)(outdir, "pnpm-lock.yaml"))) {
        return NodePackageManager.PNPM;
    }
    if ((0, fs_1.existsSync)((0, path_1.join)(outdir, "bun.lockb"))) {
        return NodePackageManager.BUN;
    }
    if ((0, fs_1.existsSync)((0, path_1.join)(outdir, "yarn.lock"))) {
        return NodePackageManager.YARN_CLASSIC;
    }
    if ((0, fs_1.existsSync)((0, path_1.join)(outdir, "package-lock.json"))) {
        return NodePackageManager.NPM;
    }
    return undefined;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-package.js","sourceRoot":"","sources":["../../src/javascript/node-package.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  accessSync,\n  constants,\n  existsSync,\n  readdirSync,\n  readFileSync,\n  unlinkSync,\n} from \"fs\";\nimport { join, resolve } from \"path\";\nimport * as semver from \"semver\";\nimport type { PnpmWorkspaceYamlOptions } from \"./pnpm-workspace\";\nimport { PnpmWorkspaceYaml } from \"./pnpm-workspace\";\nimport {\n  execCommand,\n  extractCodeArtifactDetails,\n  isYarnBerry,\n  isYarnClassic,\n  minVersion,\n  tryResolveDependencyVersion,\n} from \"./util\";\nimport type { YarnrcOptions } from \"./yarnrc\";\nimport { Yarnrc } from \"./yarnrc\";\nimport { resolve as resolveJson } from \"../_resolve\";\nimport { Component } from \"../component\";\nimport { DependencyType } from \"../dependencies\";\nimport { JsonFile } from \"../json\";\nimport type { Project } from \"../project\";\nimport { isAwsCodeArtifactRegistry } from \"../release\";\nimport type { Task } from \"../task\";\nimport type { TaskStep } from \"../task-model\";\nimport { isTruthy, normalizePersistedPath, sorted, writeFile } from \"../util\";\n\nconst UNLICENSED = \"UNLICENSED\";\nconst DEFAULT_NPM_REGISTRY_URL = \"https://registry.npmjs.org/\";\nconst GITHUB_PACKAGES_REGISTRY = \"npm.pkg.github.com\";\nconst DEFAULT_NPM_TOKEN_SECRET = \"NPM_TOKEN\";\nconst DEFAULT_GITHUB_TOKEN_SECRET = \"GITHUB_TOKEN\";\nconst DEFAULT_PNPM_VERSION = \"10.33.0\";\nconst DEFAULT_YARN_BERRY_VERSION = \"4.13.0\";\nconst DEFAULT_YARN_CLASSIC_VERSION = \"1.22.22\";\n\nexport interface NodePackageOptions {\n  /**\n   * The \"name\" in package.json\n   * @default - defaults to project name\n   * @featured\n   */\n  readonly packageName?: string;\n  /**\n   * The description is just a string that helps people understand the purpose of the package.\n   * It can be used when searching for packages in a package manager as well.\n   * See https://classic.yarnpkg.com/en/docs/package-json/#toc-description\n   * @featured\n   */\n  readonly description?: string;\n\n  /**\n   * Runtime dependencies of this module.\n   *\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `pnpm add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `pnpm add` or `npm i` (e.g. `express@^2`) and\n   * this will be what your `package.json` will eventually include.\n   *\n   * @example [ 'express', 'lodash', 'foo@^2' ]\n   * @default []\n   * @featured\n   */\n  readonly deps?: string[];\n\n  /**\n   * Build dependencies for this module. These dependencies will only be\n   * available in your build environment but will not be fetched when this\n   * module is consumed.\n   *\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `pnpm add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `pnpm add` or `npm i` (e.g. `express@^2`) and\n   * this will be what your `package.json` will eventually include.\n   *\n   * @example [ 'typescript', '@types/express' ]\n   * @default []\n   * @featured\n   */\n  readonly devDeps?: string[];\n\n  /**\n   * Peer dependencies for this module. Dependencies listed here are required to\n   * be installed (and satisfied) by the _consumer_ of this library. Using peer\n   * dependencies allows you to ensure that only a single module of a certain\n   * library exists in the `node_modules` tree of your consumers.\n   *\n   * Note that prior to npm@7, peer dependencies are _not_ automatically\n   * installed, which means that adding peer dependencies to a library will be a\n   * breaking change for your customers.\n   *\n   * Unless `peerDependencyOptions.pinnedDevDependency` is disabled (it is\n   * enabled by default), projen will automatically add a dev dependency with a\n   * pinned version for each peer dependency. This will ensure that you build &\n   * test your module against the lowest peer version required.\n   *\n   * @default []\n   */\n  readonly peerDeps?: string[];\n\n  /**\n   * List of dependencies to bundle into this module. These modules will be\n   * added both to the `dependencies` section and `bundledDependencies` section of\n   * your `package.json`.\n   *\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `pnpm add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `pnpm add` or `npm i` (e.g. `express@^2`) and\n   * this will be what your `package.json` will eventually include.\n   */\n  readonly bundledDeps?: string[];\n\n  /**\n   * Options for `peerDeps`.\n   */\n  readonly peerDependencyOptions?: PeerDependencyOptions;\n\n  /**\n   * Allow the project to include `peerDependencies` and `bundledDependencies`.\n   * This is normally only allowed for libraries. For apps, there's no meaning\n   * for specifying these.\n   *\n   * @default true\n   */\n  readonly allowLibraryDependencies?: boolean;\n\n  /**\n   * Keywords to include in `package.json`.\n   */\n  readonly keywords?: string[];\n\n  /**\n   * Configuration values available to package scripts at runtime.\n   *\n   * Values should be JSON-serializable.\n   *\n   * @see https://docs.npmjs.com/cli/v11/configuring-npm/package-json#config\n   * @default - no package configuration\n   */\n  readonly config?: Record<string, any>;\n\n  /**\n   * Module entrypoint (`main` in `package.json`)\n   *\n   * Set to an empty string to not include `main` in your package.json\n   *\n   * @default \"lib/index.js\"\n   */\n  readonly entrypoint?: string;\n\n  /**\n   * Binary programs vended with your module.\n   *\n   * You can use this option to add/customize how binaries are represented in\n   * your `package.json`, but unless `autoDetectBin` is `false`, every\n   * executable file under `bin` will automatically be added to this section.\n   */\n  readonly bin?: Record<string, string>;\n\n  /**\n   * Automatically add all executables under the `bin` directory to your\n   * `package.json` file under the `bin` section.\n   *\n   * @default true\n   */\n  readonly autoDetectBin?: boolean;\n\n  /**\n   * The Node Package Manager used to execute scripts\n   *\n   * @default - Detected from the calling process or `YARN_CLASSIC` if detection fails.\n   * @pjnew $PACKAGE_MANAGER\n   */\n  readonly packageManager?: NodePackageManager;\n\n  /**\n   * Add a `dedupe` task that deduplicates project dependencies.\n   *\n   * Deduplication prevents multiple versions of the same package from being\n   * installed, if a single version can satisfy all requested version ranges.\n   * This prevents version proliferation and reduces the size of the dependency\n   * tree.\n   *\n   * The behavior depends on the package manager:\n   * - npm: runs `npm dedupe` after every mutating install.\n   * - pnpm: runs `pnpm dedupe` after every mutating install.\n   * - Yarn Berry: runs `yarn dedupe` after every mutating install. If\n   *   `yarnBerryOptions.dedupePackages` is set, only the listed packages are\n   *   deduplicated.\n   * - Yarn Classic: `yarn install` already deduplicates, so the task only\n   *   prints an informational message.\n   * - Bun: not supported, enabling this option throws an error.\n   *\n   * @default - false, unless `yarnBerryOptions.dedupePackages` is set\n   */\n  readonly dedupeDeps?: boolean;\n\n  /**\n   * The repository is the location where the actual code for your package lives.\n   * See https://classic.yarnpkg.com/en/docs/package-json/#toc-repository\n   */\n  readonly repository?: string;\n\n  /**\n   * If the package.json for your package is not in the root directory (for example if it is part of a monorepo),\n   * you can specify the directory in which it lives.\n   */\n  readonly repositoryDirectory?: string;\n\n  /**\n   * Author's name\n   */\n  readonly authorName?: string;\n\n  /**\n   * Author's e-mail\n   */\n  readonly authorEmail?: string;\n\n  /**\n   * Author's URL / Website\n   */\n  readonly authorUrl?: string;\n\n  /**\n   * Is the author an organization\n   */\n  readonly authorOrganization?: boolean;\n\n  /**\n   * Package's Homepage / Website\n   */\n  readonly homepage?: string;\n\n  /**\n   * Package's Stability\n   */\n  readonly stability?: string;\n\n  /**\n   * The minimum node version required by this package to function.\n   * Most projects should not use this option.\n   *\n   * The value indicates that the package is incompatible with any older versions of node.\n   * This requirement is enforced via the engines field.\n   *\n   * You will normally not need to set this option, even if your package is incompatible with EOL versions of node.\n   * Consider this option only if your package depends on a specific feature, that is not available in other LTS versions.\n   * Setting this option has very high impact on the consumers of your package,\n   * as package managers will actively prevent usage with node versions you have marked as incompatible.\n   *\n   * To change the node version of your CI/CD workflows, use `workflowNodeVersion`.\n   *\n   * @default - no minimum version is enforced\n\n   */\n  readonly minNodeVersion?: string;\n\n  /**\n   * The maximum node version supported by this package.\n   * Most projects should not use this option.\n   *\n   * The value indicates that the package is incompatible with any newer versions of node.\n   * This requirement is enforced via the engines field.\n   *\n   * You will normally not need to set this option.\n   * Consider this option only if your package is known to not function with newer versions of node.\n   *\n   * @default - no maximum version is enforced\n   */\n  readonly maxNodeVersion?: string;\n\n  /**\n   * The version of PNPM to use if using PNPM as a package manager.\n   *\n   * @default \"10.33.0\"\n   */\n  readonly pnpmVersion?: string;\n\n  /**\n   * The version of Bun to use if using Bun as a package manager.\n   *\n   * @default \"latest\"\n   */\n  readonly bunVersion?: string;\n\n  /**\n   * License's SPDX identifier.\n   * See https://github.com/projen/projen/tree/main/license-text for a list of supported licenses.\n   * Use the `licensed` option if you want to no license to be specified.\n   *\n   * @default \"Apache-2.0\"\n   */\n  readonly license?: string;\n\n  /**\n   * Indicates if a license should be added.\n   *\n   * @default true\n   */\n  readonly licensed?: boolean;\n\n  /**\n   * The base URL of the npm package registry.\n   *\n   * Must be a URL (e.g. start with \"https://\" or \"http://\")\n   *\n   * @default \"https://registry.npmjs.org\"\n   */\n  readonly npmRegistryUrl?: string;\n\n  /**\n   * The url to your project's issue tracker.\n   */\n  readonly bugsUrl?: string;\n\n  /**\n   * The email address to which issues should be reported.\n   */\n  readonly bugsEmail?: string;\n\n  /**\n   * Access level of the npm package.\n   *\n   * @default - for scoped packages (e.g. `foo@bar`), the default is\n   * `NpmAccess.RESTRICTED`, for non-scoped packages, the default is\n   * `NpmAccess.PUBLIC`.\n   */\n  readonly npmAccess?: NpmAccess;\n\n  /**\n   * Should provenance statements be generated when the package is published.\n   *\n   * A supported package manager is required to publish a package with npm provenance statements and\n   * you will need to use a supported CI/CD provider.\n   *\n   * Note that the projen `Release` and `Publisher` components are using `publib` to publish packages,\n   * which is using npm internally and supports provenance statements independently of the package manager used.\n   *\n   * @see https://docs.npmjs.com/generating-provenance-statements\n   * @default - true for public packages, false otherwise\n   */\n  readonly npmProvenance?: boolean;\n\n  /**\n   * GitHub secret which contains the NPM token to use when publishing packages.\n   *\n   * @default \"NPM_TOKEN\"\n   */\n  readonly npmTokenSecret?: string;\n\n  /**\n   * Use trusted publishing for publishing to npmjs.com\n   * Needs to be pre-configured on npm.js to work.\n   *\n   * @see\n   *\n   * @default - false\n   */\n  readonly npmTrustedPublishing?: boolean;\n\n  /**\n   * Options for npm packages using AWS CodeArtifact.\n   * This is required if publishing packages to, or installing scoped packages from AWS CodeArtifact\n   *\n   * @default - undefined\n   */\n  readonly codeArtifactOptions?: CodeArtifactOptions;\n\n  /**\n   * Options for privately hosted scoped packages\n   *\n   * @default - fetch all scoped packages from the public npm registry\n   */\n  readonly scopedPackagesOptions?: ScopedPackagesOptions[];\n\n  /**\n   * Options for Yarn Berry\n   *\n   * @default - Yarn Berry v4 with all default options\n   */\n  readonly yarnBerryOptions?: YarnBerryOptions;\n\n  /**\n   * Options for pnpm\n   *\n   * @default - all default options\n   */\n  readonly pnpmOptions?: PnpmOptions;\n\n  /**\n   * Configure the `devEngines` field in `package.json`.\n   *\n   * The `devEngines.packageManager` field is automatically populated based on\n   * the resolved `packageManager` value. Any fields provided here are merged\n   * with the auto-populated `packageManager` entry.\n   *\n   * @see https://docs.npmjs.com/cli/v10/configuring-npm/package-json#devengines\n   */\n  readonly devEngines?: DevEngines;\n\n  /**\n   * Automatically add the resolved `packageManager` to `devEngines.packageManager`\n   * in `package.json`, setting `onFail` to `ignore`.\n   *\n   * @default true\n   */\n  readonly addPackageManagerToDevEngines?: boolean;\n\n  /**\n   * Automatically delete lockfiles from package managers that are not the\n   * active one. Only triggered when the lockfile for the configured package\n   * manager already exists.\n   *\n   * This is useful when migrating between package managers to avoid conflicts.\n   *\n   * @default true\n   */\n  readonly deleteOrphanedLockFiles?: boolean;\n\n  /**\n   * List of dependency (package) names that are allowed to run lifecycle\n   * install scripts (`preinstall`, `install`, `postinstall`, `prepare`)\n   * during dependency installation.\n   *\n   * These scripts can execute arbitrary code, making them a common\n   * supply-chain attack vector. Package managers are moving toward\n   * blocking them by default and requiring an explicit allowlist.\n   * Configuring `allowScripts` sets up that allowlist so scripts only run\n   * for the packages you have explicitly reviewed and trust.\n   *\n   * Support for this setting depends on the configured `packageManager`:\n   *\n   * - `NPM`: written to the native `allowScripts` field in `package.json`\n   *   (requires npm >= 11.16; see https://docs.npmjs.com/cli/v11/commands/npm-approve-scripts).\n   * - `BUN`: written to the native `trustedDependencies` field in\n   *   `package.json` (see https://bun.com/docs/pm/lifecycle).\n   * - `PNPM`: written to the `onlyBuiltDependencies` setting in\n   *   `pnpm-workspace.yaml` (see https://pnpm.io/settings#onlybuiltdependencies).\n   * - `YARN2`, `YARN_BERRY`: written to the native\n   *   `dependenciesMeta.<pkg>.built` allowlist in `package.json`, combined\n   *   with `enableScripts: false` in `.yarnrc.yml` (see\n   *   https://yarnpkg.com/features/security#postinstalls). If you set\n   *   `yarnBerryOptions.yarnRcOptions.enableScripts` explicitly, that value\n   *   is respected instead of being overridden.\n   * - `YARN`, `YARN_CLASSIC`: not supported. Yarn Classic has no native\n   *   mechanism to allowlist install scripts for specific dependencies.\n   *   Setting this option with one of these package managers throws an\n   *   error at synthesis time.\n   *\n   * @default - all install scripts are allowed to run (package manager default)\n   */\n  readonly allowScripts?: string[];\n}\n\n/**\n * A dependency entry for the `devEngines` field in `package.json`.\n */\nexport interface DevEngineDependency {\n  /**\n   * The name of the dependency.\n   */\n  readonly name: string;\n\n  /**\n   * The version range for the dependency.\n   *\n   * @default \"*\"\n   */\n  readonly version?: string;\n\n  /**\n   * What action to take if validation fails.\n   *\n   * @default \"error\"\n   */\n  readonly onFail?: \"ignore\" | \"warn\" | \"error\" | \"download\";\n}\n\n/**\n * The `devEngines` field in `package.json`.\n *\n * @see https://docs.npmjs.com/cli/v10/configuring-npm/package-json#devengines\n */\nexport interface DevEngines {\n  /**\n   * Supported operating systems.\n   */\n  readonly os?: DevEngineDependency | DevEngineDependency[];\n\n  /**\n   * Supported CPU architectures.\n   */\n  readonly cpu?: DevEngineDependency | DevEngineDependency[];\n\n  /**\n   * Supported C standard libraries.\n   */\n  readonly libc?: DevEngineDependency | DevEngineDependency[];\n\n  /**\n   * Supported JavaScript runtimes.\n   */\n  readonly runtime?: DevEngineDependency | DevEngineDependency[];\n\n  /**\n   * Supported package managers.\n   */\n  readonly packageManager?: DevEngineDependency | DevEngineDependency[];\n}\n\n/**\n * Options for authorizing requests to a AWS CodeArtifact npm repository.\n */\nexport enum CodeArtifactAuthProvider {\n  /**\n   * Fixed credentials provided via Github secrets.\n   */\n  ACCESS_AND_SECRET_KEY_PAIR = \"ACCESS_AND_SECRET_KEY_PAIR\",\n\n  /**\n   * Ephemeral credentials provided via Github's OIDC integration with an IAM role.\n   * See:\n   * https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html\n   * https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services\n   */\n  GITHUB_OIDC = \"GITHUB_OIDC\",\n}\n\n/**\n * Options for publishing npm packages to AWS CodeArtifact.\n */\nexport interface CodeArtifactOptions {\n  /**\n   * Provider to use for authorizing requests to AWS CodeArtifact.\n   *\n   * @default CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR\n   */\n  readonly authProvider?: CodeArtifactAuthProvider;\n\n  /**\n   * GitHub secret which contains the AWS access key ID to use when publishing packages to AWS CodeArtifact.\n   * This property must be specified only when publishing to AWS CodeArtifact (`npmRegistryUrl` contains AWS CodeArtifact URL).\n   *\n   * @default - When the `authProvider` value is set to\n   * `CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR`, the default is\n   * \"AWS_ACCESS_KEY_ID\". For `CodeArtifactAuthProvider.GITHUB_OIDC`, this\n   * value must be left undefined.\n   */\n  readonly accessKeyIdSecret?: string;\n\n  /**\n   * GitHub secret which contains the AWS secret access key to use when publishing packages to AWS CodeArtifact.\n   * This property must be specified only when publishing to AWS CodeArtifact (`npmRegistryUrl` contains AWS CodeArtifact URL).\n   *\n   * @default - When the `authProvider` value is set to\n   * `CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR`, the default is\n   * \"AWS_SECRET_ACCESS_KEY\". For `CodeArtifactAuthProvider.GITHUB_OIDC`, this\n   * value must be left undefined.\n   */\n  readonly secretAccessKeySecret?: string;\n\n  /**\n   * ARN of AWS role to be assumed prior to get authorization token from AWS CodeArtifact\n   * This property must be specified only when publishing to AWS CodeArtifact (`registry` contains AWS CodeArtifact URL).\n   * When using the `CodeArtifactAuthProvider.GITHUB_OIDC` auth provider, this value must be defined.\n   *\n   * @default undefined\n   */\n  readonly roleToAssume?: string;\n}\n\n/**\n * Options for scoped packages\n */\nexport interface ScopedPackagesOptions {\n  /**\n   * Scope of the packages\n   *\n   * @example \"@angular\"\n   */\n  readonly scope: string;\n\n  /**\n   * URL of the registry for scoped packages\n   */\n  readonly registryUrl: string;\n}\n\n/**\n * Represents the npm `package.json` file.\n */\nexport class NodePackage extends Component {\n  /**\n   * Returns the `NodePackage` instance associated with a project or `undefined` if\n   * there is no NodePackage.\n   * @param project The project\n   * @returns A NodePackage, or undefined\n   */\n  public static of(project: Project): NodePackage | undefined {\n    const isIt = (o: Component): o is NodePackage => o instanceof NodePackage;\n    return project.components.find(isIt);\n  }\n\n  /**\n   * The name of the npm package.\n   */\n  public readonly packageName: string;\n\n  /**\n   * The module's entrypoint (e.g. `lib/index.js`).\n   */\n  public readonly entrypoint: string;\n\n  /**\n   * Allow project to take library dependencies.\n   */\n  public readonly allowLibraryDependencies: boolean;\n\n  /**\n   * The package manager to use.\n   */\n  public readonly packageManager: NodePackageManager;\n\n  /**\n   * @deprecated use `addField(x, y)`\n   */\n  public readonly manifest: any;\n\n  /**\n   * The minimum node version required by this package to function.\n   *\n   * This value indicates the package is incompatible with older versions.\n   */\n  public readonly minNodeVersion?: string;\n\n  /**\n   * Maximum node version supported by this package.\n   *\n   * The value indicates the package is incompatible with newer versions.\n   */\n  public readonly maxNodeVersion?: string;\n\n  /**\n   * The version of PNPM to use if using PNPM as a package manager.\n   *\n   * @returns `undefined` if the package manager is not PNPM.\n   */\n  public get pnpmVersion(): string | undefined {\n    return this.packageManager === NodePackageManager.PNPM\n      ? this._pnpmVersion\n      : undefined;\n  }\n\n  /**\n   * The version of Bun to use if using Bun as a package manager.\n   *\n   * @returns `undefined` if the package manager is not Bun.\n   */\n  public get bunVersion(): string | undefined {\n    return this.packageManager === NodePackageManager.BUN\n      ? this._bunVersion\n      : undefined;\n  }\n\n  /**\n   * The version of Yarn to use if using Yarn as a package manager.\n   *\n   * @returns `undefined` if the package manager is not Yarn.\n   */\n  public get yarnVersion(): string | undefined {\n    if (isYarnBerry(this.packageManager)) {\n      return this._yarnBerryVersion;\n    }\n    if (isYarnClassic(this.packageManager)) {\n      return DEFAULT_YARN_CLASSIC_VERSION;\n    }\n    return undefined;\n  }\n\n  private readonly _pnpmVersion: string;\n  private readonly _bunVersion: string;\n  private readonly _yarnBerryVersion: string;\n  private readonly _options: NodePackageOptions;\n\n  /**\n   * The SPDX license of this module. `undefined` if this package is not licensed.\n   */\n  public readonly license?: string;\n\n  /**\n   * npm registry (e.g. `https://registry.npmjs.org`). Use `npmRegistryHost` to get just the host name.\n   */\n  public readonly npmRegistryUrl: string;\n\n  /**\n   * The npm registry host (e.g. `registry.npmjs.org`).\n   */\n  public readonly npmRegistry: string;\n\n  /**\n   * GitHub secret which contains the NPM token to use when publishing packages.\n   */\n  public readonly npmTokenSecret?: string;\n\n  /**\n   * Options for npm packages using AWS CodeArtifact.\n   * This is required if publishing packages to, or installing scoped packages from AWS CodeArtifact\n   *\n   * @default - undefined\n   */\n  readonly codeArtifactOptions?: CodeArtifactOptions;\n\n  /**\n   * Options for privately hosted scoped packages\n   *\n   * @default undefined\n   */\n  readonly scopedPackagesOptions?: ScopedPackagesOptions[];\n\n  /**\n   * npm package access level.\n   */\n  public readonly npmAccess: NpmAccess;\n\n  /**\n   * Should provenance statements be generated when package is published.\n   */\n  public readonly npmProvenance: boolean;\n\n  /**\n   * The name of the lock file.\n   */\n  public readonly lockFile: string;\n\n  /**\n   * The task for installing project dependencies (non-frozen).\n   */\n  public readonly installTask: Task;\n\n  /**\n   * The task for installing project dependencies (frozen).\n   */\n  public readonly installCiTask: Task;\n\n  /**\n   * The task for deduplicating project dependencies, if configured.\n   */\n  public readonly dedupeTask?: Task;\n\n  /**\n   * The package.json file.\n   */\n  public readonly file: JsonFile;\n\n  private readonly scripts: Record<string, string> = {};\n  private readonly scriptsToBeRemoved = new Set<string>();\n  private readonly keywords: Set<string> = new Set();\n  private readonly allowedScripts: Set<string> = new Set();\n  private readonly bin: Record<string, string> = {};\n  private readonly engines: Record<string, string> = {};\n  private readonly peerDependencyOptions: PeerDependencyOptions;\n  private readonly _prev?: Record<string, any>;\n  private _renderedDeps?: NpmDependencies;\n  private readonly _packageManagerExplicit: boolean;\n\n  constructor(project: Project, options: NodePackageOptions = {}) {\n    super(project);\n\n    this.packageName = options.packageName ?? project.name;\n    this.peerDependencyOptions = {\n      pinnedDevDependency: true,\n      ...options.peerDependencyOptions,\n    };\n    this.allowLibraryDependencies = options.allowLibraryDependencies ?? true;\n\n    // Read previous package.json early so we can use it for inference\n    this._prev = this.readPackageJson();\n\n    // Resolve package manager: explicit > inferred from package.json > fallback\n    if (options.packageManager) {\n      this.packageManager = options.packageManager;\n      this._packageManagerExplicit = true;\n    } else {\n      this._packageManagerExplicit = false;\n      const fromPkgJson = inferPackageManagerFromPkgJson(\n        this._prev,\n        project.outdir,\n      );\n      if (fromPkgJson) {\n        this.packageManager = fromPkgJson;\n      } else {\n        this.project.logger.warn(\n          `[DEPRECATED] \"packageManager\" is not set in projenrc, defaulting to \"${NodePackageManager.YARN_CLASSIC}\". ` +\n            `This will become a required option in a future version. Please set it explicitly.`,\n        );\n        this.packageManager = NodePackageManager.YARN_CLASSIC;\n      }\n    }\n\n    this.entrypoint = options.entrypoint ?? \"lib/index.js\";\n    this.lockFile = determineLockfile(this.packageManager);\n\n    // Clean up lockfiles from other package managers during migration\n    if (options.deleteOrphanedLockFiles !== false) {\n      this.deleteOrphanedLockFiles();\n    }\n\n    this.project.annotateGenerated(`/${this.lockFile}`);\n\n    const {\n      npmAccess,\n      npmRegistry,\n      npmRegistryUrl,\n      npmTokenSecret,\n      codeArtifactOptions,\n      scopedPackagesOptions,\n      npmProvenance,\n    } = this.parseNpmOptions(options);\n    this.npmAccess = npmAccess;\n    this.npmRegistry = npmRegistry;\n    this.npmRegistryUrl = npmRegistryUrl;\n    this.npmTokenSecret = npmTokenSecret;\n    this.codeArtifactOptions = codeArtifactOptions;\n    this.scopedPackagesOptions = scopedPackagesOptions;\n    this.npmProvenance = npmProvenance;\n\n    this.processDeps(options);\n\n    // empty objects are here to preserve order for backwards compatibility\n    this.manifest = {\n      name: this.packageName,\n      description: options.description,\n      repository: !options.repository\n        ? undefined\n        : {\n            type: \"git\",\n            url: options.repository,\n            directory: options.repositoryDirectory,\n          },\n      bin: () => this.renderBin(),\n      scripts: () => this.renderScripts(),\n      author: this.renderAuthor(options),\n      devDependencies: {},\n      peerDependencies: {},\n      dependencies: {},\n      bundledDependencies: [],\n      ...this.renderPackageResolutions(),\n      keywords: () => this.renderKeywords(),\n      config: options.config,\n      engines: () => this.renderEngines(),\n      devEngines: () => this.renderDevEngines(),\n      main: this.entrypoint !== \"\" ? this.entrypoint : undefined,\n      license: () => this.license ?? UNLICENSED,\n      homepage: options.homepage,\n      stability: options.stability,\n      publishConfig: () => this.renderPublishConfig(),\n      typesVersions: this._prev?.typesVersions,\n      allowScripts:\n        this.packageManager === NodePackageManager.NPM\n          ? () => this.renderNpmAllowScripts()\n          : undefined,\n      trustedDependencies:\n        this.packageManager === NodePackageManager.BUN\n          ? () => this.renderBunTrustedDependencies()\n          : undefined,\n      dependenciesMeta: isYarnBerry(this.packageManager)\n        ? () => this.renderYarnBerryDependenciesMeta()\n        : undefined,\n\n      // in release CI builds we bump the version before we run \"build\" so we want\n      // to preserve the version number. otherwise, we always set it to 0.0.0\n      version: this.determineVersion(this._prev?.version),\n      bugs:\n        options.bugsEmail || options.bugsUrl\n          ? {\n              email: options.bugsEmail,\n              url: options.bugsUrl,\n            }\n          : undefined,\n    };\n\n    // Resolve package manager versions\n    this._options = options;\n    this._pnpmVersion = options.pnpmVersion ?? DEFAULT_PNPM_VERSION;\n    this._bunVersion = options.bunVersion ?? \"latest\";\n    this._yarnBerryVersion =\n      options.yarnBerryOptions?.version ?? DEFAULT_YARN_BERRY_VERSION;\n    this.addAllowedScripts(...(options.allowScripts ?? []));\n\n    // Configure Yarn Berry if using\n    if (isYarnBerry(this.packageManager)) {\n      this.configureYarnBerry(project, options);\n    }\n\n    // Configure pnpm if using\n    if (this.packageManager === NodePackageManager.PNPM) {\n      this.configurePnpm(project, options);\n    }\n\n    this.file = new JsonFile(this, \"package.json\", {\n      obj: this.manifest,\n      readonly: false, // we want \"yarn add\" to work and we have anti-tamper\n      newline: true, // all package managers prefer a newline, see https://github.com/projen/projen/issues/2076\n      committed: true, // needs to be committed so users can install the dependencies\n    });\n\n    this.addKeywords(...(options.keywords ?? []));\n    this.addBin(options.bin ?? {});\n\n    // automatically add all executable files under \"bin\"\n    if (options.autoDetectBin ?? true) {\n      this.autoDiscoverBinaries();\n    }\n\n    // node version\n    this.minNodeVersion = options.minNodeVersion;\n    this.maxNodeVersion = options.maxNodeVersion;\n    this.addNodeEngine();\n\n    this.configureCorepack();\n\n    this.addCodeArtifactLoginScript();\n\n    // license\n    if (options.licensed ?? true) {\n      this.license = options.license ?? \"Apache-2.0\";\n    }\n\n    this.installTask = project.addTask(\"install\", {\n      description:\n        \"Install project dependencies and update lockfile (non-frozen)\",\n      exec: this.installAndUpdateLockfileCommand,\n    });\n\n    this.installCiTask = project.addTask(\"install:ci\", {\n      description: \"Install project dependencies using frozen lockfile\",\n      exec: this.installCommand,\n    });\n\n    // Needs to happen after the install tasks have been added\n    this.dedupeTask = this.maybeAddDedupeTask(options);\n  }\n\n  /**\n   * Adds a `dedupe` task if enabled via `dedupeDeps` or implied by\n   * `yarnBerryOptions.dedupePackages`.\n   *\n   * @returns the dedupe task, or `undefined` if not enabled.\n   */\n  private maybeAddDedupeTask(options: NodePackageOptions): Task | undefined {\n    const yarnBerryDedupePackages = options.yarnBerryOptions?.dedupePackages;\n    if (!(options.dedupeDeps ?? yarnBerryDedupePackages !== undefined)) {\n      return undefined;\n    }\n\n    if (this.packageManager === NodePackageManager.BUN) {\n      throw new Error(\n        \"The 'dedupeDeps' option is not supported for Bun: bun does not provide a dedupe command.\",\n      );\n    }\n\n    const dedupeTask = this.project.addTask(\"dedupe\", {\n      description: \"Deduplicate project dependencies\",\n    });\n\n    if (isYarnClassic(this.packageManager)) {\n      // Yarn Classic always deduplicates as part of `yarn install`\n      dedupeTask.say(\n        \"The dedupe command isn't necessary. `yarn install` will already dedupe.\",\n      );\n    } else {\n      dedupeTask.execArgs(\n        isYarnBerry(this.packageManager)\n          ? [\"yarn\", \"dedupe\", ...(yarnBerryDedupePackages ?? [])]\n          : [this.packageManager, \"dedupe\"],\n      );\n\n      // Add dedupe to mutable install task\n      this.installTask.spawn(dedupeTask);\n    }\n\n    return dedupeTask;\n  }\n\n  /**\n   * Defines normal dependencies.\n   *\n   * @param deps Names modules to install. By default, the the dependency will\n   * be installed in the next `pnpm projen` run and the version will be recorded\n   * in your `package.json` file. You can upgrade manually or using `pnpm\n   * add/update`. If you wish to specify a version range use this syntax:\n   * `module@^7`.\n   */\n  public addDeps(...deps: string[]) {\n    for (const dep of deps) {\n      this.project.deps.addDependency(dep, DependencyType.RUNTIME);\n    }\n  }\n\n  /**\n   * Defines development/test dependencies.\n   *\n   * @param deps Names modules to install. By default, the the dependency will\n   * be installed in the next `pnpm projen` run and the version will be recorded\n   * in your `package.json` file. You can upgrade manually or using `pnpm\n   * add/update`. If you wish to specify a version range use this syntax:\n   * `module@^7`.\n   */\n  public addDevDeps(...deps: string[]) {\n    for (const dep of deps) {\n      this.project.deps.addDependency(dep, DependencyType.BUILD);\n    }\n  }\n\n  /**\n   * Defines peer dependencies.\n   *\n   * When adding peer dependencies, a devDependency will also be added on the\n   * pinned version of the declared peer. This will ensure that you are testing\n   * your code against the minimum version required from your consumers.\n   *\n   * @param deps Names modules to install. By default, the the dependency will\n   * be installed in the next `pnpm projen` run and the version will be recorded\n   * in your `package.json` file. You can upgrade manually or using `pnpm\n   * add/update`. If you wish to specify a version range use this syntax:\n   * `module@^7`.\n   */\n  public addPeerDeps(...deps: string[]) {\n    if (Object.keys(deps).length && !this.allowLibraryDependencies) {\n      throw new Error(\n        `cannot add peer dependencies to an APP project: ${Object.keys(\n          deps,\n        ).join(\",\")}`,\n      );\n    }\n\n    for (const dep of deps) {\n      this.project.deps.addDependency(dep, DependencyType.PEER);\n    }\n  }\n\n  /**\n   * Defines bundled dependencies.\n   *\n   * Bundled dependencies will be added as normal dependencies as well as to the\n   * `bundledDependencies` section of your `package.json`.\n   *\n   * @param deps Names modules to install. By default, the the dependency will\n   * be installed in the next `pnpm projen` run and the version will be recorded\n   * in your `package.json` file. You can upgrade manually or using `pnpm\n   * add/update`. If you wish to specify a version range use this syntax:\n   * `module@^7`.\n   */\n  public addBundledDeps(...deps: string[]) {\n    if (deps.length && !this.allowLibraryDependencies) {\n      throw new Error(\n        `cannot add bundled dependencies to an APP project: ${deps.join(\",\")}`,\n      );\n    }\n\n    for (const dep of deps) {\n      this.project.deps.addDependency(dep, DependencyType.BUNDLED);\n    }\n  }\n\n  /**\n   * Adds an `engines` requirement to your package.\n   * @param engine The engine (e.g. `node`)\n   * @param version The semantic version requirement (e.g. `^10`)\n   */\n  public addEngine(engine: string, version: string) {\n    this.engines[engine] = version;\n  }\n\n  /**\n   * Adds keywords to package.json (deduplicated)\n   * @param keywords The keywords to add\n   */\n  public addKeywords(...keywords: string[]) {\n    for (const k of keywords) {\n      this.keywords.add(k);\n    }\n  }\n\n  /**\n   * Allows the given dependency (package) names to run lifecycle install\n   * scripts (`preinstall`, `install`, `postinstall`, `prepare`), in addition\n   * to any already allowed via the `allowScripts` option or previous calls.\n   *\n   * Useful for project types that want to allowlist a package by default\n   * while still letting consumers add further packages via `allowScripts`.\n   *\n   * @param packages The dependency (package) names to allow.\n   * @see NodePackageOptions.allowScripts\n   */\n  public addAllowedScripts(...packages: string[]) {\n    for (const pkg of packages) {\n      this.allowedScripts.add(pkg);\n    }\n  }\n\n  /**\n   * Removes the given dependency (package) names from the `allowScripts`\n   * allowlist, whether they were added via the `allowScripts` option, a\n   * project type default, or a previous call to `addAllowedScripts`.\n   *\n   * @param packages The dependency (package) names to remove.\n   * @see NodePackageOptions.allowScripts\n   */\n  public removeAllowedScripts(...packages: string[]) {\n    for (const pkg of packages) {\n      this.allowedScripts.delete(pkg);\n    }\n  }\n\n  public addBin(bins: Record<string, string>) {\n    for (const [k, v] of Object.entries(bins)) {\n      this.bin[k] = v;\n    }\n  }\n\n  /**\n   * Add a npm package.json script.\n   *\n   * @param name The script name\n   * @param command The command to execute, run by the package manager's shell.\n   */\n  public setScript(name: string, command: string) {\n    this.scripts[name] = command;\n  }\n\n  /**\n   * Removes an npm script (always successful).\n   *\n   * @param name The name of the script.\n   */\n  public removeScript(name: string) {\n    // need to keep track in case there's a task of the same name\n    this.scriptsToBeRemoved.add(name);\n    delete this.scripts[name];\n  }\n\n  /**\n   * Directly set fields in `package.json`.\n   * @escape\n   * @param name field name\n   * @param value field value\n   */\n  public addField(name: string, value: any) {\n    this.manifest[name] = value;\n  }\n\n  /**\n   * Sets the package version.\n   * @param version Package version.\n   */\n  public addVersion(version: string) {\n    this.manifest.version = version;\n  }\n\n  /**\n   * Defines resolutions for dependencies to change the normally resolved\n   * version of a dependency to something else.\n   *\n   * @param resolutions Names resolutions to be added. Specify a version or\n   * range with this syntax:\n   * `module@^7`\n   */\n  public addPackageResolutions(...resolutions: string[]) {\n    for (const resolution of resolutions) {\n      this.project.deps.addDependency(resolution, DependencyType.OVERRIDE);\n    }\n  }\n\n  /**\n   * Returns the package manager's immutable install command with a frozen lockfile, e.g. `npm ci` or `pnpm ci`.\n   *\n   * Prefer using `NodePackage.installCiTask`. The raw command string is intended for bootstrapping.\n   */\n  public get installCommand() {\n    return this.renderInstallCommand(true);\n  }\n\n  /**\n   * Returns the package manager's mutable install command with lockfile update, e.g. `npm install` or `pnpm install`.\n   *\n   * Prefer using `NodePackage.installTask`. The raw command string is intended for bootstrapping.\n   */\n  public get installAndUpdateLockfileCommand() {\n    return this.renderInstallCommand(false);\n  }\n\n  /**\n   * Attempt to resolve the currently installed version for a given dependency.\n   *\n   * @remarks\n   * This method will first look through the current project's dependencies.\n   * If found and semantically valid (not '*'), that will be used.\n   * Otherwise, it will fall back to locating a `package.json` manifest for the dependency\n   * through node's internal resolution reading the version from there.\n   *\n   * @param dependencyName Dependency to resolve for.\n   */\n  public tryResolveDependencyVersion(\n    dependencyName: string,\n  ): string | undefined {\n    try {\n      const fromDeps = this.project.deps.tryGetDependency(dependencyName);\n      const version = semver.coerce(fromDeps?.version, { loose: true });\n      if (version) {\n        return version.format();\n      }\n    } catch {}\n    return tryResolveDependencyVersion(dependencyName, {\n      paths: [this.project.outdir],\n    });\n  }\n\n  // ---------------------------------------------------------------------------------------\n  public synthesize() {\n    this._renderedDeps = this.renderDependencies();\n    super.synthesize();\n  }\n\n  public postSynthesize() {\n    super.postSynthesize();\n\n    // Phase 1: install if package.json changed or node_modules is missing\n    const initialTrigger = this.determineInitialInstallTrigger();\n    if (initialTrigger) {\n      this.logInstallTrigger(initialTrigger);\n      this.installDependencies(initialTrigger);\n    }\n\n    // Phase 2: resolve \"*\" deps and install again if versions changed\n    const resolutions = this.resolveDepsAndWritePackageJson();\n    if (resolutions?.length) {\n      const trigger: InstallTrigger = {\n        reason: InstallReason.DEPS_RESOLVED,\n        resolutions,\n      };\n      this.logInstallTrigger(trigger);\n      this.installDependencies(trigger);\n    }\n  }\n\n  /**\n   * Checks whether dependencies need to be installed before dependency\n   * resolution.\n   *\n   * @returns a structured trigger describing the reason, or `undefined` if\n   * no install is needed.\n   */\n  private determineInitialInstallTrigger(): InstallTrigger | undefined {\n    const hasNodeModules = existsSync(\n      join(this.project.outdir, \"node_modules\"),\n    );\n\n    if (this.file.changed) {\n      return {\n        reason: InstallReason.PACKAGE_JSON_CHANGED,\n        diff: this.file.diff(true),\n      };\n    }\n\n    if (!hasNodeModules) {\n      return { reason: InstallReason.NO_NODE_MODULES };\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Logs user-facing information about why dependencies are being installed.\n   * Emits an info-level summary and debug-level details (reason, diff, resolutions).\n   */\n  private logInstallTrigger(trigger: InstallTrigger) {\n    this.project.logger.info(\n      \"Installing dependencies... (use --debug for details)\",\n    );\n    this.project.logger.debug(`Install reason: ${trigger.reason}`);\n\n    if (trigger.diff) {\n      this.project.logger.debug(\n        `package.json diff:\\n${trigger.diff.join(\"\\n\")}`,\n      );\n    }\n\n    if (trigger.resolutions?.length) {\n      this.project.logger.info(\n        `Resolved dependency versions:\\n${trigger.resolutions.map((r) => `  ${r}`).join(\"\\n\")}`,\n      );\n    }\n  }\n\n  /**\n   * The command prefix to use when executing binary commands for this package\n   * manager (e.g. `npx`, `pnpm exec`, `yarn`, `bunx`).\n   */\n  public get execCommand(): string {\n    return execCommand(this.packageManager);\n  }\n\n  /**\n   * Returns `true` if we are running within a CI build.\n   */\n  private get isAutomatedBuild(): boolean {\n    return isTruthy(process.env.CI);\n  }\n\n  private determineVersion(currVersion?: string) {\n    if (!this.isReleaseBuild) {\n      return \"0.0.0\";\n    }\n\n    return currVersion ?? \"0.0.0\";\n  }\n\n  /**\n   * Returns `true` if this is a CI release build.\n   */\n  private get isReleaseBuild(): boolean {\n    return isTruthy(process.env.RELEASE);\n  }\n\n  // -------------------------------------------------------------------------------------------\n\n  private parseNpmOptions(options: NodePackageOptions) {\n    const npmRegistryUrl = options.npmRegistryUrl;\n\n    const npmr = new URL(npmRegistryUrl ?? DEFAULT_NPM_REGISTRY_URL);\n    if (!npmr || !npmr.hostname || !npmr.href) {\n      throw new Error(\n        `unable to determine npm registry host from url ${npmRegistryUrl}. Is this really a URL?`,\n      );\n    }\n\n    const npmAccess = options.npmAccess ?? defaultNpmAccess(this.packageName);\n    if (!isScoped(this.packageName) && npmAccess === NpmAccess.RESTRICTED) {\n      throw new Error(\n        `\"npmAccess\" cannot be RESTRICTED for non-scoped npm package \"${this.packageName}\"`,\n      );\n    }\n\n    const npmProvenance =\n      options.npmProvenance ?? npmAccess === NpmAccess.PUBLIC;\n    if (npmProvenance && npmAccess !== NpmAccess.PUBLIC) {\n      throw new Error(\n        `\"npmProvenance\" can only be enabled for public packages`,\n      );\n    }\n\n    const isAwsCodeArtifact = isAwsCodeArtifactRegistry(npmRegistryUrl);\n    const hasScopedPackage =\n      options.scopedPackagesOptions &&\n      options.scopedPackagesOptions.length !== 0;\n\n    if (isAwsCodeArtifact) {\n      if (options.npmTokenSecret) {\n        throw new Error(\n          '\"npmTokenSecret\" must not be specified when publishing AWS CodeArtifact.',\n        );\n      } else if (\n        options.codeArtifactOptions?.authProvider ===\n        CodeArtifactAuthProvider.GITHUB_OIDC\n      ) {\n        if (\n          options.codeArtifactOptions.accessKeyIdSecret ||\n          options.codeArtifactOptions.secretAccessKeySecret\n        ) {\n          throw new Error(\n            \"access and secret key pair should not be provided when using GITHUB_OIDC auth provider for AWS CodeArtifact\",\n          );\n        } else if (!options.codeArtifactOptions.roleToAssume) {\n          throw new Error(\n            '\"roleToAssume\" property is required when using GITHUB_OIDC for AWS CodeArtifact options',\n          );\n        }\n      }\n    } else {\n      if (\n        (options.codeArtifactOptions?.accessKeyIdSecret ||\n          options.codeArtifactOptions?.secretAccessKeySecret ||\n          options.codeArtifactOptions?.roleToAssume) &&\n        !hasScopedPackage\n      ) {\n        throw new Error(\n          \"codeArtifactOptions must only be specified when publishing AWS CodeArtifact or used in scoped packages.\",\n        );\n      }\n    }\n\n    // apply defaults for AWS CodeArtifact\n    let codeArtifactOptions: CodeArtifactOptions | undefined;\n    if (isAwsCodeArtifact || hasScopedPackage) {\n      const authProvider =\n        options.codeArtifactOptions?.authProvider ??\n        CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR;\n      const isAccessSecretKeyPairAuth =\n        authProvider === CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR;\n      codeArtifactOptions = {\n        authProvider,\n        accessKeyIdSecret:\n          options.codeArtifactOptions?.accessKeyIdSecret ??\n          (isAccessSecretKeyPairAuth ? \"AWS_ACCESS_KEY_ID\" : undefined),\n        secretAccessKeySecret:\n          options.codeArtifactOptions?.secretAccessKeySecret ??\n          (isAccessSecretKeyPairAuth ? \"AWS_SECRET_ACCESS_KEY\" : undefined),\n        roleToAssume: options.codeArtifactOptions?.roleToAssume,\n      };\n    }\n\n    return {\n      npmAccess,\n      npmRegistry: npmr.hostname + this.renderNpmRegistryPath(npmr.pathname!),\n      npmRegistryUrl: npmr.href,\n      npmTokenSecret: options.npmTrustedPublishing\n        ? undefined\n        : defaultNpmToken(options.npmTokenSecret, npmr.hostname),\n      codeArtifactOptions,\n      scopedPackagesOptions: this.parseScopedPackagesOptions(\n        options.scopedPackagesOptions,\n      ),\n      npmProvenance,\n    };\n  }\n\n  private parseScopedPackagesOptions(\n    scopedPackagesOptions?: ScopedPackagesOptions[],\n  ): ScopedPackagesOptions[] | undefined {\n    if (!scopedPackagesOptions) {\n      return undefined;\n    }\n\n    return scopedPackagesOptions.map((option): ScopedPackagesOptions => {\n      if (!isScoped(option.scope)) {\n        throw new Error(\n          `Scope must start with \"@\" in options, found ${option.scope}`,\n        );\n      }\n\n      if (!isAwsCodeArtifactRegistry(option.registryUrl)) {\n        throw new Error(\n          `Only AWS Code artifact scoped registry is supported for now, found ${option.registryUrl}`,\n        );\n      }\n\n      const result: ScopedPackagesOptions = {\n        registryUrl: option.registryUrl,\n        scope: option.scope,\n      };\n\n      return result;\n    });\n  }\n\n  private addCodeArtifactLoginScript() {\n    if (\n      !this.scopedPackagesOptions ||\n      this.scopedPackagesOptions.length === 0\n    ) {\n      return;\n    }\n\n    this.project.addTask(\"ca:login\", {\n      steps: [\n        { execArgs: [\"which\", \"aws\"] }, // check that AWS CLI is installed\n        ...this.scopedPackagesOptions.flatMap((scopedPackagesOption) => {\n          const { registryUrl, scope } = scopedPackagesOption;\n          const { domain, region, accountId, registry } =\n            extractCodeArtifactDetails(registryUrl);\n          // reference: https://docs.aws.amazon.com/codeartifact/latest/ug/npm-auth.html\n          const steps: TaskStep[] = [\n            {\n              execArgs: [\n                \"npm\",\n                \"config\",\n                \"set\",\n                `${scope}:registry`,\n                registryUrl,\n              ],\n            },\n            {\n              env: {\n                CODEARTIFACT_AUTH_TOKEN: `$(aws codeartifact get-authorization-token --domain ${domain} --region ${region} --domain-owner ${accountId} --query authorizationToken --output text)`,\n                CODEARTIFACT_AUTH_TOKEN_KEY: `//${registry}:_authToken`,\n              },\n              // needs a shell to expand env vars\n              exec: 'npm config set \"$CODEARTIFACT_AUTH_TOKEN_KEY=$CODEARTIFACT_AUTH_TOKEN\"',\n            },\n          ];\n\n          if (!this.minNodeVersion || semver.major(this.minNodeVersion) <= 16) {\n            steps.push({\n              execArgs: [\n                \"npm\",\n                \"config\",\n                \"set\",\n                `//${registry}:always-auth=true`,\n              ],\n            });\n          }\n\n          return steps;\n        }),\n      ],\n    });\n  }\n\n  private addNodeEngine() {\n    if (!this.minNodeVersion && !this.maxNodeVersion) {\n      return;\n    }\n\n    let nodeVersion = \"\";\n    if (this.minNodeVersion) {\n      nodeVersion += `>= ${this.minNodeVersion}`;\n    }\n    if (this.maxNodeVersion) {\n      nodeVersion += ` <= ${this.maxNodeVersion}`;\n    }\n    this.addEngine(\"node\", nodeVersion);\n  }\n\n  private renderNpmRegistryPath(path: string | undefined): string {\n    if (!path || path == \"/\") {\n      return \"\";\n    } else {\n      return path;\n    }\n  }\n\n  private renderInstallCommand(frozen: boolean) {\n    switch (this.packageManager) {\n      case NodePackageManager.YARN:\n      case NodePackageManager.YARN_CLASSIC:\n        return [\n          \"yarn install\",\n          \"--check-files\", // ensure all modules exist (especially projen which was just removed).\n          ...(frozen ? [\"--frozen-lockfile\"] : []),\n        ].join(\" \");\n      case NodePackageManager.YARN2:\n      case NodePackageManager.YARN_BERRY:\n        return [\n          \"yarn install\",\n          ...(frozen ? [\"--immutable\"] : [\"--no-immutable\"]),\n        ].join(\" \");\n      case NodePackageManager.NPM:\n        return frozen ? \"npm ci\" : \"npm install\";\n      case NodePackageManager.PNPM:\n        return frozen\n          ? \"pnpm i --frozen-lockfile\"\n          : \"pnpm i --no-frozen-lockfile\";\n      case NodePackageManager.BUN:\n        return [\"bun install\", ...(frozen ? [\"--frozen-lockfile\"] : [])].join(\n          \" \",\n        );\n\n      default:\n        throw new Error(`unexpected package manager ${this.packageManager}`);\n    }\n  }\n\n  private processDeps(options: NodePackageOptions) {\n    this.addDeps(...(options.deps ?? []));\n    this.addDevDeps(...(options.devDeps ?? []));\n    this.addPeerDeps(...(options.peerDeps ?? []));\n    this.addBundledDeps(...(options.bundledDeps ?? []));\n  }\n\n  private renderDependencies(): NpmDependencies {\n    const devDependencies: Record<string, string> = {};\n    const peerDependencies: Record<string, string> = {};\n    const dependencies: Record<string, string> = {};\n    const bundledDependencies = new Array<string>();\n\n    // synthetic dependencies: add a pinned build dependency to ensure we are\n    // testing against the minimum requirement of the peer.\n    if (this.peerDependencyOptions.pinnedDevDependency) {\n      for (const dep of this.project.deps.all.filter(\n        (d) => d.type === DependencyType.PEER,\n      )) {\n        let req = dep.name;\n\n        // Skip if we already have a runtime dependency on this peer and no build dependency yet.\n        // If there is a build dep already, we need to override its version.\n        if (\n          this.project.deps.tryGetDependency(\n            dep.name,\n            DependencyType.RUNTIME,\n          ) &&\n          !this.project.deps.tryGetDependency(dep.name, DependencyType.BUILD)\n        ) {\n          continue;\n        }\n\n        if (dep.version) {\n          const ver = minVersion(dep.version);\n          if (!ver) {\n            throw new Error(\n              `unable to determine minimum semver for peer dependency ${dep.name}@${dep.version}`,\n            );\n          }\n\n          req += \"@\" + ver;\n        }\n        this.addDevDeps(req);\n      }\n    }\n\n    for (const dep of this.project.deps.all) {\n      let version = dep.version ?? \"*\";\n      let name = dep.name;\n\n      if (name.startsWith(\"file:\")) {\n        const localDependencyPath = name.substring(5);\n        const depPackageJson = resolve(\n          this.project.outdir,\n          localDependencyPath,\n          \"package.json\",\n        );\n        const pkgFile = readFileSync(depPackageJson, \"utf8\");\n        const pkg = JSON.parse(pkgFile);\n        version = localDependencyPath;\n        name = pkg.name;\n      }\n\n      switch (dep.type) {\n        case DependencyType.BUNDLED:\n          bundledDependencies.push(name);\n\n          const depDecls = this.project.deps.all.filter((d) => d.name === name);\n          if (depDecls.some((d) => d.type === DependencyType.PEER)) {\n            throw new Error(\n              `unable to bundle \"${name}\": it cannot appear as a peer dependency (bundled would always take precedence over peer)`,\n            );\n          }\n\n          // I've observed that at least npm 10.8.2 will silently fail to bundle\n          // a dependency if it is [also] part of `devDependencies`. It must exist in\n          // `dependencies` and `dependencies` only.\n          if (depDecls.some((d) => d.type === DependencyType.BUILD)) {\n            throw new Error(\n              `unable to bundle \"${name}\": it cannot appear as a devDependency (only prod dependencies are bundled, and any dependency appearing as a devDependency is considered to be not a prod dependency)`,\n            );\n          }\n\n          // also add as a runtime dependency\n          dependencies[name] = version;\n          break;\n\n        case DependencyType.PEER:\n          peerDependencies[name] = version;\n          break;\n\n        case DependencyType.RUNTIME:\n          dependencies[name] = version;\n          break;\n\n        case DependencyType.TEST:\n        case DependencyType.DEVENV:\n        case DependencyType.BUILD:\n          devDependencies[name] = version;\n          break;\n      }\n    }\n\n    // returns a lazy value to normalize during synthesis\n    const normalize = (obj: any) => () => sorted(obj);\n\n    // update the manifest we are about to save into `package.json`\n    this.manifest.devDependencies = normalize(devDependencies);\n    this.manifest.peerDependencies = normalize(peerDependencies);\n    this.manifest.dependencies = normalize(dependencies);\n    this.manifest.bundledDependencies = sorted(bundledDependencies);\n\n    // nothing further to do if package.json file does not exist\n    if (!this._prev) {\n      return { devDependencies, peerDependencies, dependencies };\n    }\n\n    const unmanagedRemoved: string[] = [];\n\n    const readDeps = (\n      user: Record<string, string>,\n      current: Record<string, string> = {},\n    ) => {\n      for (const [name, userVersion] of Object.entries(user)) {\n        const currentVersion = current[name];\n\n        // respect user version if it's not '*' or if current version is undefined\n        if (userVersion !== \"*\" || !currentVersion || currentVersion === \"*\") {\n          continue;\n        }\n\n        // memoize current version in memory so it is preserved when saving\n        user[name] = currentVersion;\n      }\n\n      // report removals\n      for (const name of Object.keys(current ?? {})) {\n        if (!user[name]) {\n          this.project.logger.verbose(`${name}: removed`);\n          unmanagedRemoved.push(name);\n        }\n      }\n    };\n\n    readDeps(devDependencies, this._prev.devDependencies);\n    readDeps(dependencies, this._prev.dependencies);\n    readDeps(peerDependencies, this._prev.peerDependencies);\n\n    if (unmanagedRemoved.length > 0) {\n      this.project.logger.warn(\n        `Removing unmanaged dependencies not declared in .projenrc: ${unmanagedRemoved.join(\", \")}. ` +\n          \"These were likely installed via a package manager (e.g. npm install). \" +\n          \"To keep them, add them to your .projenrc and run projen again.\",\n      );\n    }\n\n    return { devDependencies, dependencies, peerDependencies };\n  }\n\n  /**\n   * Resolves any deps that do not have a specified version (e.g. `*`) and\n   * updates `package.json` if needed. Does not log or install — the caller\n   * is responsible for acting on the returned changes.\n   *\n   * @returns list of human-readable resolution changes, or `undefined` if\n   * `package.json` does not exist. An empty array means no changes were made.\n   */\n  private resolveDepsAndWritePackageJson(): string[] | undefined {\n    const outdir = this.project.outdir;\n    const rootPackageJson = join(outdir, \"package.json\");\n\n    const original = readFileSync(rootPackageJson, \"utf8\");\n    const pkg = JSON.parse(original);\n    const changes: string[] = [];\n\n    const resolveDeps = (\n      current: { [name: string]: string },\n      user: Record<string, string>,\n    ) => {\n      const result: Record<string, string> = {};\n      current = current ?? {};\n      user = user ?? {};\n\n      for (const [name, currentDefinition] of Object.entries(user)) {\n        // find actual version from node_modules\n        let desiredVersion = currentDefinition;\n\n        if (currentDefinition === \"*\") {\n          // we already know we don't have the version in project `deps`,\n          // so skip straight to checking manifest.\n          const resolvedVersion = tryResolveDependencyVersion(name, {\n            paths: [this.project.outdir],\n          });\n          if (!resolvedVersion) {\n            this.project.logger.warn(\n              `unable to resolve version for ${name} from installed modules`,\n            );\n            continue;\n          }\n          desiredVersion = `^${resolvedVersion}`;\n        }\n\n        if (currentDefinition !== desiredVersion) {\n          changes.push(`${name}: ${currentDefinition} => ${desiredVersion}`);\n        }\n\n        result[name] = desiredVersion;\n      }\n\n      // collect removed packages\n      for (const name of Object.keys(current)) {\n        if (!result[name]) {\n          changes.push(`${name}: removed`);\n        }\n      }\n\n      return result;\n    };\n\n    const rendered = this._renderedDeps;\n    if (!rendered) {\n      throw new Error(\"assertion failed\");\n    }\n\n    const deps = resolveDeps(pkg.dependencies, rendered.dependencies);\n    const devDeps = resolveDeps(pkg.devDependencies, rendered.devDependencies);\n    const peerDeps = resolveDeps(\n      pkg.peerDependencies,\n      rendered.peerDependencies,\n    );\n\n    if (this.peerDependencyOptions.pinnedDevDependency) {\n      for (const [name, version] of Object.entries(peerDeps)) {\n        // Skip if we already have a runtime dependency on this peer\n        // or if devDependency version is already set.\n        // Relies on the \"*\" devDependency added in the presynth step\n        if (deps[name] || rendered.devDependencies[name] !== \"*\") {\n          continue;\n        }\n\n        // Take version and pin as dev dependency\n        const ver = minVersion(version);\n        if (!ver) {\n          throw new Error(\n            `unable to determine minimum semver for peer dependency ${name}@${version}`,\n          );\n        }\n\n        devDeps[name] = ver;\n      }\n    }\n\n    pkg.dependencies = sorted(deps);\n    pkg.devDependencies = sorted(devDeps);\n    pkg.peerDependencies = sorted(peerDeps);\n\n    const updated = JSON.stringify(pkg, undefined, 2) + \"\\n\";\n\n    if (original === updated) {\n      return [];\n    }\n\n    writeFile(rootPackageJson, updated);\n    return changes;\n  }\n\n  private renderPackageResolutions() {\n    const render = () => {\n      const overridingDependencies = this.project.deps.all.filter(\n        (dep) => dep.type === DependencyType.OVERRIDE,\n      );\n      if (!overridingDependencies.length) {\n        return undefined;\n      }\n\n      return Object.fromEntries(\n        overridingDependencies.map(({ name, version = \"*\" }) => [\n          name,\n          version,\n        ]),\n      );\n    };\n\n    switch (this.packageManager) {\n      case NodePackageManager.NPM:\n      case NodePackageManager.BUN:\n        return { overrides: render };\n      case NodePackageManager.PNPM:\n        return this.project.parent\n          ? undefined\n          : { pnpm: { overrides: render } };\n      case NodePackageManager.YARN:\n      case NodePackageManager.YARN2:\n      case NodePackageManager.YARN_CLASSIC:\n      case NodePackageManager.YARN_BERRY:\n      default:\n        return { resolutions: render };\n    }\n  }\n\n  /**\n   * Renders the native npm `allowScripts` field (`{ \"pkg\": true }`) from the\n   * `allowScripts` allowlist.\n   *\n   * @see https://docs.npmjs.com/cli/v11/commands/npm-approve-scripts\n   */\n  private renderNpmAllowScripts() {\n    if (this.allowedScripts.size === 0) {\n      return undefined;\n    }\n\n    return Object.fromEntries(\n      [...this.allowedScripts].sort().map((pkg) => [pkg, true]),\n    );\n  }\n\n  /**\n   * Renders the native bun `trustedDependencies` field from the\n   * `allowScripts` allowlist.\n   *\n   * @see https://bun.com/docs/pm/lifecycle\n   */\n  private renderBunTrustedDependencies() {\n    if (this.allowedScripts.size === 0) {\n      return undefined;\n    }\n\n    return [...this.allowedScripts].sort();\n  }\n\n  /**\n   * Renders the native yarn berry per-package script allowlist via\n   * `dependenciesMeta.<pkg>.built = true`. Combined with the global\n   * `enableScripts: false` yarnrc setting (set in `configureYarnBerry`),\n   * this allows install scripts to run only for the listed packages.\n   *\n   * @see https://yarnpkg.com/configuration/manifest#dependenciesMeta.built\n   * @see https://yarnpkg.com/features/security#postinstalls\n   */\n  private renderYarnBerryDependenciesMeta() {\n    if (this.allowedScripts.size === 0) {\n      return undefined;\n    }\n\n    return Object.fromEntries(\n      [...this.allowedScripts].sort().map((pkg) => [pkg, { built: true }]),\n    );\n  }\n\n  /**\n   * Validates and configures the `allowScripts` allowlist for the resolved\n   * package manager, throwing a descriptive error for package managers that\n   * have no native way to allowlist install scripts per-dependency.\n   */\n  private configureAllowScripts() {\n    if (this.allowedScripts.size === 0) {\n      return;\n    }\n\n    switch (this.packageManager) {\n      case NodePackageManager.NPM:\n      case NodePackageManager.BUN:\n        // handled via the `allowScripts` / `trustedDependencies` manifest fields\n        return;\n\n      case NodePackageManager.YARN2:\n      case NodePackageManager.YARN_BERRY:\n        // handled via `dependenciesMeta.<pkg>.built` + `enableScripts: false`\n        // in `renderYarnBerryDependenciesMeta` and `configureYarnBerry`\n        return;\n\n      case NodePackageManager.PNPM:\n        // handled via `configurePnpm`\n        return;\n\n      default:\n        throw new Error(\n          `\"allowScripts\" is not supported for packageManager \"${this.packageManager}\". ` +\n            \"Switch to a modern package manager that supports this option.\",\n        );\n    }\n  }\n\n  /**\n   * Configures the `PnpmWorkspaceYaml` component, merging `onlyBuiltDependencies`\n   * from `allowScripts` and any explicit `pnpmOptions.workspaceYamlOptions`.\n   * The merge is resolved lazily (at synthesis time), so calls to\n   * `addAllowedScripts`/`removeAllowedScripts` made after this runs are\n   * still reflected. The file is only written if it ends up with actual\n   * content (see `omitEmpty`), so this is safe to call unconditionally for\n   * every pnpm project.\n   */\n  private configurePnpm(project: Project, options: NodePackageOptions) {\n    const { workspaceYamlOptions = {} } = options.pnpmOptions ?? {};\n\n    const renderOnlyBuiltDependencies = () => {\n      const merged = new Set([\n        ...this.allowedScripts,\n        ...(workspaceYamlOptions.onlyBuiltDependencies ?? []),\n      ]);\n      return merged.size > 0 ? [...merged].sort() : undefined;\n    };\n\n    new PnpmWorkspaceYaml(project, {\n      ...workspaceYamlOptions,\n      // `onlyBuiltDependencies` is typed as `string[]`, but defining it as a\n      // getter lets us resolve the merged allowlist lazily (at synthesis\n      // time), so `addAllowedScripts`/`removeAllowedScripts` calls made\n      // after this runs are still reflected.\n      get onlyBuiltDependencies(): string[] | undefined {\n        return renderOnlyBuiltDependencies();\n      },\n    });\n  }\n\n  private renderPublishConfig() {\n    // When npm provenance is enabled, we need to always render the public access\n    // But when npmAccess is the set to the default, we prefer to omit it\n    const shouldOmitAccess =\n      !this.npmProvenance &&\n      this.npmAccess === defaultNpmAccess(this.packageName);\n\n    // omit values if they are the same as the npm defaults\n    return resolveJson(\n      {\n        registry:\n          this.npmRegistryUrl !== DEFAULT_NPM_REGISTRY_URL\n            ? this.npmRegistryUrl\n            : undefined,\n        access: shouldOmitAccess ? undefined : this.npmAccess,\n      },\n      { omitEmpty: true },\n    );\n  }\n\n  private renderKeywords() {\n    const kwds = Array.from(this.keywords);\n    return sorted(kwds.sort());\n  }\n\n  private renderEngines() {\n    return sorted(this.engines);\n  }\n\n  private renderDevEngines(): DevEngines | undefined {\n    const autoAdd =\n      this._options.addPackageManagerToDevEngines !== false &&\n      this._packageManagerExplicit;\n\n    const base: DevEngines = autoAdd\n      ? { packageManager: this.packageManagerToDevEngine() }\n      : {};\n\n    const merged = { ...base, ...this._options.devEngines };\n    return Object.keys(merged).length > 0 ? merged : undefined;\n  }\n\n  private deleteOrphanedLockFiles() {\n    const ownLockFile = join(this.project.outdir, this.lockFile);\n    if (!existsSync(ownLockFile)) {\n      return;\n    }\n\n    const allLockFiles = [\n      \"yarn.lock\",\n      \"package-lock.json\",\n      \"pnpm-lock.yaml\",\n      \"bun.lockb\",\n    ];\n    for (const lf of allLockFiles) {\n      if (lf === this.lockFile) {\n        continue;\n      }\n      const path = join(this.project.outdir, lf);\n      if (existsSync(path)) {\n        this.project.logger.info(`Deleting orphaned lockfile: ${lf}`);\n        unlinkSync(path);\n      }\n    }\n  }\n\n  private autoDiscoverBinaries() {\n    const binrel = \"bin\";\n    const bindir = join(this.project.outdir, binrel);\n    if (existsSync(bindir)) {\n      for (const file of readdirSync(bindir)) {\n        try {\n          accessSync(join(bindir, file), constants.X_OK);\n\n          const binPath = join(binrel, file);\n          const normalizedPath = normalizePersistedPath(binPath);\n\n          this.bin[file] = normalizedPath;\n        } catch (e) {\n          // not executable, skip\n        }\n      }\n    }\n  }\n\n  private renderAuthor(options: NodePackageOptions) {\n    let author;\n    if (options.authorName) {\n      author = {\n        name: options.authorName,\n        email: options.authorEmail,\n        url: options.authorUrl,\n        organization: options.authorOrganization ?? false,\n      };\n    } else {\n      if (\n        options.authorEmail ||\n        options.authorUrl ||\n        options.authorOrganization !== undefined\n      ) {\n        throw new Error(\n          '\"authorName\" is required if specifying \"authorEmail\" or \"authorUrl\"',\n        );\n      }\n    }\n    return author;\n  }\n\n  private renderBin() {\n    const entries = Object.entries(this.bin);\n\n    // Yarn Berry rewrites `\"bin\": {\"name\": \"./path\"}` to `\"bin\": \"./path\"`\n    // when the key matches the package name, causing anti-tamper failures.\n    // Render the string form directly to avoid this.\n    // See: https://github.com/yarnpkg/berry/issues/6184\n    const { name: binName } = parsePackageName(this.packageName);\n    if (isYarnBerry(this.packageManager) && entries.length === 1) {\n      const [key, value] = entries[0];\n      if (key === binName) {\n        return value;\n      }\n    }\n\n    return sorted(this.bin);\n  }\n\n  private renderScripts() {\n    // Validate the `allowScripts` allowlist lazily (at synthesis time, since\n    // `scripts` is always resolved regardless of package manager), so\n    // `addAllowedScripts` calls made after construction are also checked.\n    this.configureAllowScripts();\n\n    const result: any = {};\n    const tasks = this.project.tasks.all\n      .filter(\n        (t) =>\n          // Must remove to prevent overriding built-in npm command (which would loop)\n          t.name !== this.installTask.name &&\n          t.name !== this.installCiTask.name,\n      )\n      .sort((x, y) => x.name.localeCompare(y.name));\n\n    const scriptCommand = this.resolveScriptCommand();\n    for (const task of tasks) {\n      if (this.scriptsToBeRemoved.has(task.name)) {\n        continue;\n      }\n      result[task.name] = `${scriptCommand} ${task.name}`;\n    }\n\n    return {\n      ...result,\n      ...this.scripts,\n    };\n  }\n\n  /**\n   * Determines the command to use for projen in package.json scripts.\n   *\n   * Since `node_modules/.bin` is always on PATH in npm scripts, we can use\n   * bare `projen` unless the user has set a custom `projenCommand`.\n   */\n  private resolveScriptCommand(): string {\n    const cmd = this.project.projenCommand;\n    const isDefault = [\n      // NodeProject sets projenCommand based on the package manager\n      execCommand(this.packageManager, \"projen\"),\n      // Plain Project always defaults to \"npx projen\" regardless of package manager\n      \"npx projen\",\n    ].includes(cmd);\n    return isDefault ? \"projen\" : cmd;\n  }\n\n  private readPackageJson() {\n    const file = join(this.project.outdir, \"package.json\");\n    if (!existsSync(file)) {\n      return undefined;\n    }\n\n    return JSON.parse(readFileSync(file, \"utf-8\"));\n  }\n\n  /**\n   * Runs the install or install:ci task. Does not log — the caller is\n   * responsible for informing the user before calling this method.\n   *\n   * @param _trigger the reason for the install, available for subclasses to act on.\n   */\n  protected installDependencies(_trigger: InstallTrigger) {\n    const taskToRun = this.isAutomatedBuild\n      ? this.installCiTask\n      : this.installTask;\n    this.project.tasks.runTask(taskToRun.name);\n  }\n\n  /**\n   * Sets the `packageManager` field in `package.json` for corepack-managed\n   * package managers (yarn berry and pnpm).\n   */\n  private configureCorepack() {\n    if (isYarnBerry(this.packageManager)) {\n      this.addField(\"packageManager\", `yarn@${this._yarnBerryVersion}`);\n    } else if (this.packageManager === NodePackageManager.PNPM) {\n      this.addField(\"packageManager\", `pnpm@${this._pnpmVersion}`);\n    }\n  }\n\n  /**\n   * Maps the current package manager to a `DevEngineDependency`.\n   */\n  private packageManagerToDevEngine(): DevEngineDependency {\n    const onFail = \"ignore\";\n    switch (this.packageManager) {\n      case NodePackageManager.YARN:\n      case NodePackageManager.YARN_CLASSIC:\n        return {\n          name: \"yarn\",\n          version: DEFAULT_YARN_CLASSIC_VERSION,\n          onFail,\n        };\n      case NodePackageManager.YARN2:\n      case NodePackageManager.YARN_BERRY:\n        return {\n          name: \"yarn\",\n          version:\n            this._options.yarnBerryOptions?.version ??\n            `>=${semver.major(this._yarnBerryVersion)}`,\n          onFail,\n        };\n      case NodePackageManager.NPM:\n        return { name: \"npm\", onFail };\n      case NodePackageManager.PNPM:\n        return {\n          name: \"pnpm\",\n          version:\n            this._options.pnpmVersion ?? `>=${semver.major(this._pnpmVersion)}`,\n          onFail,\n        };\n      case NodePackageManager.BUN:\n        return { name: \"bun\", onFail };\n    }\n  }\n\n  private configureYarnBerry(project: Project, options: NodePackageOptions) {\n    const { yarnRcOptions = {}, zeroInstalls = false } =\n      options.yarnBerryOptions || {};\n    this.checkForConflictingYarnOptions(yarnRcOptions);\n\n    this.configureYarnBerryGitignore(zeroInstalls);\n\n    // When an allowlist is provided, disable scripts globally so that only\n    // the packages explicitly marked via `dependenciesMeta.<pkg>.built` are\n    // allowed to run their install scripts. Resolved lazily (at synthesis\n    // time, via a getter) so that later calls to\n    // `addAllowedScripts`/`removeAllowedScripts` are reflected. Has no\n    // effect if the user set `enableScripts` explicitly.\n    const nodePackage = this;\n    new Yarnrc(project, {\n      get enableScripts(): boolean | undefined {\n        return nodePackage.allowedScripts.size > 0 ? false : undefined;\n      },\n      ...yarnRcOptions,\n    });\n  }\n\n  private checkForConflictingYarnOptions(yarnRcOptions: YarnrcOptions) {\n    if (\n      this.npmAccess &&\n      yarnRcOptions.npmPublishAccess &&\n      this.npmAccess.toString() !== yarnRcOptions.npmPublishAccess.toString()\n    ) {\n      throw new Error(\n        `Cannot set npmAccess (${this.npmAccess}) and yarnRcOptions.npmPublishAccess (${yarnRcOptions.npmPublishAccess}) to different values.`,\n      );\n    }\n\n    if (\n      this.npmRegistryUrl &&\n      yarnRcOptions.npmRegistryServer &&\n      this.npmRegistryUrl !== yarnRcOptions.npmRegistryServer\n    ) {\n      throw new Error(\n        `Cannot set npmRegistryUrl (${this.npmRegistryUrl}) and yarnRcOptions.npmRegistryServer (${yarnRcOptions.npmRegistryServer}) to different values.`,\n      );\n    }\n  }\n\n  /** See https://yarnpkg.com/getting-started/qa#which-files-should-be-gitignored */\n  private configureYarnBerryGitignore(zeroInstalls: boolean) {\n    const { gitignore } = this.project;\n\n    // These patterns are the same whether or not you're using zero-installs\n    gitignore.exclude(\".yarn/*\");\n    gitignore.include(\n      \".yarn/patches\",\n      \".yarn/plugins\",\n      \".yarn/releases\",\n      \".yarn/sdks\",\n      \".yarn/versions\",\n    );\n\n    if (zeroInstalls) {\n      gitignore.include(\"!.yarn/cache\");\n    } else {\n      gitignore.exclude(\".pnp.*\");\n    }\n  }\n}\n\nexport interface PeerDependencyOptions {\n  /**\n   * Automatically add a pinned dev dependency.\n   * @default true\n   */\n  readonly pinnedDevDependency?: boolean;\n}\n\n/**\n * The node package manager to use.\n */\nexport enum NodePackageManager {\n  /**\n   * Use `yarn` as the package manager.\n   *\n   * @deprecated For `yarn` 1.x use `YARN_CLASSIC` for `yarn` >= 2 use `YARN_BERRY`. Currently, `NodePackageManager.YARN` means `YARN_CLASSIC`. In the future, we might repurpose it to mean `YARN_BERRY`.\n   */\n  YARN = \"yarn\",\n\n  /**\n   * Use `yarn` versions >= 2 as the package manager.\n   *\n   * @deprecated use YARN_BERRY instead\n   */\n  YARN2 = \"yarn2\",\n\n  /**\n   * Use `yarn` 1.x as the package manager.\n   */\n  YARN_CLASSIC = \"yarn_classic\",\n\n  /**\n   * Use `yarn` versions >= 2 as the package manager.\n   */\n  YARN_BERRY = \"yarn_berry\",\n\n  /**\n   * Use `npm` as the package manager.\n   */\n  NPM = \"npm\",\n\n  /**\n   * Use `pnpm` as the package manager.\n   */\n  PNPM = \"pnpm\",\n\n  /**\n   * Use `bun` as the package manager\n   */\n  BUN = \"bun\",\n}\n\n/**\n * Npm package access level\n */\nexport enum NpmAccess {\n  /**\n   * Package is public.\n   */\n  PUBLIC = \"public\",\n\n  /**\n   * Package can only be accessed with credentials.\n   */\n  RESTRICTED = \"restricted\",\n}\n\n/**\n * Configure Yarn Berry\n */\nexport interface YarnBerryOptions {\n  /**\n   * A fully specified version to use for yarn (e.g., x.x.x)\n   *\n   * @default - 4.13.0\n   */\n  readonly version?: string;\n\n  /**\n   * The yarnrc configuration.\n   *\n   * @default - a blank Yarn RC file\n   */\n  readonly yarnRcOptions?: YarnrcOptions;\n\n  /**\n   * Should zero-installs be enabled?\n   * Learn more at: https://yarnpkg.com/features/caching#zero-installs\n   *\n   * @default false\n   */\n  readonly zeroInstalls?: boolean;\n\n  /**\n   * Packages to deduplicate when the `dedupe` task runs.\n   *\n   * This will prevent multiple versions of the same package from being\n   * installed in the lock file, if a single version could satisfy all requested\n   * version ranges. This will prevent version proliferation and reduce the size\n   * of the dependency tree.\n   *\n   * Setting this implies `dedupeDeps: true` on the project, which will run\n   * `yarn dedupe` after every mutating install. Set `dedupeDeps: false`\n   * explicitly to disable the task.\n   *\n   * Supports glob patterns, e.g. `@aws-sdk/*`.\n   *\n   * @default - all packages are deduplicated\n   */\n  readonly dedupePackages?: string[];\n}\n\n/**\n * Configure pnpm\n */\nexport interface PnpmOptions {\n  /**\n   * The `pnpm-workspace.yaml` configuration.\n   *\n   * @default - a blank pnpm-workspace.yaml file\n   */\n  readonly workspaceYamlOptions?: PnpmWorkspaceYamlOptions;\n}\n\ninterface NpmDependencies {\n  readonly dependencies: Record<string, string>;\n  readonly devDependencies: Record<string, string>;\n  readonly peerDependencies: Record<string, string>;\n}\n\n/**\n * Why a dependency install was triggered during synthesis.\n */\nexport enum InstallReason {\n  /** The node_modules directory does not exist. */\n  NO_NODE_MODULES = \"node_modules is missing\",\n  /** The package.json file was modified during synthesis. */\n  PACKAGE_JSON_CHANGED = \"package.json has changed\",\n  /** Wildcard dependency versions were resolved to concrete ranges. */\n  DEPS_RESOLVED = \"resolved dependency versions changed\",\n}\n\n/**\n * Describes why dependencies need to be installed.\n */\nexport interface InstallTrigger {\n  /** The reason for the install. */\n  readonly reason: InstallReason;\n\n  /**\n   * A unified diff of the package.json changes.\n   * Only present when reason is `PACKAGE_JSON_CHANGED`.\n   */\n  readonly diff?: string[];\n\n  /**\n   * Human-readable descriptions of resolved dependency version changes.\n   * Only present when reason is `DEPS_RESOLVED`.\n   */\n  readonly resolutions?: string[];\n}\n\n/**\n * Determines if an npm package is \"scoped\" (i.e. it starts with \"xxx@\").\n */\nfunction isScoped(packageName: string) {\n  return packageName.startsWith(\"@\");\n}\n\nfunction parsePackageName(packageName: string): {\n  scope?: string;\n  name: string;\n} {\n  if (isScoped(packageName)) {\n    const [scope, name] = packageName.split(\"/\");\n    return { scope, name };\n  }\n  return { name: packageName };\n}\n\nfunction defaultNpmAccess(packageName: string) {\n  return isScoped(packageName) ? NpmAccess.RESTRICTED : NpmAccess.PUBLIC;\n}\n\nexport function defaultNpmToken(\n  npmToken: string | undefined,\n  registry: string | undefined,\n) {\n  // if we are publishing to AWS CodeArtifact, no NPM_TOKEN used (will be requested using AWS CLI later).\n  if (isAwsCodeArtifactRegistry(registry)) {\n    return undefined;\n  }\n\n  // if we are publishing to GitHub Packages, default to GITHUB_TOKEN.\n  const isGitHubPackages = registry === GITHUB_PACKAGES_REGISTRY;\n  return (\n    npmToken ??\n    (isGitHubPackages ? DEFAULT_GITHUB_TOKEN_SECRET : DEFAULT_NPM_TOKEN_SECRET)\n  );\n}\n\nfunction determineLockfile(packageManager: NodePackageManager) {\n  switch (packageManager) {\n    case NodePackageManager.YARN:\n    case NodePackageManager.YARN_CLASSIC:\n    case NodePackageManager.YARN2:\n    case NodePackageManager.YARN_BERRY:\n      return \"yarn.lock\";\n    case NodePackageManager.NPM:\n      return \"package-lock.json\";\n    case NodePackageManager.PNPM:\n      return \"pnpm-lock.yaml\";\n    case NodePackageManager.BUN:\n      return \"bun.lockb\";\n    default:\n      throw new Error(`unsupported package manager ${packageManager}`);\n  }\n}\n\n/**\n * Maps a package manager name (as used in package.json `packageManager` and\n * `devEngines.packageManager` fields) to a `NodePackageManager` enum value.\n */\nfunction packageManagerNameToEnum(\n  name: string,\n  majorVersion?: number,\n): NodePackageManager | undefined {\n  switch (name) {\n    case \"npm\":\n      return NodePackageManager.NPM;\n    case \"pnpm\":\n      return NodePackageManager.PNPM;\n    case \"bun\":\n      return NodePackageManager.BUN;\n    case \"yarn\":\n      if (majorVersion !== undefined && majorVersion >= 2) {\n        return NodePackageManager.YARN_BERRY;\n      }\n      return NodePackageManager.YARN_CLASSIC;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Infers the `NodePackageManager` from an existing `package.json`.\n *\n * Checks in order:\n * 1. `packageManager` field (corepack, e.g. `\"yarn@4.1.0\"`)\n * 2. `devEngines.packageManager` field (single entry only; arrays are\n *    ambiguous and skipped unless a lockfile disambiguates)\n *\n * @returns the inferred package manager, or `undefined`\n */\nfunction inferPackageManagerFromPkgJson(\n  prev: Record<string, any> | undefined,\n  outdir: string,\n): NodePackageManager | undefined {\n  if (!prev) {\n    return undefined;\n  }\n\n  // 1. Corepack packageManager field: \"yarn@4.1.0\"\n  const corepack: string | undefined = prev.packageManager;\n  if (corepack) {\n    const match = corepack.match(/^(\\w+)@(\\d+)/);\n    if (match) {\n      const result = packageManagerNameToEnum(match[1], Number(match[2]));\n      if (result) {\n        return result;\n      }\n    }\n  }\n\n  // 2. devEngines.packageManager\n  const devEnginesPm = prev.devEngines?.packageManager;\n  if (devEnginesPm) {\n    if (!Array.isArray(devEnginesPm)) {\n      // Single entry\n      return packageManagerNameToEnum(devEnginesPm.name);\n    }\n    if (devEnginesPm.length === 1) {\n      return packageManagerNameToEnum(devEnginesPm[0].name);\n    }\n    // Multiple entries — try to disambiguate with lockfile\n    if (devEnginesPm.length > 1) {\n      const fromLockfile = inferPackageManagerFromLockfile(outdir);\n      if (fromLockfile) {\n        return fromLockfile;\n      }\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Infers the `NodePackageManager` from the presence of a lockfile.\n */\nfunction inferPackageManagerFromLockfile(\n  outdir: string,\n): NodePackageManager | undefined {\n  if (existsSync(join(outdir, \"pnpm-lock.yaml\"))) {\n    return NodePackageManager.PNPM;\n  }\n  if (existsSync(join(outdir, \"bun.lockb\"))) {\n    return NodePackageManager.BUN;\n  }\n  if (existsSync(join(outdir, \"yarn.lock\"))) {\n    return NodePackageManager.YARN_CLASSIC;\n  }\n  if (existsSync(join(outdir, \"package-lock.json\"))) {\n    return NodePackageManager.NPM;\n  }\n  return undefined;\n}\n"]}