@williamthorsen/release-kit 15.0.3 → 16.0.0

package/dist/esm/commitCommand.js

@@ -3,10 +3,10 @@ import { readFileSync } from 'node:fs';
 import { GIT_OUTPUT_LIMIT_BYTES, hasErrnoCode, parseArgsOrExit } from '@williamthorsen/nmr-core';
 import { readReleaseTags, RELEASE_SUMMARY_FILE, resolveReleaseTagsPath } from "./releaseFiles.js";
 const commitFlagSchema = {
-    dryRun: { long: '--dry-run', type: 'boolean' },
+    isDryRun: { long: '--dry-run', type: 'boolean' },
 };
 export function commitCommand(argv) {
-    const dryRun = parseArgsOrExit(argv, commitFlagSchema).flags.dryRun;
+    const isDryRun = parseArgsOrExit(argv, commitFlagSchema).flags.isDryRun;
     const tags = readReleaseTags();
     if (tags.length === 0) {
         throw new Error(`Tags file at ${resolveReleaseTagsPath()} is empty. Run \`release-kit prepare\` first.`);
@@ -24,7 +24,7 @@ export function commitCommand(argv) {
     }
     const title = `release: ${tags.join(' ')}`;
     const message = summary.length > 0 ? `${title}\n\n${summary}` : title;
-    if (dryRun) {
+    if (isDryRun) {
         console.info('[dry-run] Would create commit with message:\n');
         console.info(message);
         try {

package/dist/esm/compareVersions.js

@@ -13,13 +13,13 @@ function parseCanonicalSemver(version) {
     };
 }
 export function compareVersionsDescending(a, b) {
-    const aValid = semver.valid(a);
-    const bValid = semver.valid(b);
-    if (aValid && bValid)
-        return semver.rcompare(aValid, bValid);
-    if (aValid)
+    const aValidVersion = semver.valid(a);
+    const bValidVersion = semver.valid(b);
+    if (aValidVersion && bValidVersion)
+        return semver.rcompare(aValidVersion, bValidVersion);
+    if (aValidVersion)
         return -1;
-    if (bValid)
+    if (bValidVersion)
         return 1;
     if (a > b)
         return -1;
@@ -28,13 +28,13 @@ export function compareVersionsDescending(a, b) {
     return 0;
 }
 export function isForwardVersion(current, target) {
-    const currentParsed = parseCanonicalSemver(current);
-    const targetParsed = parseCanonicalSemver(target);
-    if (targetParsed.major !== currentParsed.major) {
-        return targetParsed.major > currentParsed.major;
+    const currentParsedVersion = parseCanonicalSemver(current);
+    const targetParsedVersion = parseCanonicalSemver(target);
+    if (targetParsedVersion.major !== currentParsedVersion.major) {
+        return targetParsedVersion.major > currentParsedVersion.major;
     }
-    if (targetParsed.minor !== currentParsed.minor) {
-        return targetParsed.minor > currentParsed.minor;
+    if (targetParsedVersion.minor !== currentParsedVersion.minor) {
+        return targetParsedVersion.minor > currentParsedVersion.minor;
     }
-    return targetParsed.patch > currentParsed.patch;
+    return targetParsedVersion.patch > currentParsedVersion.patch;
 }

package/dist/esm/configSchema.d.ts

@@ -93,7 +93,7 @@ export declare const changelogJsonInputSchema: z.ZodObject<{
 }, z.core.$strict>;
 /** Schema for the optional `changelogMarkdown` block (input shape, all fields optional). */
 export declare const changelogMarkdownInputSchema: z.ZodObject<{
-    keepVersions: z.ZodOptional<z.ZodNumber>;
+    keptVersionCount: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 /** Schema for the optional `releaseNotes` block (input shape, all fields optional). */
 export declare const releaseNotesInputSchema: z.ZodObject<{
@@ -164,7 +164,7 @@ export declare const releaseKitConfigSchema: z.ZodObject<{
         devOnlySections: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     changelogMarkdown: z.ZodOptional<z.ZodObject<{
-        keepVersions: z.ZodOptional<z.ZodNumber>;
+        keptVersionCount: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     formatCommand: z.ZodOptional<z.ZodString>;
     project: z.ZodOptional<z.ZodObject<{

package/dist/esm/configSchema.js

@@ -48,7 +48,7 @@ export const changelogJsonInputSchema = z
     .strict();
 export const changelogMarkdownInputSchema = z
     .object({
-    keepVersions: z.number().int().min(1).optional(),
+    keptVersionCount: z.number().int().min(1).optional(),
 })
     .strict();
 export const releaseNotesInputSchema = z

package/dist/esm/createGithubRelease.d.ts

@@ -2,7 +2,7 @@
 export interface CreateGithubReleaseOptions {
     tag: string;
     changelogJsonPath: string;
-    dryRun: boolean;
+    isDryRun: boolean;
     /** Section titles in priority order. When omitted, entry order is preserved. */
     sectionOrder?: string[];
 }
@@ -29,9 +29,9 @@ export declare function createGithubRelease(options: CreateGithubReleaseOptions)
 /** Outcome of a `createGithubReleases` invocation. */
 export interface CreateGithubReleasesOutcome {
     /** Tags for which a Release was created (or would be, under `--dry-run`). */
-    created: string[];
+    createdTags: string[];
     /** Tags that were skipped, paired with the discriminated reason for each skip. */
-    skipped: Array<{
+    skippedTags: Array<{
         tag: string;
         reason: CreateReleaseSkipReason;
     }>;
@@ -40,4 +40,4 @@ export interface CreateGithubReleasesOutcome {
 export declare function createGithubReleases(tags: Array<{
     tag: string;
     workspacePath: string;
-}>, changelogJsonOutputPath: string, dryRun: boolean, sectionOrder?: string[]): CreateGithubReleasesOutcome;
+}>, changelogJsonOutputPath: string, isDryRun: boolean, sectionOrder?: string[]): CreateGithubReleasesOutcome;

package/dist/esm/createGithubRelease.js

@@ -4,7 +4,7 @@ import { join } from 'node:path';
 import { extractVersion, readChangelogEntries } from "./changelogJsonUtils.js";
 import { matchesAudience, renderReleaseNotesSingle } from "./renderReleaseNotes.js";
 export function createGithubRelease(options) {
-    const { tag, changelogJsonPath, dryRun, sectionOrder } = options;
+    const { tag, changelogJsonPath, isDryRun, sectionOrder } = options;
     if (!existsSync(changelogJsonPath)) {
         console.warn(`Warning: ${changelogJsonPath} not found; skipping GitHub Release creation`);
         return { status: 'skipped', reason: 'no-entry' };
@@ -25,37 +25,37 @@ export function createGithubRelease(options) {
     }
     const body = renderReleaseNotesSingle(entry, {
         filter: matchesAudience('all'),
-        includeHeading: false,
+        shouldIncludeHeading: false,
         ...(sectionOrder !== undefined && { sectionOrder }),
     });
     if (body.trim() === '') {
         return { status: 'skipped', reason: 'empty-body' };
     }
     const args = ['release', 'create', tag, '--title', tag, '--notes', body];
-    if (dryRun) {
+    if (isDryRun) {
         console.info(`[dry-run] Would run: gh ${args.join(' ')}`);
         return { status: 'created' };
     }
     execFileSync('gh', args, { stdio: 'inherit' });
     return { status: 'created' };
 }
-export function createGithubReleases(tags, changelogJsonOutputPath, dryRun, sectionOrder) {
-    const created = [];
-    const skipped = [];
+export function createGithubReleases(tags, changelogJsonOutputPath, isDryRun, sectionOrder) {
+    const createdTags = [];
+    const skippedTags = [];
     for (const { tag, workspacePath } of tags) {
         const changelogJsonPath = join(workspacePath, changelogJsonOutputPath);
         const result = createGithubRelease({
             tag,
             changelogJsonPath,
-            dryRun,
+            isDryRun,
             ...(sectionOrder !== undefined && { sectionOrder }),
         });
         if (result.status === 'created') {
-            created.push(tag);
+            createdTags.push(tag);
         }
         else {
-            skipped.push({ tag, reason: result.reason });
+            skippedTags.push({ tag, reason: result.reason });
         }
     }
-    return { created, skipped };
+    return { createdTags, skippedTags };
 }

package/dist/esm/createGithubReleaseCommand.js

@@ -10,15 +10,15 @@ import { resolveCommandTags } from "./resolveCommandTags.js";
 import { resolveConfigFlag } from "./resolveConfigFlag.js";
 const createGithubReleaseFlagSchema = {
     ...configFlagSchema,
-    dryRun: { long: '--dry-run', type: 'boolean' },
+    isDryRun: { long: '--dry-run', type: 'boolean' },
     tags: { long: '--tags', type: 'string' },
 };
 export async function createGithubReleaseCommand(argv, styles, invocationDir) {
-    const parsed = parseArgsOrExit(argv, createGithubReleaseFlagSchema);
-    const configPath = resolveConfigFlag(parsed.flags.config, invocationDir);
-    const { dryRun } = parsed.flags;
+    const parsedArgs = parseArgsOrExit(argv, createGithubReleaseFlagSchema);
+    const configPath = resolveConfigFlag(parsedArgs.flags.config, invocationDir);
+    const { isDryRun } = parsedArgs.flags;
     const userConfig = await loadUsableConfig(styles.stderr, configPath);
-    const requestedTags = parseRequestedTags(parsed.flags.tags);
+    const requestedTags = parseRequestedTags(parsedArgs.flags.tags);
     const resolvedTags = resolveCommandTags(requestedTags, userConfig);
     const releasableTags = resolvedTags.filter(isReleasable);
     for (const resolvedTag of resolvedTags) {
@@ -32,17 +32,17 @@ export async function createGithubReleaseCommand(argv, styles, invocationDir) {
     const { changelogJsonOutputPath, sectionOrder } = deriveReleaseNotesConfig(userConfig);
     let outcome;
     try {
-        outcome = createGithubReleases(releasableTags, changelogJsonOutputPath, dryRun, sectionOrder);
+        outcome = createGithubReleases(releasableTags, changelogJsonOutputPath, isDryRun, sectionOrder);
     }
     catch (error) {
         reportError(`Failed to create GitHub Releases: ${describeError(error)}`);
         process.exit(1);
     }
-    if (outcome.skipped.length === 0) {
+    if (outcome.skippedTags.length === 0) {
         return;
     }
-    const formatted = outcome.skipped.map((s) => `${s.tag} (${s.reason})`).join(', ');
-    console.info(`Skipped ${outcome.skipped.length} tag(s) without releasable content: ${formatted}.`);
+    const formattedSkips = outcome.skippedTags.map((s) => `${s.tag} (${s.reason})`).join(', ');
+    console.info(`Skipped ${outcome.skippedTags.length} tag(s) without releasable content: ${formattedSkips}.`);
 }
 function isReleasable(resolvedTag) {
     return resolvedTag.kind !== 'package' || resolvedTag.isPublishable;

package/dist/esm/createTags.d.ts

@@ -1,7 +1,7 @@
 import { type OutputStyle } from '@williamthorsen/nmr-core';
 export interface CreateTagsOptions {
-    dryRun: boolean;
-    noGitChecks: boolean;
+    isDryRun: boolean;
+    shouldSkipGitChecks: boolean;
     style: OutputStyle;
 }
 /**

package/dist/esm/createTags.js

@@ -4,32 +4,32 @@ import { deleteFileIfExists } from "./deleteFileIfExists.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
 import { readReleaseTags, RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./releaseFiles.js";
 export function createTags(options) {
-    const { dryRun, noGitChecks, style } = options;
+    const { isDryRun, shouldSkipGitChecks, style } = options;
     const tags = readReleaseTags();
     if (tags.length === 0) {
         return [];
     }
-    if (!dryRun && !noGitChecks) {
+    if (!isDryRun && !shouldSkipGitChecks) {
         assertCleanWorkingTree();
     }
-    if (dryRun) {
+    if (isDryRun) {
         console.info('[dry-run] Would create tags:');
         for (const tag of tags) {
             console.info(formatGlyphLine(RELEASE_GLYPHS, style, 'tag', tag));
         }
         return tags;
     }
-    const created = [];
+    const createdTags = [];
     for (const tag of tags) {
         try {
             execFileSync('git', ['tag', '-a', tag, '-m', tag], { maxBuffer: GIT_OUTPUT_LIMIT_BYTES });
-            created.push(tag);
+            createdTags.push(tag);
         }
         catch (error) {
-            if (created.length > 0) {
+            if (createdTags.length > 0) {
                 console.warn('Tags created before failure:');
-                for (const t of created) {
-                    console.warn(`  ${t}`);
+                for (const tag of createdTags) {
+                    console.warn(`  ${tag}`);
                 }
             }
             throw error;

package/dist/esm/decideDirectReleases.d.ts

@@ -13,13 +13,13 @@ export interface DirectReleases {
     untaggedBaselines: Map<string, UntaggedBaseline>;
 }
 /**
- * Reads each planned package and directory target's history and decides its direct release. `force` applies only to
+ * Reads each planned package and directory target's history and decides its direct release. `shouldForce` applies only to
  * the targets from which the release starts.
  */
-export declare function decideDirectReleases(planned: readonly MemberTarget[], settings: TargetPrepareSettings, options: {
-    force?: boolean;
+export declare function decideDirectReleases(plannedTargets: readonly MemberTarget[], settings: TargetPrepareSettings, options: {
+    shouldForce?: boolean;
     bumpOverride?: ReleaseType;
-    setVersions?: ReadonlyMap<string, string>;
+    versionOverridesById?: ReadonlyMap<string, string>;
 }, startIds: ReadonlySet<string>): DirectReleases;
 /**
  * Records on each planned workspace's and directory's history the entry scopes that route nowhere in its unreleased
@@ -27,4 +27,4 @@ export declare function decideDirectReleases(planned: readonly MemberTarget[], s
  * targets first, in planned order, which sets the order of each target's findings. The repo-root directory target
  * renders every entry in its window, so it records none, but its window still routes the scope that names it.
  */
-export declare function reportUnroutedEntryScopes(planned: readonly MemberTarget[], direct: DirectReleases, settings: TargetPrepareSettings, memberTargets: readonly MemberTarget[]): void;
+export declare function reportUnroutedEntryScopes(plannedTargets: readonly MemberTarget[], directReleases: DirectReleases, settings: TargetPrepareSettings, memberTargets: readonly MemberTarget[]): void;

package/dist/esm/decideDirectReleases.js

@@ -3,64 +3,64 @@ import { findUnroutedEntryScopes } from "./findUnroutedEntryScopes.js";
 import { getAllTagPrefixes } from "./generateChangelogs.js";
 import { describeStage, isRepoRootTarget, readHistory, runStage } from "./prepareRunContext.js";
 import { decideTargetRelease, readTargetHistory, } from "./prepareTarget.js";
-export function decideDirectReleases(planned, settings, options, startIds) {
-    const { force, bumpOverride, setVersions } = options;
-    const direct = {
+export function decideDirectReleases(plannedTargets, settings, options, startIds) {
+    const { shouldForce, bumpOverride, versionOverridesById } = options;
+    const directReleases = {
         readings: new Map(),
         decisions: new Map(),
         bumps: new Map(),
         untaggedBaselines: new Map(),
     };
     const hintState = { emitted: false };
-    const knownPrefixes = planned.flatMap(getAllTagPrefixes);
-    for (const target of planned) {
-        const { history, untagged } = runStage(describeStage(target), () => readTargetHistory(target, settings));
-        direct.readings.set(target.id, history);
-        if (untagged !== undefined) {
-            direct.untaggedBaselines.set(target.id, untagged);
+    const knownPrefixes = plannedTargets.flatMap(getAllTagPrefixes);
+    for (const target of plannedTargets) {
+        const { history, untaggedBaseline } = runStage(describeStage(target), () => readTargetHistory(target, settings));
+        directReleases.readings.set(target.id, history);
+        if (untaggedBaseline !== undefined) {
+            directReleases.untaggedBaselines.set(target.id, untaggedBaseline);
         }
         if (history.previousTag === undefined && target.kind === 'package' && target.isWorkspace) {
-            maybeEmitBaselineHint(target, knownPrefixes, hintState);
+            emitBaselineHintOnce(target, knownPrefixes, hintState);
         }
-        const setVersion = setVersions?.get(target.id);
+        const versionOverride = versionOverridesById?.get(target.id);
         const decision = decideTargetRelease(target, history, {
-            force: force === true && startIds.has(target.id),
+            shouldForce: shouldForce === true && startIds.has(target.id),
             bumpOverride,
-            setVersion,
+            setVersion: versionOverride,
         });
-        direct.decisions.set(target.id, decision);
+        directReleases.decisions.set(target.id, decision);
         if (decision.outcome === 'skip') {
             continue;
         }
-        direct.bumps.set(target.id, decision.setVersion === undefined
+        directReleases.bumps.set(target.id, decision.setVersion === undefined
             ? { releaseType: decision.releaseType }
             : { releaseType: 'patch', newVersionOverride: decision.setVersion });
     }
-    return direct;
+    return directReleases;
 }
-export function reportUnroutedEntryScopes(planned, direct, settings, memberTargets) {
-    const releasing = planned.filter((target) => direct.decisions.get(target.id)?.outcome === 'release');
-    const windows = [...releasing, ...planned.filter((target) => !releasing.includes(target))].map((target) => ({
+export function reportUnroutedEntryScopes(plannedTargets, directReleases, settings, memberTargets) {
+    const releasingTargets = plannedTargets.filter((target) => directReleases.decisions.get(target.id)?.outcome === 'release');
+    const windows = [...releasingTargets, ...plannedTargets.filter((target) => !releasingTargets.includes(target))].map((target) => ({
         target,
-        history: readHistory(direct.readings, target),
+        history: readHistory(directReleases.readings, target),
     }));
-    const findings = findUnroutedEntryScopes(windows.map(({ target, history }) => ({ dir: target.id, commits: history.unreleased.commits })), memberTargets.map((target) => target.id), settings.scopeAliases ?? {});
+    const findings = findUnroutedEntryScopes(windows.map(({ target, history }) => ({ dir: target.id, commits: history.unreleasedReading.commits })), memberTargets.map((target) => target.id), settings.scopeAliases ?? {});
     for (const { target, history } of windows) {
-        history.unreleased.diagnostics.unroutedEntryScopes = isRepoRootTarget(target)
+        history.unreleasedReading.diagnostics.unroutedEntryScopes = isRepoRootTarget(target)
             ? []
             : (findings.get(target.id) ?? []);
     }
 }
-function maybeEmitBaselineHint(target, knownPrefixes, state) {
+function emitBaselineHintOnce(target, knownPrefixes, state) {
     if (state.emitted || (target.legacyIdentities?.length ?? 0) > 0)
         return;
     const candidates = detectUndeclaredTagPrefixes(knownPrefixes);
     if (candidates.length === 0)
         return;
     const totalTags = candidates.reduce((sum, candidate) => sum + candidate.tagCount, 0);
-    const example = candidates[0]?.exampleTags[0] ?? `${candidates[0]?.prefix ?? ''}?`;
+    const exampleTag = candidates[0]?.exampleTags[0] ?? `${candidates[0]?.prefix ?? ''}?`;
     process.stderr.write(`Hint: no baseline tag found for ${target.id} under '${target.tagPrefix}', but ` +
-        `${totalTags} candidate-shaped tags exist (e.g., ${example}). ` +
+        `${totalTags} candidate-shaped tags exist (e.g., ${exampleTag}). ` +
         "Run 'release-kit show-tag-prefixes' to check for undeclared legacy prefixes.\n");
     state.emitted = true;
 }

package/dist/esm/decideRelease.d.ts

@@ -6,7 +6,7 @@ export interface DecideReleaseArgs {
     /** The number of commits in the window, which selects the skip reason. */
     commitCount: number;
     /** True when `--force` was passed; treats absence of a natural bump as patch. Defaults to false. */
-    force?: boolean | undefined;
+    shouldForce?: boolean | undefined;
     /** Explicit `--bump=X` override. When set, the level is X regardless of the natural bump. */
     bumpOverride: ReleaseType | undefined;
     /**

package/dist/esm/decideRelease.js

@@ -1,6 +1,6 @@
 export function decideRelease(args) {
-    const { naturalBump, commitCount, force = false, bumpOverride, skipReasons } = args;
-    if (naturalBump === undefined && !force) {
+    const { naturalBump, commitCount, shouldForce = false, bumpOverride, skipReasons } = args;
+    if (naturalBump === undefined && !shouldForce) {
         const skipReason = commitCount === 0 ? skipReasons.noCommits : skipReasons.noBumpWorthy;
         return { outcome: 'skip', skipReason };
     }

package/dist/esm/deriveDirectoryConfig.d.ts

@@ -10,4 +10,4 @@ export declare const DIRECTORY_VERSION_FILE = "version.json";
  * repo root. Throws when the path isn't a directory, when the version file is missing or lacks a `version`, and when
  * the basename would not make a valid tag prefix.
  */
-export declare function deriveDirectoryConfig(declared: DeclaredDirectory, root?: string): DirectoryConfig;
+export declare function deriveDirectoryConfig(declaredDirectory: DeclaredDirectory, root?: string): DirectoryConfig;

package/dist/esm/deriveDirectoryConfig.js

@@ -4,24 +4,24 @@ import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
 import { isRecord } from "./typeGuards.js";
 export const DIRECTORY_VERSION_FILE = 'version.json';
 const TAG_PREFIX_PATTERN = /^[\w.-]+$/;
-export function deriveDirectoryConfig(declared, root = process.cwd()) {
-    const label = `releases.${declared.name}`;
-    if (statSync(path.resolve(root, declared.path), { throwIfNoEntry: false })?.isDirectory() !== true) {
-        throw new Error(`${label}: path '${declared.path}' is not a directory; declare a directory that exists in the repo`);
+export function deriveDirectoryConfig(declaredDirectory, root = process.cwd()) {
+    const label = `releases.${declaredDirectory.name}`;
+    if (statSync(path.resolve(root, declaredDirectory.path), { throwIfNoEntry: false })?.isDirectory() !== true) {
+        throw new Error(`${label}: path '${declaredDirectory.path}' is not a directory; declare a directory that exists in the repo`);
     }
-    const versionFile = resolveVersionFile(declared.path, root);
+    const versionFile = resolveVersionFile(declaredDirectory.path, root);
     assertVersionField(label, versionFile, root);
     const config = {
-        name: declared.name,
-        path: declared.path,
+        name: declaredDirectory.name,
+        path: declaredDirectory.path,
         versionFile,
-        tagPrefix: declared.tagPrefix ?? deriveTagPrefix(label, declared.path),
+        tagPrefix: declaredDirectory.tagPrefix ?? deriveTagPrefix(label, declaredDirectory.path),
     };
-    if (declared.paths !== undefined) {
-        config.paths = [...declared.paths];
+    if (declaredDirectory.paths !== undefined) {
+        config.paths = [...declaredDirectory.paths];
     }
-    if (declared.legacyIdentities !== undefined) {
-        config.legacyIdentities = declared.legacyIdentities;
+    if (declaredDirectory.legacyIdentities !== undefined) {
+        config.legacyIdentities = declaredDirectory.legacyIdentities;
     }
     return config;
 }
@@ -30,14 +30,14 @@ function assertVersionField(label, versionFile, root) {
     if (!existsSync(absolutePath)) {
         throw new Error(`${label}: ${versionFile} not found; create it with the directory's current version, such as { "version": "0.0.0" }`);
     }
-    let parsed;
+    let parsedJson;
     try {
-        parsed = JSON.parse(readFileSync(absolutePath, 'utf8'));
+        parsedJson = JSON.parse(readFileSync(absolutePath, 'utf8'));
     }
     catch (error) {
         throw chainError(`${label}: failed to read ${versionFile}`, error);
     }
-    if (!isRecord(parsed) || typeof parsed['version'] !== 'string') {
+    if (!isRecord(parsedJson) || typeof parsedJson['version'] !== 'string') {
         throw new Error(`${label}: ${versionFile} does not contain a string 'version' field; add one`);
     }
 }
@@ -52,8 +52,8 @@ function deriveTagPrefix(label, directoryPath) {
     return `${basename}-v`;
 }
 function resolveVersionFile(directoryPath, root) {
-    const packageJson = path.posix.join(directoryPath, 'package.json');
-    return existsSync(path.resolve(root, packageJson))
-        ? packageJson
+    const packageJsonPath = path.posix.join(directoryPath, 'package.json');
+    return existsSync(path.resolve(root, packageJsonPath))
+        ? packageJsonPath
         : path.posix.join(directoryPath, DIRECTORY_VERSION_FILE);
 }

package/dist/esm/deriveWorkspaceConfig.js

@@ -6,19 +6,19 @@ import { isRecord } from "./typeGuards.js";
 export function deriveWorkspaceConfig(workspacePath) {
     const dir = basename(workspacePath);
     const packageJsonPath = `${workspacePath}/package.json`;
-    let parsed;
+    let parsedJson;
     try {
-        parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        parsedJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
     }
     catch (error) {
         throw chainError(`Failed to read ${packageJsonPath}`, error);
     }
-    const name = isRecord(parsed) ? parsed['name'] : undefined;
+    const name = isRecord(parsedJson) ? parsedJson['name'] : undefined;
     if (typeof name !== 'string' || name.length === 0) {
         throw new Error(`${packageJsonPath} is missing a 'name' field (required for tag derivation).`);
     }
     const unscopedName = stripNpmScope(name);
-    const isPublishable = isPublishableManifest(parsed);
+    const isPublishable = isPublishableManifest(parsedJson);
     return {
         dir,
         name,

package/dist/esm/detectPackageManager.js

@@ -5,9 +5,9 @@ export function detectPackageManager() {
     const packageJsonPath = join(process.cwd(), 'package.json');
     try {
         const content = readFileSync(packageJsonPath, 'utf8');
-        const parsed = JSON.parse(content);
-        if (isRecord(parsed) && typeof parsed['packageManager'] === 'string') {
-            const [name, version] = parsed['packageManager'].split('@', 2);
+        const parsedJson = JSON.parse(content);
+        if (isRecord(parsedJson) && typeof parsedJson['packageManager'] === 'string') {
+            const [name, version] = parsedJson['packageManager'].split('@', 2);
             if (name === 'pnpm' || name === 'npm') {
                 return name;
             }
@@ -24,8 +24,8 @@ function isYarnBerry(version) {
     if (version === undefined) {
         return false;
     }
-    const major = Number.parseInt(version, 10);
-    return !Number.isNaN(major) && major >= 2;
+    const majorVersion = Number.parseInt(version, 10);
+    return !Number.isNaN(majorVersion) && majorVersion >= 2;
 }
 function detectFromLockfile() {
     const cwd = process.cwd();

package/dist/esm/detectUndeclaredTagPrefixes.js

@@ -3,7 +3,7 @@ import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
 const EXAMPLE_TAG_LIMIT = 3;
 const CANDIDATE_TAG_PATTERN = /^(?<prefix>[a-z][a-z0-9-]*-v)\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/;
 export function detectUndeclaredTagPrefixes(knownPrefixes) {
-    const known = new Set(knownPrefixes);
+    const knownPrefixSet = new Set(knownPrefixes);
     let rawOutput;
     try {
         rawOutput = execFileSync('git', ['tag', '--list'], {
@@ -15,7 +15,7 @@ export function detectUndeclaredTagPrefixes(knownPrefixes) {
     catch {
         return [];
     }
-    const grouped = new Map();
+    const tagsByPrefix = new Map();
     for (const line of rawOutput.split('\n')) {
         const tag = line.trim();
         if (tag === '')
@@ -24,17 +24,17 @@ export function detectUndeclaredTagPrefixes(knownPrefixes) {
         if (match === null)
             continue;
         const prefix = match.groups?.['prefix'] ?? '';
-        if (prefix === '' || known.has(prefix))
+        if (prefix === '' || knownPrefixSet.has(prefix))
             continue;
-        let tags = grouped.get(prefix);
+        let tags = tagsByPrefix.get(prefix);
         if (tags === undefined) {
             tags = [];
-            grouped.set(prefix, tags);
+            tagsByPrefix.set(prefix, tags);
         }
         tags.push(tag);
     }
     const results = [];
-    for (const [prefix, tags] of grouped) {
+    for (const [prefix, tags] of tagsByPrefix) {
         results.push({
             prefix,
             tagCount: tags.length,

package/dist/esm/enumerateReleaseWindows.d.ts

@@ -14,7 +14,7 @@ export interface ReleaseWindow {
     /** The tag name for a released window, the caller's unreleased-tag name for the newest one. */
     version: string;
     /** Unix seconds: the tag's creation date for a released window, the clock for the unreleased one. */
-    timestamp: number;
+    timestampSec: number;
     /** Oldest first. */
     commits: RawCommit[];
 }

package/dist/esm/enumerateReleaseWindows.js

@@ -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);