@williamthorsen/release-kit 15.0.2 → 16.0.0

package/dist/esm/enumerateReleaseWindows.js

@@ -1,5 +1,5 @@
 import { execFileSync } from 'node:child_process';
-import { GIT_OUTPUT_LIMIT } from '@williamthorsen/nmr-core';
+import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
 import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
 import { matchesTagPrefix } from "./matchesTagPrefix.js";
 const FIELD_SEPARATOR = '\u{1F}';
@@ -11,7 +11,7 @@ export function enumerateReleaseWindows(options) {
     }
     const unreleasedWindow = {
         version: unreleasedTag,
-        timestamp: Math.floor(now() / 1_000),
+        timestampSec: Math.floor(now() / 1_000),
         commits: [],
     };
     const ancestry = readAncestry();
@@ -21,7 +21,7 @@ export function enumerateReleaseWindows(options) {
     const boundaries = readTagBoundaries(tagPrefixes, ancestry.positionByHash);
     const releasedWindows = boundaries.map((boundary) => ({
         version: boundary.tag,
-        timestamp: boundary.timestamp,
+        timestampSec: boundary.timestampSec,
         commits: [],
     }));
     const windowIndexByHash = claimAncestors(boundaries, ancestry.parentsByHash);
@@ -35,14 +35,14 @@ export function enumerateReleaseWindows(options) {
 function claimAncestors(boundaries, parentsByHash) {
     const windowIndexByHash = new Map();
     for (const [windowIndex, boundary] of boundaries.entries()) {
-        const pending = [boundary.hash];
-        while (pending.length > 0) {
-            const hash = pending.pop();
+        const pendingHashes = [boundary.hash];
+        while (pendingHashes.length > 0) {
+            const hash = pendingHashes.pop();
             if (hash === undefined || windowIndexByHash.has(hash)) {
                 continue;
             }
             windowIndexByHash.set(hash, windowIndex);
-            pending.push(...(parentsByHash.get(hash) ?? []));
+            pendingHashes.push(...(parentsByHash.get(hash) ?? []));
         }
     }
     return windowIndexByHash;
@@ -103,7 +103,7 @@ function readTagBoundaries(tagPrefixes, positionByHash) {
         const hash = dereferencedName || objectName;
         const position = positionByHash.get(hash);
         if (position !== undefined) {
-            boundaries.push({ hash, position, tag, timestamp: Number(creatorDate) });
+            boundaries.push({ hash, position, tag, timestampSec: Number(creatorDate) });
         }
     }
     return boundaries.toSorted((left, right) => right.position - left.position);
@@ -112,7 +112,7 @@ function runGit(args, description) {
     try {
         return execFileSync('git', args, {
             encoding: 'utf8',
-            maxBuffer: GIT_OUTPUT_LIMIT,
+            maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
             stdio: ['pipe', 'pipe', 'pipe'],
         }).trim();
     }

package/dist/esm/findTransitiveDependents.js

@@ -1,6 +1,6 @@
 export function findTransitiveDependents(graph, startDirs) {
-    const found = new Set(startDirs);
-    const queue = [...found];
+    const foundDirs = new Set(startDirs);
+    const queue = [...foundDirs];
     while (queue.length > 0) {
         const dir = queue.shift();
         if (dir === undefined)
@@ -10,11 +10,11 @@ export function findTransitiveDependents(graph, startDirs) {
             continue;
         const dependents = graph.dependentsOf.get(packageName) ?? [];
         for (const dependent of dependents) {
-            if (found.has(dependent.id))
+            if (foundDirs.has(dependent.id))
                 continue;
-            found.add(dependent.id);
+            foundDirs.add(dependent.id);
             queue.push(dependent.id);
         }
     }
-    return found;
+    return foundDirs;
 }

package/dist/esm/findUnroutedEntryScopes.js

@@ -28,11 +28,11 @@ function findCommitUnroutedScopes(commit, windowDirs, unreadDirs, isRootReserved
     for (const [index, entry] of reading.entries.entries()) {
         const scopes = new Set(entry.scopes);
         for (const scope of scopes) {
-            const resolved = scopeAliases[scope] ?? scope;
-            const isRouted = resolved === '*' ||
-                windowDirs.has(resolved) ||
-                unreadDirs.has(resolved) ||
-                (resolved === 'root' && isRootReserved);
+            const resolvedScope = scopeAliases[scope] ?? scope;
+            const isRouted = resolvedScope === '*' ||
+                windowDirs.has(resolvedScope) ||
+                unreadDirs.has(resolvedScope) ||
+                (resolvedScope === 'root' && isRootReserved);
             if (!isRouted) {
                 findings.push({ commitHash: commit.hash, commitSubject: commit.subject, entryPosition: index + 1, scope });
             }
@@ -41,17 +41,17 @@ function findCommitUnroutedScopes(commit, windowDirs, unreadDirs, isRootReserved
     return findings;
 }
 function indexCommits(windows) {
-    const index = new Map();
+    const commitsByHash = new Map();
     for (const window of windows) {
         for (const commit of window.commits) {
-            const indexed = index.get(commit.hash);
-            if (indexed === undefined) {
-                index.set(commit.hash, { commit, windowDirs: new Set([window.dir]) });
+            const indexedEntry = commitsByHash.get(commit.hash);
+            if (indexedEntry === undefined) {
+                commitsByHash.set(commit.hash, { commit, windowDirs: new Set([window.dir]) });
             }
             else {
-                indexed.windowDirs.add(window.dir);
+                indexedEntry.windowDirs.add(window.dir);
             }
         }
     }
-    return index;
+    return commitsByHash;
 }

package/dist/esm/format.d.ts

@@ -3,4 +3,4 @@ export declare function bold(text: string, stream?: NodeJS.WritableStream): stri
 /** Styles text dim, returning it unstyled for a stream that cannot render color. */
 export declare function dim(text: string, stream?: NodeJS.WritableStream): string;
 /** Renders a section header for separating workspaces in CLI output. */
-export declare function sectionHeader(name: string): string;
+export declare function renderSectionHeader(name: string): string;

package/dist/esm/format.js

@@ -5,6 +5,6 @@ export function bold(text, stream = process.stdout) {
 export function dim(text, stream = process.stdout) {
     return styleText('dim', text, { stream });
 }
-export function sectionHeader(name) {
+export function renderSectionHeader(name) {
     return `━━━ ${name} ━━━`;
 }

package/dist/esm/formatPrepareFiles.d.ts

@@ -1,11 +1,11 @@
 import { type OutputStyle } from '@williamthorsen/nmr-core';
 import type { ReleasedPackageResult } from './types.js';
 /** Appends bump file detail lines. */
-export declare function formatBumpFiles(lines: string[], workspace: Pick<ReleasedPackageResult, 'bumpedFiles'>, dryRun: boolean, indent?: string): void;
+export declare function formatBumpFiles(lines: string[], workspace: Pick<ReleasedPackageResult, 'bumpedFiles'>, isDryRun: boolean, indent?: string): void;
 /**
  * Appends a line per generated changelog file, each followed by the versions kept from the existing changelog and a
  * warning naming the sections dropped for lacking a version, then a line per removed changelog archive file.
  */
-export declare function formatChangelogFiles(lines: string[], release: Pick<ReleasedPackageResult, 'changelogFiles' | 'changelogPreservation' | 'removedChangelogFiles'>, dryRun: boolean, style: OutputStyle, indent?: string): void;
+export declare function formatChangelogFiles(lines: string[], release: Pick<ReleasedPackageResult, 'changelogFiles' | 'changelogPreservation' | 'removedChangelogFiles'>, isDryRun: boolean, style: OutputStyle, indent?: string): void;
 /** Appends release-notes preview file lines, which are present only under `--with-release-notes`. */
-export declare function formatPreviewFiles(lines: string[], release: Pick<ReleasedPackageResult, 'previewFiles'>, dryRun: boolean, indent?: string): void;
+export declare function formatPreviewFiles(lines: string[], release: Pick<ReleasedPackageResult, 'previewFiles'>, isDryRun: boolean, indent?: string): void;

package/dist/esm/formatPrepareFiles.js

@@ -1,8 +1,8 @@
 import { formatStatusLine } from '@williamthorsen/nmr-core';
 import { dim } from "./format.js";
-export function formatBumpFiles(lines, workspace, dryRun, indent = '') {
+export function formatBumpFiles(lines, workspace, isDryRun, indent = '') {
     for (const file of workspace.bumpedFiles) {
-        if (dryRun) {
+        if (isDryRun) {
             lines.push(dim(`${indent}  [dry-run] Would bump ${file}`));
         }
         else {
@@ -10,9 +10,9 @@ export function formatBumpFiles(lines, workspace, dryRun, indent = '') {
         }
     }
 }
-export function formatChangelogFiles(lines, release, dryRun, style, indent = '') {
+export function formatChangelogFiles(lines, release, isDryRun, style, indent = '') {
     for (const file of release.changelogFiles) {
-        if (dryRun) {
+        if (isDryRun) {
             lines.push(dim(`${indent}  [dry-run] Would generate changelog: ${file}`));
         }
         else {
@@ -25,16 +25,16 @@ export function formatChangelogFiles(lines, release, dryRun, style, indent = '')
         if (preservation.preservedVersions.length > 0) {
             lines.push(dim(`${indent}    Kept from the existing changelog: ${preservation.preservedVersions.join(', ')}`));
         }
-        const dropped = preservation.droppedUnversionedHeadings;
-        if (dropped.length === 0) {
+        const droppedHeadings = preservation.droppedUnversionedHeadings;
+        if (droppedHeadings.length === 0) {
             continue;
         }
-        const message = `Dropped ${dropped.length} section${dropped.length === 1 ? '' : 's'} without a version: ${dropped.join(', ')}`;
+        const message = `Dropped ${droppedHeadings.length} section${droppedHeadings.length === 1 ? '' : 's'} without a version: ${droppedHeadings.join(', ')}`;
         lines.push(`${indent}    ${formatStatusLine(style, 'warning', message)}`);
     }
     const removedFiles = release.removedChangelogFiles ?? [];
     for (const file of removedFiles) {
-        if (dryRun) {
+        if (isDryRun) {
             lines.push(dim(`${indent}  [dry-run] Would remove changelog: ${file}`));
         }
         else {
@@ -42,10 +42,10 @@ export function formatChangelogFiles(lines, release, dryRun, style, indent = '')
         }
     }
 }
-export function formatPreviewFiles(lines, release, dryRun, indent = '') {
+export function formatPreviewFiles(lines, release, isDryRun, indent = '') {
     const previewFiles = release.previewFiles ?? [];
     for (const file of previewFiles) {
-        if (dryRun) {
+        if (isDryRun) {
             lines.push(dim(`${indent}  [dry-run] Would write ${file}`));
         }
         else {

package/dist/esm/formatPrepareWarnings.js

@@ -1,5 +1,5 @@
 import { formatStatusLine, truncateToWidth } from '@williamthorsen/nmr-core';
-const SUBJECT_COLUMN_BUDGET = 72;
+const SUBJECT_BUDGET_COLUMNS = 72;
 export function formatChangeRecordWarnings(lines, release, style, indent = '') {
     const { malformedBlocks = [], undeclaredEntryTypes = [], unroutedEntryScopes = [] } = release;
     if (malformedBlocks.length > 0) {
@@ -45,13 +45,13 @@ export function formatPolicyViolations(lines, violations, style, indent = '') {
     }
 }
 export function formatUnparseableWarning(lines, release, style, indent = '') {
-    const unparseable = release.unparseableCommits;
-    if (unparseable === undefined || unparseable.length === 0) {
+    const unparseableCommits = release.unparseableCommits;
+    if (unparseableCommits === undefined || unparseableCommits.length === 0) {
         return;
     }
-    const count = unparseable.length;
+    const count = unparseableCommits.length;
     lines.push(`${indent}  ${formatStatusLine(style, 'warning', `${count} commit${count === 1 ? '' : 's'} could not be parsed`)}`);
-    for (const commit of unparseable) {
+    for (const commit of unparseableCommits) {
         const shortHash = commit.hash.slice(0, 7);
         const truncatedSubject = truncateSubject(commit.subject);
         lines.push(`${indent}    · ${shortHash} ${truncatedSubject}`);
@@ -68,5 +68,5 @@ export function formatWarnings(lines, result, style) {
     }
 }
 function truncateSubject(subject) {
-    return truncateToWidth(subject, { width: SUBJECT_COLUMN_BUDGET });
+    return truncateToWidth(subject, { width: SUBJECT_BUDGET_COLUMNS });
 }

package/dist/esm/hasPrettierConfig.js

@@ -15,8 +15,8 @@ function hasPrettierKeyInPackageJson(packageJsonPath) {
         return false;
     }
     try {
-        const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-        return isRecord(parsed) && 'prettier' in parsed;
+        const parsedJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        return isRecord(parsedJson) && 'prettier' in parsedJson;
     }
     catch {
         return false;

package/dist/esm/init/checks.js

@@ -1,10 +1,10 @@
 import { execSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
-import { GIT_OUTPUT_LIMIT } from '@williamthorsen/nmr-core';
+import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
 import { parseJsonRecord } from "./parseJsonRecord.js";
 export function isGitRepo() {
     try {
-        execSync('git rev-parse --is-inside-work-tree', { maxBuffer: GIT_OUTPUT_LIMIT, stdio: 'pipe' });
+        execSync('git rev-parse --is-inside-work-tree', { maxBuffer: GIT_OUTPUT_LIMIT_BYTES, stdio: 'pipe' });
         return { ok: true };
     }
     catch {
@@ -24,9 +24,11 @@ export function usesPnpm() {
     if (existsSync('pnpm-lock.yaml')) {
         return { ok: true };
     }
-    const raw = readFileSync('package.json', 'utf8');
-    const pkg = parseJsonRecord(raw);
-    if (pkg !== undefined && typeof pkg['packageManager'] === 'string' && pkg['packageManager'].startsWith('pnpm')) {
+    const manifestJson = readFileSync('package.json', 'utf8');
+    const packageJson = parseJsonRecord(manifestJson);
+    if (packageJson !== undefined &&
+        typeof packageJson['packageManager'] === 'string' &&
+        packageJson['packageManager'].startsWith('pnpm')) {
         return { ok: true };
     }
     return {

package/dist/esm/init/detectRepoType.js

@@ -5,9 +5,9 @@ export function detectRepoType() {
         return 'monorepo';
     }
     if (existsSync('package.json')) {
-        const raw = readFileSync('package.json', 'utf8');
-        const pkg = parseJsonRecord(raw);
-        if (pkg !== undefined && Array.isArray(pkg['workspaces'])) {
+        const manifestJson = readFileSync('package.json', 'utf8');
+        const packageJson = parseJsonRecord(manifestJson);
+        if (packageJson !== undefined && Array.isArray(packageJson['workspaces'])) {
             return 'monorepo';
         }
     }

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

@@ -1,12 +1,12 @@
 import { type StreamStyles } from '@williamthorsen/nmr-core';
 interface InitOptions {
-    dryRun: boolean;
-    force: boolean;
+    isDryRun: boolean;
+    shouldForce: boolean;
     styles: StreamStyles;
-    withConfig: boolean;
+    shouldScaffoldConfig: boolean;
 }
 /** Runs the eligibility checks, stopping at the first failure, and reports whether all passed. */
 export declare function checkEligibility(styles: StreamStyles): boolean;
 /** Runs the `release-kit init` command and returns the process exit code. */
-export declare function initCommand({ dryRun, force, styles, withConfig }: InitOptions): number;
+export declare function initCommand({ isDryRun, shouldForce, styles, shouldScaffoldConfig }: InitOptions): number;
 export {};

package/dist/esm/init/initCommand.js

@@ -10,8 +10,8 @@ export function checkEligibility(styles) {
         runRequiredCheck('package.json found', hasPackageJson(), styles) &&
         runRequiredCheck('pnpm detected', usesPnpm(), styles));
 }
-export function initCommand({ dryRun, force, styles, withConfig }) {
-    if (dryRun) {
+export function initCommand({ isDryRun, shouldForce, styles, shouldScaffoldConfig }) {
+    if (isDryRun) {
         console.info('[dry-run mode]');
     }
     let eligible;
@@ -43,25 +43,25 @@ export function initCommand({ dryRun, force, styles, withConfig }) {
     }
     let results;
     try {
-        results = scaffoldFiles({ repoType, dryRun, overwrite: force, publishable, withConfig });
+        results = scaffoldFiles({ repoType, isDryRun, shouldOverwrite: shouldForce, publishable, shouldScaffoldConfig });
     }
     catch (error) {
         printError(`Failed to scaffold files: ${describeError(error)}`, styles.stderr);
         return 1;
     }
     for (const result of results) {
-        reportWriteResult(result, dryRun, styles);
+        reportWriteResult(result, isDryRun, styles);
     }
     if (results.some((r) => r.outcome === 'failed')) {
         return 1;
     }
     printStep('Next steps');
-    console.info(`\n${formatNextSteps({ publishable, withConfig })}\n`);
+    console.info(`\n${formatNextSteps({ publishable, shouldScaffoldConfig })}\n`);
     return 0;
 }
-function formatNextSteps({ publishable, withConfig }) {
+function formatNextSteps({ publishable, shouldScaffoldConfig, }) {
     const steps = [
-        withConfig
+        shouldScaffoldConfig
             ? '(Optional) Customize .config/release-kit.config.ts.'
             : '(Optional) Run again with --with-config to scaffold config files.',
         ...(publishable ? ['If this is a private repo, remove provenance: true from .github/workflows/publish.yaml.'] : []),

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

@@ -1,2 +1,2 @@
 /** Parses a JSON string, returning the result if it is a plain object and `undefined` otherwise. */
-export declare function parseJsonRecord(raw: string): Record<string, unknown> | undefined;
+export declare function parseJsonRecord(jsonText: string): Record<string, unknown> | undefined;

package/dist/esm/init/parseJsonRecord.js

@@ -1,11 +1,11 @@
 import { isRecord } from "../typeGuards.js";
-export function parseJsonRecord(raw) {
-    let parsed;
+export function parseJsonRecord(jsonText) {
+    let parsedJson;
     try {
-        parsed = JSON.parse(raw);
+        parsedJson = JSON.parse(jsonText);
     }
     catch {
         return undefined;
     }
-    return isRecord(parsed) ? parsed : undefined;
+    return isRecord(parsedJson) ? parsedJson : undefined;
 }

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

@@ -2,15 +2,15 @@ import { type WriteResult } from '@williamthorsen/nmr-core';
 import type { RepoType } from './detectRepoType.js';
 interface ScaffoldOptions {
     repoType: RepoType;
-    dryRun: boolean;
-    overwrite: boolean;
+    isDryRun: boolean;
+    shouldOverwrite: boolean;
     publishable: boolean;
-    withConfig: boolean;
+    shouldScaffoldConfig: boolean;
 }
 export declare const CREATE_GITHUB_RELEASE_WORKFLOW_PATH = ".github/workflows/create-github-release.yaml";
 export declare const PUBLISH_WORKFLOW_PATH = ".github/workflows/publish.yaml";
 /** The workflows that act only on publishable packages, which a repo whose packages are all private does not get. */
 export declare const PUBLISHING_WORKFLOW_PATHS: readonly [".github/workflows/create-github-release.yaml", ".github/workflows/publish.yaml"];
 /** Scaffolds release-kit files for the target repo, returning a result for each file attempted. */
-export declare function scaffoldFiles({ repoType, dryRun, overwrite, publishable, withConfig, }: ScaffoldOptions): WriteResult[];
+export declare function scaffoldFiles({ repoType, isDryRun, shouldOverwrite, publishable, shouldScaffoldConfig, }: ScaffoldOptions): WriteResult[];
 export {};

package/dist/esm/init/scaffold.js

@@ -1,19 +1,28 @@
 import { writeFileWithCheck } from '@williamthorsen/nmr-core';
-import { createGithubReleaseWorkflow, publishWorkflow, releaseConfigScript, releaseWorkflow } from "./templates.js";
+import { renderCreateGithubReleaseWorkflow, renderPublishWorkflow, renderReleaseConfigScript, renderReleaseWorkflow, } from "./templates.js";
 export const CREATE_GITHUB_RELEASE_WORKFLOW_PATH = '.github/workflows/create-github-release.yaml';
 export const PUBLISH_WORKFLOW_PATH = '.github/workflows/publish.yaml';
 export const PUBLISHING_WORKFLOW_PATHS = [CREATE_GITHUB_RELEASE_WORKFLOW_PATH, PUBLISH_WORKFLOW_PATH];
-export function scaffoldFiles({ repoType, dryRun, overwrite, publishable, withConfig, }) {
+export function scaffoldFiles({ repoType, isDryRun, shouldOverwrite, publishable, shouldScaffoldConfig, }) {
     const results = [];
     if (publishable) {
-        results.push(writeFileWithCheck(CREATE_GITHUB_RELEASE_WORKFLOW_PATH, createGithubReleaseWorkflow(repoType), {
-            dryRun,
-            overwrite,
-        }), writeFileWithCheck(PUBLISH_WORKFLOW_PATH, publishWorkflow(repoType), { dryRun, overwrite }));
+        results.push(writeFileWithCheck(CREATE_GITHUB_RELEASE_WORKFLOW_PATH, renderCreateGithubReleaseWorkflow(repoType), {
+            isDryRun,
+            shouldOverwrite,
+        }), writeFileWithCheck(PUBLISH_WORKFLOW_PATH, renderPublishWorkflow(repoType), {
+            isDryRun,
+            shouldOverwrite,
+        }));
     }
-    results.push(writeFileWithCheck('.github/workflows/release.yaml', releaseWorkflow(repoType), { dryRun, overwrite }));
-    if (withConfig) {
-        results.push(writeFileWithCheck('.config/release-kit.config.ts', releaseConfigScript(repoType), { dryRun, overwrite }));
+    results.push(writeFileWithCheck('.github/workflows/release.yaml', renderReleaseWorkflow(repoType), {
+        isDryRun,
+        shouldOverwrite,
+    }));
+    if (shouldScaffoldConfig) {
+        results.push(writeFileWithCheck('.config/release-kit.config.ts', renderReleaseConfigScript(repoType), {
+            isDryRun,
+            shouldOverwrite,
+        }));
     }
     return results;
 }

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

@@ -1,16 +1,16 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { printError, printSkip, printStep, printSuccess, reportTemplateUpdate, updateManagedFile, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
-import { syncLabelsWorkflow } from "../sync-labels/templates.js";
+import { readSyncLabelsWorkflowTemplate } from "../sync-labels/templates.js";
 import { detectRepoType } from "./detectRepoType.js";
 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, { 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, syncLabelsWorkflow()]);
+        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;