@williamthorsen/release-kit 15.0.3 → 16.1.0

package/dist/esm/init/templates.d.ts

@@ -1,16 +1,16 @@
 import type { RepoType } from './detectRepoType.js';
-/** Generates the `.config/release-kit.config.ts` starter config, with commented-out options to customize. */
-export declare function releaseConfigScript(repoType: RepoType): string;
+/** Renders the `.config/release-kit.config.ts` starter config, with commented-out options to customize. */
+export declare function renderReleaseConfigScript(repoType: RepoType): string;
 /**
- * Generates the publish.yaml GitHub Actions entry-point workflow.
+ * Renders the publish.yaml GitHub Actions entry-point workflow.
  *
  * The caller's `permissions` block caps what the reusable workflow receives, so it must grant the `id-token: write`
- * that OIDC publishing needs. `provenance: false` omits the provenance input, which a private repo cannot use.
+ * that OIDC publishing needs. `shouldGenerateProvenance: false` omits the provenance input, which a private repo cannot use.
  */
-export declare function publishWorkflow(repoType: RepoType, { provenance }?: {
-    provenance?: boolean;
+export declare function renderPublishWorkflow(repoType: RepoType, { shouldGenerateProvenance }?: {
+    shouldGenerateProvenance?: boolean;
 }): string;
-/** Generates the create-github-release.yaml GitHub Actions caller workflow. */
-export declare function createGithubReleaseWorkflow(repoType: RepoType): string;
-/** Generates the release.yaml GitHub Actions workflow. */
-export declare function releaseWorkflow(repoType: RepoType): string;
+/** Renders the create-github-release.yaml GitHub Actions caller workflow. */
+export declare function renderCreateGithubReleaseWorkflow(repoType: RepoType): string;
+/** Renders the release.yaml GitHub Actions workflow. */
+export declare function renderReleaseWorkflow(repoType: RepoType): string;

package/dist/esm/init/templates.js

@@ -1,4 +1,4 @@
-export function releaseConfigScript(repoType) {
+export function renderReleaseConfigScript(repoType) {
     if (repoType === 'monorepo') {
         return `import { defineConfig } from '@williamthorsen/release-kit/config';
 
@@ -39,7 +39,7 @@ export default defineConfig({
 });
 `;
 }
-export function publishWorkflow(repoType, { provenance = true } = {}) {
+export function renderPublishWorkflow(repoType, { shouldGenerateProvenance = true } = {}) {
     const tagPattern = repoType === 'monorepo' ? "'*-v[0-9]*.[0-9]*.[0-9]*'" : "'v[0-9]*.[0-9]*.[0-9]*'";
     return `# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
 name: Publish
@@ -57,10 +57,10 @@ jobs:
   publish:
     uses: williamthorsen/node-monorepo-tools/.github/workflows/publish.reusable.yaml@workflow/publish-v1
     with:
-${provenance ? '      provenance: true\n' : ''}      tags: \${{ github.ref_name }}
+${shouldGenerateProvenance ? '      provenance: true\n' : ''}      tags: \${{ github.ref_name }}
 `;
 }
-export function createGithubReleaseWorkflow(repoType) {
+export function renderCreateGithubReleaseWorkflow(repoType) {
     const tagPattern = repoType === 'monorepo' ? "'*-v[0-9]*.[0-9]*.[0-9]*'" : "'v[0-9]*.[0-9]*.[0-9]*'";
     return `# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
 name: Create GitHub release
@@ -80,7 +80,7 @@ jobs:
       tag: \${{ github.ref_name }}
 `;
 }
-export function releaseWorkflow(repoType) {
+export function renderReleaseWorkflow(repoType) {
     if (repoType === 'monorepo') {
         return `# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
 name: Release

package/dist/esm/init/updateTemplatesCommand.d.ts

@@ -1,6 +1,6 @@
 import { type StreamStyles } from '@williamthorsen/nmr-core';
 interface UpdateTemplatesOptions {
-    dryRun: boolean;
+    isDryRun: boolean;
     styles: StreamStyles;
 }
 /**
@@ -10,5 +10,5 @@ interface UpdateTemplatesOptions {
  * `sync-labels.yaml` is refreshed only when it exists, as are the publishing workflows in a repo whose packages are
  * all private. Config files are never read or written.
  */
-export declare function updateTemplatesCommand({ dryRun, styles }: UpdateTemplatesOptions): number;
+export declare function updateTemplatesCommand({ isDryRun, styles }: UpdateTemplatesOptions): number;
 export {};

package/dist/esm/init/updateTemplatesCommand.js

@@ -7,10 +7,10 @@ import { hasProvenance } from "./hasProvenance.js";
 import { formatPrivateWorkflowSkip, hasPublishablePackage } from "./hasPublishablePackage.js";
 import { checkEligibility } from "./initCommand.js";
 import { CREATE_GITHUB_RELEASE_WORKFLOW_PATH, PUBLISH_WORKFLOW_PATH, PUBLISHING_WORKFLOW_PATHS } from "./scaffold.js";
-import { createGithubReleaseWorkflow, publishWorkflow, releaseWorkflow } from "./templates.js";
+import { renderCreateGithubReleaseWorkflow, renderPublishWorkflow, renderReleaseWorkflow } from "./templates.js";
 const SYNC_LABELS_WORKFLOW_PATH = '.github/workflows/sync-labels.yaml';
-export function updateTemplatesCommand({ dryRun, styles }) {
-    if (dryRun) {
+export function updateTemplatesCommand({ isDryRun, styles }) {
+    if (isDryRun) {
         console.info('[dry-run mode]');
     }
     let eligible;
@@ -36,32 +36,34 @@ export function updateTemplatesCommand({ dryRun, styles }) {
     printStep('Updating workflows');
     let results;
     try {
-        const { files, skipped } = buildManagedFiles(repoType, hasPublishablePackage());
-        for (const filePath of skipped) {
+        const { files, skippedPaths } = buildManagedFiles(repoType, hasPublishablePackage());
+        for (const filePath of skippedPaths) {
             printSkip(formatPrivateWorkflowSkip(filePath), styles.stdout);
         }
-        results = files.map(([filePath, content]) => updateManagedFile(filePath, content, { isDryRun: dryRun }));
+        results = files.map(([filePath, content]) => updateManagedFile(filePath, content, { isDryRun }));
     }
     catch (error) {
         printError(`Failed to render workflows: ${describeError(error)}`, styles.stderr);
         return 1;
     }
     for (const result of results) {
-        reportTemplateUpdate(result, dryRun, styles);
+        reportTemplateUpdate(result, isDryRun, styles);
     }
     return results.some((result) => result.outcome === 'failed') ? 1 : 0;
 }
 function buildManagedFiles(repoType, publishable) {
-    const skipped = publishable ? [] : PUBLISHING_WORKFLOW_PATHS.filter((filePath) => !existsSync(filePath));
+    const skippedPaths = publishable
+        ? []
+        : PUBLISHING_WORKFLOW_PATHS.filter((filePath) => !existsSync(filePath));
     const files = [
-        [CREATE_GITHUB_RELEASE_WORKFLOW_PATH, createGithubReleaseWorkflow(repoType)],
-        [PUBLISH_WORKFLOW_PATH, publishWorkflow(repoType, { provenance: readProvenanceSetting() })],
-        ['.github/workflows/release.yaml', releaseWorkflow(repoType)],
+        [CREATE_GITHUB_RELEASE_WORKFLOW_PATH, renderCreateGithubReleaseWorkflow(repoType)],
+        [PUBLISH_WORKFLOW_PATH, renderPublishWorkflow(repoType, { shouldGenerateProvenance: readProvenanceSetting() })],
+        ['.github/workflows/release.yaml', renderReleaseWorkflow(repoType)],
     ];
     if (existsSync(SYNC_LABELS_WORKFLOW_PATH)) {
         files.push([SYNC_LABELS_WORKFLOW_PATH, readSyncLabelsWorkflowTemplate()]);
     }
-    return { files: files.filter(([filePath]) => !skipped.includes(filePath)), skipped };
+    return { files: files.filter(([filePath]) => !skippedPaths.includes(filePath)), skippedPaths };
 }
 function readProvenanceSetting() {
     if (!existsSync(PUBLISH_WORKFLOW_PATH))

package/dist/esm/injectReleaseNotesIntoReadme.d.ts

@@ -16,7 +16,7 @@ export type RenderInjectedReadmeSkipReason = 'no-entry' | 'empty-body';
 /** Discriminated outcome of rendering release notes for a tag. */
 export type RenderInjectedReadmeResult = {
     status: 'rendered';
-    rendered: RenderedInjectedReadme;
+    renderedReadme: RenderedInjectedReadme;
 } | {
     status: 'skipped';
     reason: RenderInjectedReadmeSkipReason;

package/dist/esm/injectReleaseNotesIntoReadme.js

@@ -11,7 +11,7 @@ export function renderInjectedReadmeFromEntries(readme, entries, tag, sectionOrd
     }
     const renderedSections = renderReleaseNotesSingle(entry, {
         filter: matchesAudience('all'),
-        includeHeading: false,
+        shouldIncludeHeading: false,
         ...(sectionOrder !== undefined && { sectionOrder }),
     });
     if (renderedSections.trimEnd().length === 0) {
@@ -20,7 +20,7 @@ export function renderInjectedReadmeFromEntries(readme, entries, tag, sectionOrd
     const labeledHeading = `## Release notes — v${version} (${entry.date})`;
     const releaseNotesMarkdown = `${labeledHeading}\n\n${renderedSections.trimEnd()}`;
     const injectedReadme = injectSection(readme, 'release-notes', releaseNotesMarkdown);
-    return { status: 'rendered', rendered: { injectedReadme, releaseNotesMarkdown } };
+    return { status: 'rendered', renderedReadme: { injectedReadme, releaseNotesMarkdown } };
 }
 export function renderInjectedReadme(readme, changelogJsonPath, tag, sectionOrder) {
     if (!existsSync(changelogJsonPath)) {
@@ -37,15 +37,15 @@ export function renderInjectedReadme(readme, changelogJsonPath, tag, sectionOrde
         console.warn(`Warning: ${describeRenderSkip(result.reason, result.version)}; skipping README injection`);
         return undefined;
     }
-    return result.rendered;
+    return result.renderedReadme;
 }
 export function injectReleaseNotesIntoReadme(readmePath, changelogJsonPath, tag, sectionOrder) {
     const originalReadme = readFileSync(readmePath, 'utf8');
-    const rendered = renderInjectedReadme(originalReadme, changelogJsonPath, tag, sectionOrder);
-    if (rendered === undefined) {
+    const renderResult = renderInjectedReadme(originalReadme, changelogJsonPath, tag, sectionOrder);
+    if (renderResult === undefined) {
         return undefined;
     }
-    writeFileSync(readmePath, rendered.injectedReadme, 'utf8');
+    writeFileSync(readmePath, renderResult.injectedReadme, 'utf8');
     return originalReadme;
 }
 export function resolveReadmePath(workspacePath) {

package/dist/esm/injectSection.js

@@ -5,16 +5,16 @@ function closeMarker(key) {
     return `<!-- /section:${key} -->`;
 }
 export function injectSection(content, key, injection) {
-    const open = openMarker(key);
-    const close = closeMarker(key);
-    const openIndex = content.indexOf(open);
-    const closeIndex = content.indexOf(close);
+    const openComment = openMarker(key);
+    const closeComment = closeMarker(key);
+    const openIndex = content.indexOf(openComment);
+    const closeIndex = content.indexOf(closeComment);
     if (openIndex !== -1 && closeIndex !== -1 && closeIndex > openIndex) {
-        const before = content.slice(0, openIndex + open.length);
-        const after = content.slice(closeIndex);
-        return `${before}\n${injection}\n${after}`;
+        const contentBefore = content.slice(0, openIndex + openComment.length);
+        const contentAfter = content.slice(closeIndex);
+        return `${contentBefore}\n${injection}\n${contentAfter}`;
     }
-    const section = `${open}\n${injection}\n${close}`;
+    const section = `${openComment}\n${injection}\n${closeComment}`;
     if (content.length === 0) {
         return `${section}\n`;
     }

package/dist/esm/loadChangelogOverrides.d.ts

@@ -25,7 +25,7 @@ export declare function parseOverrideKey(key: string): {
  * Each error names the offending key (e.g. `overrides['abc']: 'audience' must be one of …`) so that the user can find
  * it in the override file.
  */
-export declare function validateChangelogOverrides(raw: unknown): {
+export declare function validateChangelogOverrides(rawValue: unknown): {
     overrides: Map<string, ChangelogOverride>;
     errors: string[];
 };

package/dist/esm/loadChangelogOverrides.js

@@ -18,16 +18,16 @@ export function loadChangelogOverrides(path) {
             errors: [`Failed to read override file ${path}: ${describeError(error)}`],
         };
     }
-    let parsed;
+    let parsedJson;
     try {
-        parsed = JSON.parse(content);
+        parsedJson = JSON.parse(content);
     }
     catch (error) {
         return {
             errors: [`Failed to parse override file ${path}: ${describeError(error)}`],
         };
     }
-    const result = validateChangelogOverrides(parsed);
+    const result = validateChangelogOverrides(parsedJson);
     if (result.errors.length > 0) {
         return { errors: result.errors };
     }
@@ -41,14 +41,14 @@ export function parseOverrideKey(key) {
     }
     return { hashPrefix: key.slice(0, separatorIndex), entry: Number(key.slice(separatorIndex + 1)) };
 }
-export function validateChangelogOverrides(raw) {
+export function validateChangelogOverrides(rawValue) {
     const overrides = new Map();
     const errors = [];
-    if (!isRecord(raw)) {
+    if (!isRecord(rawValue)) {
         errors.push('Override file: top-level value must be an object keyed by commit hash');
         return { overrides, errors };
     }
-    for (const [key, rawEntry] of Object.entries(raw)) {
+    for (const [key, rawEntry] of Object.entries(rawValue)) {
         if (key === SCHEMA_KEY) {
             if (typeof rawEntry !== 'string') {
                 errors.push(`Override file: '${SCHEMA_KEY}' must be a string`);
@@ -59,9 +59,9 @@ export function validateChangelogOverrides(raw) {
             errors.push(`overrides['${key}']: key must be a lowercase hex commit hash or prefix, optionally followed by ':<n>'`);
             continue;
         }
-        const validated = validateSingleOverride(key, rawEntry, errors);
-        if (validated !== undefined) {
-            overrides.set(key, validated);
+        const validatedOverride = validateSingleOverride(key, rawEntry, errors);
+        if (validatedOverride !== undefined) {
+            overrides.set(key, validatedOverride);
         }
     }
     return { overrides, errors };

package/dist/esm/loadConfig.d.ts

@@ -3,13 +3,13 @@ export declare const ROOT_PACKAGE_JSON_PATH = "package.json";
 /**
  * Reads the root `package.json` and returns its `version` field.
  *
- * Returns `{ exists: false }` when the file is missing, `{ exists: true, version: undefined }`
- * when the file exists but does not have a `version` field, and `{ exists: true, version }`
+ * Returns `{ doesExist: false }` when the file is missing, `{ doesExist: true, version: undefined }`
+ * when the file exists but does not have a `version` field, and `{ doesExist: true, version }`
  * when both are present; `mergeMonorepoConfig` decides whether the situation is an error.
  * Throws when the file cannot be read or parsed.
  */
 export declare function readRootPackageVersion(): {
-    exists: boolean;
+    doesExist: boolean;
     version: string | undefined;
 };
 /** The path where the consumer-facing config file is expected. */

package/dist/esm/loadConfig.js

@@ -15,7 +15,7 @@ export const ROOT_PACKAGE_JSON_PATH = 'package.json';
 export function readRootPackageVersion() {
     const absolutePath = path.resolve(process.cwd(), ROOT_PACKAGE_JSON_PATH);
     if (!existsSync(absolutePath)) {
-        return { exists: false, version: undefined };
+        return { doesExist: false, version: undefined };
     }
     let contents;
     try {
@@ -24,17 +24,17 @@ export function readRootPackageVersion() {
     catch (error) {
         throw chainError(`Failed to read root ${ROOT_PACKAGE_JSON_PATH}`, error);
     }
-    let parsed;
+    let parsedJson;
     try {
-        parsed = JSON.parse(contents);
+        parsedJson = JSON.parse(contents);
     }
     catch (error) {
         throw chainError(`Failed to parse root ${ROOT_PACKAGE_JSON_PATH}`, error);
     }
-    if (!isRecord(parsed)) {
-        return { exists: true, version: undefined };
+    if (!isRecord(parsedJson)) {
+        return { doesExist: true, version: undefined };
     }
-    return { exists: true, version: typeof parsed['version'] === 'string' ? parsed['version'] : undefined };
+    return { doesExist: true, version: typeof parsedJson['version'] === 'string' ? parsedJson['version'] : undefined };
 }
 export const CONFIG_FILE_PATH = '.config/release-kit.config.ts';
 export async function loadConfig(configPath) {
@@ -45,10 +45,10 @@ export async function loadConfig(configPath) {
         }
         throw new Error(`Config file not found: ${absoluteConfigPath}`);
     }
-    const imported = await import(__rewriteRelativeImportExtension(pathToFileURL(absoluteConfigPath).href));
-    const resolved = isRecord(imported) ? (imported['default'] ?? imported['config']) : undefined;
-    if (resolved === undefined) {
+    const importedModule = await import(__rewriteRelativeImportExtension(pathToFileURL(absoluteConfigPath).href));
+    const resolvedConfig = isRecord(importedModule) ? (importedModule['default'] ?? importedModule['config']) : undefined;
+    if (resolvedConfig === undefined) {
         throw new Error('Config file must have a default export or a named `config` export (e.g., `export default { ... }` or `export const config = { ... }`)');
     }
-    return resolved;
+    return resolvedConfig;
 }

package/dist/esm/loadValidatedConfig.js

@@ -4,17 +4,17 @@ import { CONFIG_FILE_PATH, loadConfig } from "./loadConfig.js";
 import { validateConfig } from "./validateConfig.js";
 export async function loadValidatedConfig(configPath) {
     const configFilePath = configPath ?? CONFIG_FILE_PATH;
-    let raw;
+    let rawConfig;
     try {
-        raw = await loadConfig(configPath);
+        rawConfig = await loadConfig(configPath);
     }
     catch (error) {
         return { status: 'invalid', configFilePath, problem: { kind: 'load', message: describeError(error) } };
     }
-    if (raw === undefined) {
+    if (rawConfig === undefined) {
         return { status: 'missing', configFilePath };
     }
-    const { config, errors, warnings } = validateConfig(raw);
+    const { config, errors, warnings } = validateConfig(rawConfig);
     if (errors.length > 0) {
         return { status: 'invalid', configFilePath, problem: { kind: 'validation', errors } };
     }

package/dist/esm/mergeConfig.d.ts

@@ -36,6 +36,6 @@ export declare function resolveWorkTypes(userWorkTypes?: ReleaseKitConfig['workT
  * `mergeMonorepoConfig` does not perform any I/O.
  */
 export interface RootPackageInfo {
-    exists: boolean;
+    doesExist: boolean;
     version: string | undefined;
 }

package/dist/esm/mergeConfig.js

@@ -5,10 +5,10 @@ import { ROOT_PACKAGE_JSON_PATH } from "./loadConfig.js";
 import { assertLegacyIdentityDoesNotMatchCurrent, assertNoSharedVersionFiles, assertNoTagPrefixCollisions, assertRetiredPackagesDoNotCollideWithActive, assertUniqueTagPrefixes, } from "./monorepoConfigAssertions.js";
 import { resolveReleaseDeclaration } from "./resolveReleaseDeclaration.js";
 export function mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage) {
-    const discovered = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
-    assertUniqueTagPrefixes(discovered);
-    const { retained: workspaces, excluded, directories: declaredDirectories, composite, } = resolveReleaseDeclaration(discovered, userConfig);
-    const directories = declaredDirectories.map((declared) => deriveDirectoryConfig(declared));
+    const discoveredWorkspaces = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
+    assertUniqueTagPrefixes(discoveredWorkspaces);
+    const { retainedWorkspaces: workspaces, excludedWorkspaces, directories: declaredDirectories, composite: declaredComposite, } = resolveReleaseDeclaration(discoveredWorkspaces, userConfig);
+    const directories = declaredDirectories.map((declaredDirectory) => deriveDirectoryConfig(declaredDirectory));
     for (const workspace of workspaces) {
         if (workspace.legacyIdentities !== undefined) {
             assertLegacyIdentityDoesNotMatchCurrent(workspace.dir, workspace.name, workspace.tagPrefix, workspace.legacyIdentities);
@@ -17,13 +17,13 @@ export function mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage) {
     if (userConfig?.retiredPackages !== undefined) {
         assertRetiredPackagesDoNotCollideWithActive(workspaces, userConfig.retiredPackages);
     }
-    const project = resolveProjectConfig(composite, rootPackage, workspaces);
+    const projectConfig = resolveProjectConfig(declaredComposite, rootPackage, workspaces);
     const workTypes = resolveWorkTypes(userConfig?.workTypes);
     const versionPatterns = userConfig?.versionPatterns === undefined ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
     const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
     const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
-    assertNoSharedVersionFiles(workspaces, directories, project);
-    assertNoTagPrefixCollisions(workspaces, directories, userConfig?.retiredPackages, project);
+    assertNoSharedVersionFiles(workspaces, directories, projectConfig);
+    assertNoTagPrefixCollisions(workspaces, directories, userConfig?.retiredPackages, projectConfig);
     const result = {
         workspaces,
         workTypes,
@@ -31,14 +31,14 @@ export function mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage) {
         changelogJson,
         releaseNotes,
     };
-    if (excluded.length > 0) {
-        result.excludedWorkspaces = excluded;
+    if (excludedWorkspaces.length > 0) {
+        result.excludedWorkspaces = excludedWorkspaces;
     }
     if (directories.length > 0) {
         result.directories = directories;
     }
-    if (project !== undefined) {
-        result.project = project;
+    if (projectConfig !== undefined) {
+        result.project = projectConfig;
     }
     applyOptionalPassthroughFields(result, userConfig);
     return result;
@@ -80,39 +80,39 @@ function applyOptionalPassthroughFields(result, userConfig) {
         result.breakingPolicies = userConfig.breakingPolicies;
     }
 }
-function mergeChangelogJsonConfig(partial) {
-    if (partial === undefined) {
+function mergeChangelogJsonConfig(partialConfig) {
+    if (partialConfig === undefined) {
         return { ...DEFAULT_CHANGELOG_JSON_CONFIG };
     }
     return {
-        enabled: partial.enabled ?? DEFAULT_CHANGELOG_JSON_CONFIG.enabled,
-        outputPath: partial.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
-        devOnlySections: partial.devOnlySections ?? [...DEFAULT_CHANGELOG_JSON_CONFIG.devOnlySections],
+        enabled: partialConfig.enabled ?? DEFAULT_CHANGELOG_JSON_CONFIG.enabled,
+        outputPath: partialConfig.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
+        devOnlySections: partialConfig.devOnlySections ?? [...DEFAULT_CHANGELOG_JSON_CONFIG.devOnlySections],
     };
 }
-function mergeReleaseNotesConfig(partial) {
-    if (partial === undefined) {
+function mergeReleaseNotesConfig(partialConfig) {
+    if (partialConfig === undefined) {
         return { ...DEFAULT_RELEASE_NOTES_CONFIG };
     }
     return {
-        shouldInjectIntoReadme: partial.shouldInjectIntoReadme ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldInjectIntoReadme,
+        shouldInjectIntoReadme: partialConfig.shouldInjectIntoReadme ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldInjectIntoReadme,
     };
 }
-function resolveProjectConfig(composite, rootPackage, workspaces) {
-    if (composite === undefined) {
+function resolveProjectConfig(declaredComposite, rootPackage, workspaces) {
+    if (declaredComposite === undefined) {
         return undefined;
     }
-    const subject = composite.name === undefined ? 'project block' : `composite release '${composite.name}'`;
-    if (rootPackage === undefined || !rootPackage.exists) {
+    const subject = declaredComposite.name === undefined ? 'project block' : `composite release '${declaredComposite.name}'`;
+    if (rootPackage === undefined || !rootPackage.doesExist) {
         throw new Error(`${subject} requires a root ${ROOT_PACKAGE_JSON_PATH}; create one with a 'version' field at the repo root`);
     }
     if (rootPackage.version === undefined) {
         throw new Error(`${subject} requires root ${ROOT_PACKAGE_JSON_PATH} to have a 'version' field; add a 'version' field to the root package.json`);
     }
     return {
-        paths: composite.paths ?? workspaces.flatMap((workspace) => workspace.paths),
-        tagPrefix: composite.tagPrefix ?? DEFAULT_PROJECT_TAG_PREFIX,
-        ...(composite.name !== undefined && { name: composite.name }),
-        ...(composite.members !== undefined && { members: composite.members }),
+        paths: declaredComposite.paths ?? workspaces.flatMap((workspace) => workspace.paths),
+        tagPrefix: declaredComposite.tagPrefix ?? DEFAULT_PROJECT_TAG_PREFIX,
+        ...(declaredComposite.name !== undefined && { name: declaredComposite.name }),
+        ...(declaredComposite.members !== undefined && { members: declaredComposite.members }),
     };
 }

package/dist/esm/monorepoConfigAssertions.js

@@ -63,10 +63,10 @@ export function assertNoTagPrefixCollisions(workspaces, directories, retiredPack
         }
     }
     const retiredEntries = (retiredPackages ?? []).entries();
-    for (const [index, retired] of retiredEntries) {
+    for (const [index, retiredPackage] of retiredEntries) {
         sources.push({
-            prefix: retired.tagPrefix,
-            label: `retiredPackages entry (name='${retired.name}')`,
+            prefix: retiredPackage.tagPrefix,
+            label: `retiredPackages entry (name='${retiredPackage.name}')`,
             owner: `retired:${index}`,
         });
     }
@@ -77,10 +77,10 @@ export function assertNoTagPrefixCollisions(workspaces, directories, retiredPack
             owner: 'project',
         });
     }
-    for (let i = 0; i < sources.length; i++) {
-        for (let j = i + 1; j < sources.length; j++) {
-            const a = sources[i];
-            const b = sources[j];
+    for (let aIndex = 0; aIndex < sources.length; aIndex++) {
+        for (let bIndex = aIndex + 1; bIndex < sources.length; bIndex++) {
+            const a = sources[aIndex];
+            const b = sources[bIndex];
             if (a === undefined || b === undefined || a.owner === b.owner)
                 continue;
             if (isPrefixCollision(a.prefix, b.prefix)) {
@@ -96,23 +96,23 @@ export function assertRetiredPackagesDoNotCollideWithActive(workspaces, retiredP
     for (const workspace of workspaces) {
         workspaceByDerivedPrefix.set(workspace.tagPrefix, workspace);
     }
-    for (const retired of retiredPackages) {
-        const active = workspaceByDerivedPrefix.get(retired.tagPrefix);
-        if (active !== undefined) {
-            throw new Error(`retiredPackages: tagPrefix '${retired.tagPrefix}' collides with active workspace '${active.dir}' ` +
-                `(derived prefix '${active.tagPrefix}'). A retired package's tagPrefix cannot belong to an active workspace.`);
+    for (const retiredPackage of retiredPackages) {
+        const activeWorkspace = workspaceByDerivedPrefix.get(retiredPackage.tagPrefix);
+        if (activeWorkspace !== undefined) {
+            throw new Error(`retiredPackages: tagPrefix '${retiredPackage.tagPrefix}' collides with active workspace '${activeWorkspace.dir}' ` +
+                `(derived prefix '${activeWorkspace.tagPrefix}'). A retired package's tagPrefix cannot belong to an active workspace.`);
         }
     }
 }
 export function assertUniqueTagPrefixes(workspaces) {
     const pathsByPrefix = new Map();
     for (const workspace of workspaces) {
-        const existing = pathsByPrefix.get(workspace.tagPrefix);
-        if (existing === undefined) {
+        const existingPaths = pathsByPrefix.get(workspace.tagPrefix);
+        if (existingPaths === undefined) {
             pathsByPrefix.set(workspace.tagPrefix, [workspace.workspacePath]);
         }
         else {
-            existing.push(workspace.workspacePath);
+            existingPaths.push(workspace.workspacePath);
         }
     }
     for (const [prefix, paths] of pathsByPrefix) {

package/dist/esm/npmRegistry.js

@@ -34,17 +34,17 @@ export function lookUpNpmPackage(packageName, registry) {
     return classifyNpmPackageLookup(runNpmJson(args));
 }
 export function readNpmError(stdout) {
-    let parsed;
+    let parsedJson;
     try {
-        parsed = JSON.parse(stdout);
+        parsedJson = JSON.parse(stdout);
     }
     catch {
         return undefined;
     }
-    if (!isRecord(parsed) || !isRecord(parsed['error']) || typeof parsed['error']['code'] !== 'string') {
+    if (!isRecord(parsedJson) || !isRecord(parsedJson['error']) || typeof parsedJson['error']['code'] !== 'string') {
         return undefined;
     }
-    const { code, summary } = parsed['error'];
+    const { code, summary } = parsedJson['error'];
     return { code, summary: typeof summary === 'string' ? summary : '' };
 }
 export function runNpmJson(args) {

package/dist/esm/packFromCleanCheckout.d.ts

@@ -0,0 +1,11 @@
+import { type PackageManager } from './detectPackageManager.js';
+/**
+ * Packs each workspace as the publish environment would and returns each one's tarball entries, keyed by workspace
+ * path and relative to the package root.
+ *
+ * Clones HEAD of the repo at the current directory into a temporary directory, runs a frozen install there, then for
+ * each workspace runs its `prepublishOnly` when it declares one and packs it. Workspace paths are relative to the repo
+ * root. Throws an error that names the failing step and contains its output. Leaves the repo and its working tree
+ * untouched, and removes the temporary directory.
+ */
+export declare function packFromCleanCheckout(workspacePaths: readonly string[], packageManager: PackageManager): Map<string, string[]>;