@williamthorsen/release-kit 15.0.3 → 16.1.0

package/dist/esm/packFromCleanCheckout.js

@@ -0,0 +1,81 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { resolveExecutable } from "./detectPackageManager.js";
+import { isRecord } from "./typeGuards.js";
+export function packFromCleanCheckout(workspacePaths, packageManager) {
+    const repoRoot = runStep('find the repository root', 'git', ['rev-parse', '--show-toplevel'], process.cwd()).trim();
+    const headSha = runStep('resolve HEAD', 'git', ['rev-parse', 'HEAD'], repoRoot).trim();
+    const scratchDir = mkdtempSync(join(tmpdir(), 'release-kit-pack-'));
+    try {
+        const cloneDir = join(scratchDir, 'checkout');
+        runStep('clone HEAD', 'git', ['clone', '--quiet', '--shared', '--no-checkout', repoRoot, cloneDir], scratchDir);
+        runStep('check out HEAD', 'git', ['checkout', '--quiet', '--detach', headSha], cloneDir);
+        const executable = resolveExecutable(packageManager);
+        const commands = PACKAGE_MANAGER_COMMANDS[packageManager];
+        runStep('install dependencies', executable, commands.installArgs, cloneDir);
+        const filesByWorkspace = new Map();
+        for (const [index, workspacePath] of workspacePaths.entries()) {
+            const packageDir = join(cloneDir, workspacePath);
+            if (declaresPrepublishOnly(packageDir)) {
+                runStep(`run prepublishOnly in ${workspacePath}`, executable, ['run', 'prepublishOnly'], packageDir);
+            }
+            const packDir = join(scratchDir, 'packs', String(index));
+            mkdirSync(packDir, { recursive: true });
+            runStep(`pack ${workspacePath}`, executable, commands.buildPackArgs(packDir), packageDir);
+            filesByWorkspace.set(workspacePath, listTarballEntries(findTarball(packDir, workspacePath)));
+        }
+        return filesByWorkspace;
+    }
+    finally {
+        rmSync(scratchDir, { force: true, recursive: true });
+    }
+}
+const PACKAGE_MANAGER_COMMANDS = {
+    npm: {
+        installArgs: ['ci', '--prefer-offline'],
+        buildPackArgs: (packDir) => ['pack', '--pack-destination', packDir],
+    },
+    pnpm: {
+        installArgs: ['install', '--frozen-lockfile', '--prefer-offline'],
+        buildPackArgs: (packDir) => ['pack', '--pack-destination', packDir],
+    },
+    yarn: {
+        installArgs: ['install', '--frozen-lockfile'],
+        buildPackArgs: (packDir) => ['pack', '--filename', join(packDir, 'package.tgz')],
+    },
+    'yarn-berry': {
+        installArgs: ['install', '--immutable'],
+        buildPackArgs: (packDir) => ['pack', '--out', join(packDir, 'package.tgz')],
+    },
+};
+function declaresPrepublishOnly(packageDir) {
+    const manifest = JSON.parse(readFileSync(join(packageDir, 'package.json'), 'utf8'));
+    const scripts = isRecord(manifest) ? manifest['scripts'] : undefined;
+    return isRecord(scripts) && typeof scripts['prepublishOnly'] === 'string';
+}
+function findTarball(packDir, workspacePath) {
+    const tarballs = readdirSync(packDir).filter((name) => name.endsWith('.tgz'));
+    const [tarball] = tarballs;
+    if (tarballs.length !== 1 || tarball === undefined) {
+        throw new Error(`Could not pack ${workspacePath}: expected one tarball, found ${tarballs.length}.`);
+    }
+    return join(packDir, tarball);
+}
+function listTarballEntries(tarballPath) {
+    const listing = runStep('list the tarball', 'tar', ['--list', '--gzip', '--file', tarballPath], process.cwd());
+    return listing
+        .split('\n')
+        .filter((entry) => entry !== '' && !entry.endsWith('/'))
+        .map((entry) => entry.replace(/^package\//, ''));
+}
+function runStep(step, command, args, cwd) {
+    const result = spawnSync(command, args, { cwd, encoding: 'utf8', maxBuffer: 2 ** 26 });
+    if (result.error === undefined && result.status === 0) {
+        return result.stdout;
+    }
+    const outcome = result.error === undefined ? `exited with status ${result.status}` : result.error.message;
+    const output = [result.stdout, result.stderr].filter((text) => text !== '').join('\n');
+    throw new Error(`Could not ${step}: \`${[command, ...args].join(' ')}\` ${outcome}.${output === '' ? '' : `\n${output}`}`);
+}

package/dist/esm/packsPath.js

@@ -11,10 +11,10 @@ const GLOB_TOKEN_PATTERN = /\*\*\/|\*\*|\*|\?|[^*?]+/g;
 function compileEntry(entry) {
     if (entry.startsWith('!'))
         return undefined;
-    const normalized = entry.replace(/^\.?\//, '').replace(/\/+$/, '');
-    if (normalized === '')
+    const normalizedEntry = entry.replace(/^\.?\//, '').replace(/\/+$/, '');
+    if (normalizedEntry === '')
         return undefined;
-    return new RegExp(`^${translateGlob(normalized)}$`);
+    return new RegExp(`^${translateGlob(normalizedEntry)}$`);
 }
 function isStringArray(value) {
     return Array.isArray(value) && value.every((entry) => typeof entry === 'string');

package/dist/esm/parseChangeRecordBlock.js

@@ -6,10 +6,10 @@ export function parseChangeRecordBlock(message) {
     if (fence === undefined) {
         return { kind: 'absent' };
     }
-    if (fence.close === undefined) {
+    if (fence.closeIndex === undefined) {
         return { kind: 'malformed', reason: 'the block opens but never closes' };
     }
-    const document = parseDocument(lines.slice(fence.open + 1, fence.close).join('\n'));
+    const document = parseDocument(lines.slice(fence.openIndex + 1, fence.closeIndex).join('\n'));
     const [error] = document.errors;
     if (error !== undefined) {
         const detail = (error.message.split('\n', 1)[0] ?? '').replace(/:$/, '');
@@ -21,60 +21,60 @@ export function stripChangeRecordBlocks(message) {
     const lines = message.split(/\r?\n/);
     const fences = findFences(lines);
     return lines
-        .filter((_line, index) => fences.every((fence) => index < fence.open || index > (fence.close ?? lines.length)))
+        .filter((_line, index) => fences.every((fence) => index < fence.openIndex || index > (fence.closeIndex ?? lines.length)))
         .join('\n');
 }
 const FENCE = '```';
 function findFences(lines) {
     const fences = [];
-    let open;
+    let openIndex;
     for (const [index, line] of lines.entries()) {
-        if (open === undefined) {
+        if (openIndex === undefined) {
             if (line.trim() === `${FENCE}${INFO_STRING}`) {
-                open = index;
+                openIndex = index;
             }
         }
         else if (line.trim() === FENCE) {
-            fences.push({ close: index, open });
-            open = undefined;
+            fences.push({ closeIndex: index, openIndex });
+            openIndex = undefined;
         }
     }
-    if (open !== undefined) {
-        fences.push({ open });
+    if (openIndex !== undefined) {
+        fences.push({ openIndex });
     }
     return fences;
 }
 const INFO_STRING = 'change-record';
 function readEntry(item, index) {
-    const at = `entries[${index}]`;
+    const entryPath = `entries[${index}]`;
     if (!isRecord(item)) {
-        return { reason: `\`${at}\` is not a mapping` };
+        return { reason: `\`${entryPath}\` is not a mapping` };
     }
     const { breaking, migration, scopes } = item;
     if (breaking !== undefined && breaking !== null && typeof breaking !== 'boolean') {
-        return { reason: `\`${at}.breaking\` is not a boolean` };
+        return { reason: `\`${entryPath}.breaking\` is not a boolean` };
     }
     if (migration !== undefined && migration !== null && typeof migration !== 'string') {
-        return { reason: `\`${at}.migration\` is not a string` };
+        return { reason: `\`${entryPath}.migration\` is not a string` };
     }
     if (scopes !== undefined && scopes !== null && !Array.isArray(scopes)) {
-        return { reason: `\`${at}.scopes\` is not a list` };
+        return { reason: `\`${entryPath}.scopes\` is not a list` };
     }
     const declaredScopes = scopes ?? [];
     const readScopes = [];
     for (const [position, scope] of declaredScopes.entries()) {
         if (typeof scope !== 'string') {
-            return { reason: `\`${at}.scopes[${position}]\` is not a string` };
+            return { reason: `\`${entryPath}.scopes[${position}]\` is not a string` };
         }
         readScopes.push(scope.trim());
     }
-    const type = readRequiredString(item, at, 'type');
-    if ('reason' in type) {
-        return type;
+    const typeResult = readRequiredString(item, entryPath, 'type');
+    if ('reason' in typeResult) {
+        return typeResult;
     }
-    const text = readRequiredString(item, at, 'text');
-    if ('reason' in text) {
-        return text;
+    const textResult = readRequiredString(item, entryPath, 'text');
+    if ('reason' in textResult) {
+        return textResult;
     }
     const trimmedMigration = migration?.trim();
     return {
@@ -82,8 +82,8 @@ function readEntry(item, index) {
             breaking: breaking === true,
             ...(trimmedMigration !== undefined && trimmedMigration !== '' && { migration: trimmedMigration }),
             scopes: readScopes,
-            text: text.value,
-            type: type.value,
+            text: textResult.value,
+            type: typeResult.value,
         },
     };
 }
@@ -106,11 +106,11 @@ function readPayload(payload) {
             return { kind: 'malformed', reason: '`entries` is not a list' };
         }
         for (const [index, item] of entries.entries()) {
-            const read = readEntry(item, index);
-            if ('reason' in read) {
-                return { kind: 'malformed', reason: read.reason };
+            const readResult = readEntry(item, index);
+            if ('reason' in readResult) {
+                return { kind: 'malformed', reason: readResult.reason };
             }
-            readEntries.push(read.entry);
+            readEntries.push(readResult.entry);
         }
     }
     const trimmedTicketRef = ticketRef?.trim();
@@ -121,14 +121,14 @@ function readPayload(payload) {
         ...(trimmedTicketRef !== undefined && trimmedTicketRef !== '' && { ticketRef: trimmedTicketRef }),
     };
 }
-function readRequiredString(item, at, name) {
+function readRequiredString(item, entryPath, name) {
     const value = item[name];
     if (value === undefined || value === null) {
-        return { reason: `\`${at}.${name}\` is missing` };
+        return { reason: `\`${entryPath}.${name}\` is missing` };
     }
     if (typeof value !== 'string') {
-        return { reason: `\`${at}.${name}\` is not a string` };
+        return { reason: `\`${entryPath}.${name}\` is not a string` };
     }
-    const trimmed = value.trim();
-    return trimmed === '' ? { reason: `\`${at}.${name}\` is blank` } : { value: trimmed };
+    const trimmedValue = value.trim();
+    return trimmedValue === '' ? { reason: `\`${entryPath}.${name}\` is blank` } : { value: trimmedValue };
 }

package/dist/esm/parseCommitMessage.js

@@ -30,7 +30,7 @@ export function parseCommitMessage(message, hash, workTypes, scopeAliases, optio
     };
 }
 export function parseSubject(subject, workTypes) {
-    const taxonomy = toTaxonomy(workTypes);
+    const taxonomy = adaptToTaxonomy(workTypes);
     for (const nodes of SUBJECT_TEMPLATES) {
         const record = parse(nodes, subject, taxonomy);
         if (record !== undefined) {
@@ -54,14 +54,14 @@ export function evaluateBreakingPolicy(inputs) {
     return hasPrefixBreaking || hasFooterBreaking;
 }
 export function resolveType(rawType, workTypes) {
-    const lowered = rawType.toLowerCase();
+    const loweredType = rawType.toLowerCase();
     for (const [key, config] of Object.entries(workTypes)) {
-        if (key === lowered) {
+        if (key === loweredType) {
             return key;
         }
         if (config.aliases !== undefined) {
             for (const alias of config.aliases) {
-                if (alias === lowered) {
+                if (alias === loweredType) {
                     return key;
                 }
             }
@@ -69,7 +69,7 @@ export function resolveType(rawType, workTypes) {
     }
     return undefined;
 }
-function toTaxonomy(workTypes) {
+function adaptToTaxonomy(workTypes) {
     return {
         tiers: [],
         types: Object.entries(workTypes).map(([key, config]) => ({ aliases: config.aliases ?? [], key, tier: '' })),

package/dist/esm/planChangelogFiles.js

@@ -13,16 +13,16 @@ export function planChangelogFiles(changelogDir, newEntries, settings, sectionOr
         changelogJsonFiles.push(jsonPath);
     }
     const changelogFile = joinPath(changelogDir, 'CHANGELOG.md');
-    const preserved = planPreservedSections(changelogDir, entries);
-    const keepVersions = settings.changelogMarkdown?.keepVersions;
-    const rendered = renderChangelogFiles(entries, {
+    const preservedPlan = planPreservedSections(changelogDir, entries);
+    const keptVersionCount = settings.changelogMarkdown?.keptVersionCount;
+    const renderedFiles = renderChangelogFiles(entries, {
         sectionOrder,
-        preservedSections: preserved.sections,
-        ...(keepVersions !== undefined && { keepVersions }),
+        preservedSections: preservedPlan.sections,
+        ...(keptVersionCount !== undefined && { keptVersionCount }),
     });
-    writes.push({ path: changelogFile, content: rendered.main });
+    writes.push({ path: changelogFile, content: renderedFiles.main });
     const archiveFiles = [];
-    for (const { major, content } of rendered.archives) {
+    for (const { major, content } of renderedFiles.archives) {
         const path = joinPath(changelogDir, describeArchivePath(major));
         writes.push({ path, content });
         archiveFiles.push(path);
@@ -34,7 +34,7 @@ export function planChangelogFiles(changelogDir, newEntries, settings, sectionOr
         changelogFiles: [changelogFile, ...archiveFiles],
         changelogJsonFiles,
         entries,
-        preservation: preserved.preservation,
+        preservation: preservedPlan.preservation,
         removals,
         writes,
     };

package/dist/esm/planReleaseNotesPreviews.js

@@ -13,21 +13,21 @@ export function planReleaseNotesPreviews(options) {
         warnings.push(describePreviewSkip(workspacePath, result.reason, result.version));
         return { writes: [], warnings };
     }
-    const { rendered } = result;
-    if (!readme.exists && !readme.unreadable) {
+    const { renderedReadme } = result;
+    if (!readme.doesExist && !readme.unreadable) {
         warnings.push(`${readmePath} not found; skipping injected-README preview but still writing standalone release notes`);
     }
     const version = extractVersion(tag);
     const docsDir = path.join(workspacePath, 'docs');
     const writes = [];
-    if (readme.exists) {
-        writes.push({ path: path.join(docsDir, `README.v${version}.md`), content: rendered.injectedReadme });
+    if (readme.doesExist) {
+        writes.push({ path: path.join(docsDir, `README.v${version}.md`), content: renderedReadme.injectedReadme });
     }
     writes.push({
         path: path.join(docsDir, `RELEASE_NOTES.v${version}.md`),
-        content: rendered.releaseNotesMarkdown.endsWith('\n')
-            ? rendered.releaseNotesMarkdown
-            : `${rendered.releaseNotesMarkdown}\n`,
+        content: renderedReadme.releaseNotesMarkdown.endsWith('\n')
+            ? renderedReadme.releaseNotesMarkdown
+            : `${renderedReadme.releaseNotesMarkdown}\n`,
     });
     return { writes, warnings };
 }
@@ -39,14 +39,14 @@ function describePreviewSkip(workspacePath, reason, version) {
 }
 function readWorkspaceReadme(readmePath, warnings) {
     if (!existsSync(readmePath)) {
-        return { content: '', exists: false, unreadable: false };
+        return { content: '', doesExist: false, unreadable: false };
     }
     try {
-        return { content: readFileSync(readmePath, 'utf8'), exists: true, unreadable: false };
+        return { content: readFileSync(readmePath, 'utf8'), doesExist: true, unreadable: false };
     }
     catch (error) {
         const message = describeError(error);
         warnings.push(`failed to read ${readmePath}: ${message}; skipping injected-README preview`);
-        return { content: '', exists: false, unreadable: true };
+        return { content: '', doesExist: false, unreadable: true };
     }
 }

package/dist/esm/planVersionBump.js

@@ -6,34 +6,42 @@ function isPackageJson(value) {
     return typeof value === 'object' && value !== null && 'version' in value && typeof value.version === 'string';
 }
 export function planVersionBump(packageFiles, releaseType) {
-    const { firstFile, firstPkg } = readPrimaryPackage(packageFiles);
-    const currentVersion = firstPkg.version;
+    const { firstFile, firstPackageJson } = readPrimaryPackage(packageFiles);
+    const currentVersion = firstPackageJson.version;
     const newVersion = bumpVersion(currentVersion, releaseType);
-    return { currentVersion, newVersion, writes: renderVersionWrites(packageFiles, firstFile, firstPkg, newVersion) };
+    return {
+        currentVersion,
+        newVersion,
+        writes: renderVersionWrites(packageFiles, firstFile, firstPackageJson, newVersion),
+    };
 }
 export function planVersionSet(packageFiles, newVersion) {
-    const { firstFile, firstPkg } = readPrimaryPackage(packageFiles);
-    const currentVersion = firstPkg.version;
+    const { firstFile, firstPackageJson } = readPrimaryPackage(packageFiles);
+    const currentVersion = firstPackageJson.version;
     if (!isForwardVersion(currentVersion, newVersion)) {
         throw new Error(`--set-version ${newVersion} is not greater than current version ${currentVersion}`);
     }
-    return { currentVersion, newVersion, writes: renderVersionWrites(packageFiles, firstFile, firstPkg, newVersion) };
+    return {
+        currentVersion,
+        newVersion,
+        writes: renderVersionWrites(packageFiles, firstFile, firstPackageJson, newVersion),
+    };
 }
 export function readCurrentVersion(packageFiles) {
-    return readPrimaryPackage(packageFiles).firstPkg.version;
+    return readPrimaryPackage(packageFiles).firstPackageJson.version;
 }
 function readPrimaryPackage(packageFiles) {
     const firstFile = packageFiles[0];
     if (firstFile === undefined) {
         throw new Error('No package files specified');
     }
-    return { firstFile, firstPkg: readPackageJson(firstFile) };
+    return { firstFile, firstPackageJson: readPackageJson(firstFile) };
 }
-function renderVersionWrites(packageFiles, firstFile, firstPkg, newVersion) {
+function renderVersionWrites(packageFiles, firstFile, firstPackageJson, newVersion) {
     return packageFiles.map((filePath) => {
-        const pkg = filePath === firstFile ? firstPkg : readPackageJson(filePath);
-        pkg.version = newVersion;
-        return { path: filePath, content: JSON.stringify(pkg, null, 2) + '\n' };
+        const packageJson = filePath === firstFile ? firstPackageJson : readPackageJson(filePath);
+        packageJson.version = newVersion;
+        return { path: filePath, content: JSON.stringify(packageJson, null, 2) + '\n' };
     });
 }
 function readPackageJson(filePath) {
@@ -44,15 +52,15 @@ function readPackageJson(filePath) {
     catch (error) {
         throw chainError(`Failed to read ${filePath}`, error);
     }
-    let parsed;
+    let parsedJson;
     try {
-        parsed = JSON.parse(content);
+        parsedJson = JSON.parse(content);
     }
     catch (error) {
         throw chainError(`Failed to parse JSON in ${filePath}`, error);
     }
-    if (!isPackageJson(parsed)) {
+    if (!isPackageJson(parsedJson)) {
         throw new Error(`No valid 'version' field found in ${filePath}`);
     }
-    return parsed;
+    return parsedJson;
 }

package/dist/esm/prepareArgs.d.ts

@@ -2,15 +2,15 @@ import type { ReleaseType } from './types.js';
 /** Canonical `N.N.N` semver pattern for validating `--set-version` input. */
 export declare const CANONICAL_SEMVER_PATTERN: RegExp;
 export declare const prepareFlagSchema: {
-    dryRun: {
+    isDryRun: {
         long: string;
         type: "boolean";
     };
-    force: {
+    shouldForce: {
         long: string;
         type: "boolean";
     };
-    noGitChecks: {
+    shouldSkipGitChecks: {
         long: string;
         type: "boolean";
         short: string;
@@ -27,7 +27,7 @@ export declare const prepareFlagSchema: {
         long: string;
         type: "string";
     };
-    withReleaseNotes: {
+    shouldIncludeReleaseNotes: {
         long: string;
         type: "boolean";
     };
@@ -39,14 +39,14 @@ export declare const prepareFlagSchema: {
 /** Parses CLI arguments into structured options. Prints a usage error and exits on invalid input. */
 export declare function parseArgs(argv: string[]): {
     configPath: string | undefined;
-    dryRun: boolean;
-    force: boolean;
-    noGitChecks: boolean;
+    isDryRun: boolean;
+    shouldForce: boolean;
+    shouldSkipGitChecks: boolean;
     bumpOverride: ReleaseType | undefined;
-    only: string[] | undefined;
+    onlyNames: string[] | undefined;
     /** The raw `--set-version` value, whose accepted form depends on the mode. */
     setVersion: string | undefined;
-    withReleaseNotes: boolean;
+    shouldIncludeReleaseNotes: boolean;
 };
 /**
  * Parses a monorepo `--set-version` value, a comma-separated list of `<target>@N.N.N` entries, into versions keyed by

package/dist/esm/prepareArgs.js

@@ -4,9 +4,9 @@ const VALID_BUMP_TYPES = ['major', 'minor', 'patch'];
 export const CANONICAL_SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
 export const prepareFlagSchema = {
     ...configFlagSchema,
-    dryRun: { long: '--dry-run', type: 'boolean' },
-    force: { long: '--force', type: 'boolean' },
-    noGitChecks: {
+    isDryRun: { long: '--dry-run', type: 'boolean' },
+    shouldForce: { long: '--force', type: 'boolean' },
+    shouldSkipGitChecks: {
         long: '--no-git-checks',
         type: 'boolean',
         short: '-n',
@@ -14,7 +14,7 @@ export const prepareFlagSchema = {
     bump: { long: '--bump', type: 'string' },
     setVersion: { long: '--set-version', type: 'string' },
     only: { long: '--only', type: 'string' },
-    withReleaseNotes: { long: '--with-release-notes', type: 'boolean' },
+    shouldIncludeReleaseNotes: { long: '--with-release-notes', type: 'boolean' },
 };
 export function parseArgs(argv) {
     const { flags } = parseArgsOrExit(argv, prepareFlagSchema);
@@ -26,19 +26,19 @@ export function parseArgs(argv) {
         }
         bumpOverride = flags.bump;
     }
-    let only;
+    let onlyNames;
     if (flags.only !== undefined) {
-        only = flags.only.split(',');
+        onlyNames = flags.only.split(',');
     }
     return {
         configPath: flags.config,
-        dryRun: flags.dryRun,
-        force: flags.force,
-        noGitChecks: flags.noGitChecks,
+        isDryRun: flags.isDryRun,
+        shouldForce: flags.shouldForce,
+        shouldSkipGitChecks: flags.shouldSkipGitChecks,
         bumpOverride,
-        only,
+        onlyNames,
         setVersion: flags.setVersion,
-        withReleaseNotes: flags.withReleaseNotes,
+        shouldIncludeReleaseNotes: flags.shouldIncludeReleaseNotes,
     };
 }
 export function parseSetVersions(value, knownNames) {

package/dist/esm/prepareCommand.js

@@ -3,28 +3,29 @@ import { formatGlyphLine, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
 import { assertReleasesOnNpm } from "./assertReleasesOnNpm.js";
+import { assertTarballsComplete } from "./assertTarballsComplete.js";
 import { describeEmptyWorkspace, discoverWorkspaces } from "./discoverWorkspaces.js";
 import { dim } from "./format.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
 import { loadValidatedConfig, reportConfigProblem, reportConfigWarnings } from "./loadValidatedConfig.js";
 import { CANONICAL_SEMVER_PATTERN, parseArgs, parseSetVersions } from "./prepareArgs.js";
+import { prepareReleaseTargets } from "./prepareReleaseTargets.js";
 import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./releaseFiles.js";
 import { applyReleasePlan } from "./releasePlan.js";
-import { releasePrepareTargets } from "./releasePrepareTargets.js";
 import { reportPrepare } from "./reportPrepare.js";
 import { resolveConfigFlag } from "./resolveConfigFlag.js";
 import { isSinglePackageTargets, PROJECT_TARGET_ID, resolveReleaseTargets, SINGLE_PACKAGE_TARGET_ID, } from "./resolveReleaseTargets.js";
 export async function prepareCommand(argv, styles, invocationDir) {
-    const { configPath: configFlag, dryRun, force, noGitChecks, bumpOverride, only, setVersion, withReleaseNotes, } = parseArgs(argv);
+    const { configPath: configFlag, isDryRun, shouldForce, shouldSkipGitChecks, bumpOverride, onlyNames, setVersion, shouldIncludeReleaseNotes, } = parseArgs(argv);
     const options = {
-        force,
+        shouldForce,
         ...(bumpOverride !== undefined && { bumpOverride }),
-        ...(withReleaseNotes && { withReleaseNotes: true }),
+        ...(shouldIncludeReleaseNotes && { shouldIncludeReleaseNotes: true }),
     };
-    if (dryRun) {
+    if (isDryRun) {
         console.info(`\n${formatGlyphLine(RELEASE_GLYPHS, styles.stdout, 'dryRun', 'DRY RUN: release-kit will not modify any files')}\n`);
     }
-    if (!dryRun && !noGitChecks) {
+    if (!isDryRun && !shouldSkipGitChecks) {
         try {
             assertCleanWorkingTree();
         }
@@ -43,37 +44,39 @@ export async function prepareCommand(argv, styles, invocationDir) {
         reportConfigWarnings(configResult.warnings, styles.stderr);
         userConfig = configResult.config;
     }
-    let workspace;
+    let workspaceDiscovery;
     try {
-        workspace = discoverWorkspaces();
+        workspaceDiscovery = discoverWorkspaces();
     }
     catch (error) {
         reportError(`Failed to discover workspaces: ${describeError(error)}`);
         process.exit(1);
     }
-    if (workspace.kind === 'empty') {
-        reportError(`No workspace package to release. ${describeEmptyWorkspace(workspace)}`);
+    if (workspaceDiscovery.kind === 'empty') {
+        reportError(`No workspace package to release. ${describeEmptyWorkspace(workspaceDiscovery)}`);
         process.exit(1);
     }
-    const config = resolveTargetsOrExit(userConfig, workspace, only, setVersion);
+    const config = resolveTargetsOrExit(userConfig, workspaceDiscovery, onlyNames, setVersion);
     const targetOptions = {
         ...options,
-        ...(only !== undefined && { only }),
-        ...(setVersion !== undefined && { setVersions: resolveSetVersions(setVersion, config.targets) }),
+        ...(onlyNames !== undefined && { onlyTargetIds: onlyNames }),
+        ...(setVersion !== undefined && { versionOverridesById: resolveSetVersions(setVersion, config.targets) }),
     };
     runAndReport(() => {
-        const plan = releasePrepareTargets(config, targetOptions);
-        assertReleasesOnNpm(findReleasedPackagePaths(plan, config.targets));
+        const plan = prepareReleaseTargets(config, targetOptions);
+        const releasedPackagePaths = findReleasedPackagePaths(plan, config.targets);
+        assertReleasesOnNpm(releasedPackagePaths);
+        assertTarballsComplete(releasedPackagePaths, userConfig?.devExportConditions ?? []);
         return plan;
-    }, dryRun, styles.stdout);
+    }, isDryRun, styles.stdout);
 }
 function findReleasedPackagePaths(plan, targets) {
     const releasedIds = new Set(plan.targets.flatMap((result) => result.status === 'released' && result.kind === 'package' ? result.targetId : []));
     return targets.flatMap((target) => target.kind === 'package' && releasedIds.has(target.id) ? target.packagePath : []);
 }
-function resolveTargetsOrExit(userConfig, discovery, only, setVersion) {
+function resolveTargetsOrExit(userConfig, discovery, onlyNames, setVersion) {
     if (discovery.kind === 'single-package') {
-        if (only !== undefined) {
+        if (onlyNames !== undefined) {
             reportError('--only is only supported for monorepo configurations');
             process.exit(1);
         }
@@ -98,8 +101,8 @@ function resolveTargetsOrExit(userConfig, discovery, only, setVersion) {
         process.exit(1);
     }
     const knownNames = listSelectableIds(config.targets);
-    const onlyNames = only ?? [];
-    for (const name of onlyNames) {
+    const requestedNames = onlyNames ?? [];
+    for (const name of requestedNames) {
         if (knownNames.includes(name)) {
             continue;
         }
@@ -120,7 +123,7 @@ function listSelectableIds(targets) {
 function listMemberIds(targets) {
     return targets.flatMap((target) => (target.kind === 'composite' ? [] : target.id));
 }
-function runAndReport(computePlan, dryRun, style) {
+function runAndReport(computePlan, isDryRun, style) {
     let plan;
     try {
         plan = computePlan();
@@ -130,7 +133,7 @@ function runAndReport(computePlan, dryRun, style) {
         process.stderr.write('The command did not write any files; the working tree is unchanged.\n');
         process.exit(1);
     }
-    if (dryRun) {
+    if (isDryRun) {
         process.stdout.write(reportPrepare(plan, { applied: false, style }) + '\n');
         reportPlanFiles(plan, true);
         return;
@@ -164,11 +167,11 @@ function runFormatCommand(formatCommand) {
         return describeError(error);
     }
 }
-function reportPlanFiles(plan, dryRun) {
+function reportPlanFiles(plan, isDryRun) {
     if (plan.tags.length === 0) {
         return;
     }
-    if (dryRun) {
+    if (isDryRun) {
         console.info(dim(`  [dry-run] Would write ${RELEASE_TAGS_FILE}: ${plan.tags.join(' ')}`));
         if (plan.summary.length > 0) {
             console.info(dim(`  [dry-run] Would write ${RELEASE_SUMMARY_FILE}`));