@williamthorsen/release-kit 14.2.1 → 14.2.3

package/dist/esm/prepareArgs.d.ts

@@ -0,0 +1,55 @@
+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: {
+        long: string;
+        type: "boolean";
+    };
+    force: {
+        long: string;
+        type: "boolean";
+    };
+    noGitChecks: {
+        long: string;
+        type: "boolean";
+        short: string;
+    };
+    bump: {
+        long: string;
+        type: "string";
+    };
+    setVersion: {
+        long: string;
+        type: "string";
+    };
+    only: {
+        long: string;
+        type: "string";
+    };
+    withReleaseNotes: {
+        long: string;
+        type: "boolean";
+    };
+    config: {
+        long: string;
+        type: "string";
+    };
+};
+/** 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;
+    bumpOverride: ReleaseType | undefined;
+    only: string[] | undefined;
+    /** The raw `--set-version` value, whose accepted form depends on the mode. */
+    setVersion: string | undefined;
+    withReleaseNotes: boolean;
+};
+/**
+ * Parses a monorepo `--set-version` value, a comma-separated list of `<target>@N.N.N` entries, into versions keyed by
+ * target name. Prints a usage error and exits on a malformed entry, an unknown target, or a repeated one.
+ */
+export declare function parseSetVersions(value: string, knownNames: readonly string[]): Map<string, string>;

package/dist/esm/prepareArgs.js

@@ -0,0 +1,69 @@
+import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
+import { configFlagSchema } from "./configFlagSchema.js";
+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: {
+        long: '--no-git-checks',
+        type: 'boolean',
+        short: '-n',
+    },
+    bump: { long: '--bump', type: 'string' },
+    setVersion: { long: '--set-version', type: 'string' },
+    only: { long: '--only', type: 'string' },
+    withReleaseNotes: { long: '--with-release-notes', type: 'boolean' },
+};
+export function parseArgs(argv) {
+    const { flags } = parseArgsOrExit(argv, prepareFlagSchema);
+    let bumpOverride;
+    if (flags.bump !== undefined) {
+        if (!isReleaseType(flags.bump)) {
+            reportError(`Invalid bump type "${flags.bump}". Must be one of: ${VALID_BUMP_TYPES.join(', ')}`);
+            process.exit(1);
+        }
+        bumpOverride = flags.bump;
+    }
+    let only;
+    if (flags.only !== undefined) {
+        only = flags.only.split(',');
+    }
+    return {
+        configPath: flags.config,
+        dryRun: flags.dryRun,
+        force: flags.force,
+        noGitChecks: flags.noGitChecks,
+        bumpOverride,
+        only,
+        setVersion: flags.setVersion,
+        withReleaseNotes: flags.withReleaseNotes,
+    };
+}
+export function parseSetVersions(value, knownNames) {
+    const setVersions = new Map();
+    for (const entry of value.split(',')) {
+        const separatorIndex = entry.lastIndexOf('@');
+        const name = entry.slice(0, Math.max(0, separatorIndex));
+        const version = entry.slice(separatorIndex + 1);
+        if (separatorIndex <= 0 || !CANONICAL_SEMVER_PATTERN.test(version)) {
+            reportError(`Invalid --set-version entry "${entry}". In monorepo mode, each entry must be <target>@N.N.N ` +
+                '(canonical semver, no pre-release suffix), e.g. --set-version=arrays@1.0.0.');
+            process.exit(1);
+        }
+        if (!knownNames.includes(name)) {
+            reportError(`Unknown release target "${name}" in --set-version. Known targets: ${knownNames.join(', ')}`);
+            process.exit(1);
+        }
+        if (setVersions.has(name)) {
+            reportError(`--set-version names target "${name}" more than once`);
+            process.exit(1);
+        }
+        setVersions.set(name, version);
+    }
+    return setVersions;
+}
+function isReleaseType(value) {
+    return VALID_BUMP_TYPES.includes(value);
+}

package/dist/esm/prepareCommand.d.ts

@@ -1,52 +1,4 @@
 import { type StreamStyles } from '@williamthorsen/nmr-core';
-import type { ReleaseType } from './types.js';
-export declare const prepareFlagSchema: {
-    dryRun: {
-        long: string;
-        type: "boolean";
-    };
-    force: {
-        long: string;
-        type: "boolean";
-    };
-    noGitChecks: {
-        long: string;
-        type: "boolean";
-        short: string;
-    };
-    bump: {
-        long: string;
-        type: "string";
-    };
-    setVersion: {
-        long: string;
-        type: "string";
-    };
-    only: {
-        long: string;
-        type: "string";
-    };
-    withReleaseNotes: {
-        long: string;
-        type: "boolean";
-    };
-    config: {
-        long: string;
-        type: "string";
-    };
-};
-/** 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;
-    bumpOverride: ReleaseType | undefined;
-    only: string[] | undefined;
-    /** The raw `--set-version` value, whose accepted form depends on the mode. */
-    setVersion: string | undefined;
-    withReleaseNotes: boolean;
-};
 /**
  * Orchestrates the CLI `prepare` command: checks the working tree, loads and validates the config, discovers the
  * workspaces, and prepares the release over the targets of the repo shape.

package/dist/esm/prepareCommand.js

@@ -1,63 +1,19 @@
 import { execSync } from 'node:child_process';
-import { formatGlyphLine, parseArgsOrExit, reportError, } from '@williamthorsen/nmr-core';
+import { formatGlyphLine, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
 import { assertReleasesOnNpm } from "./assertReleasesOnNpm.js";
-import { configFlagSchema } from "./configFlagSchema.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 { 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";
-const VALID_BUMP_TYPES = ['major', 'minor', 'patch'];
-const CANONICAL_SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
-function isReleaseType(value) {
-    return VALID_BUMP_TYPES.includes(value);
-}
-export const prepareFlagSchema = {
-    ...configFlagSchema,
-    dryRun: { long: '--dry-run', type: 'boolean' },
-    force: { long: '--force', type: 'boolean' },
-    noGitChecks: {
-        long: '--no-git-checks',
-        type: 'boolean',
-        short: '-n',
-    },
-    bump: { long: '--bump', type: 'string' },
-    setVersion: { long: '--set-version', type: 'string' },
-    only: { long: '--only', type: 'string' },
-    withReleaseNotes: { long: '--with-release-notes', type: 'boolean' },
-};
-export function parseArgs(argv) {
-    const { flags } = parseArgsOrExit(argv, prepareFlagSchema);
-    let bumpOverride;
-    if (flags.bump !== undefined) {
-        if (!isReleaseType(flags.bump)) {
-            reportError(`Invalid bump type "${flags.bump}". Must be one of: ${VALID_BUMP_TYPES.join(', ')}`);
-            process.exit(1);
-        }
-        bumpOverride = flags.bump;
-    }
-    let only;
-    if (flags.only !== undefined) {
-        only = flags.only.split(',');
-    }
-    return {
-        configPath: flags.config,
-        dryRun: flags.dryRun,
-        force: flags.force,
-        noGitChecks: flags.noGitChecks,
-        bumpOverride,
-        only,
-        setVersion: flags.setVersion,
-        withReleaseNotes: flags.withReleaseNotes,
-    };
-}
 export async function prepareCommand(argv, styles, invocationDir) {
     const { configPath: configFlag, dryRun, force, noGitChecks, bumpOverride, only, setVersion, withReleaseNotes, } = parseArgs(argv);
     const options = {
@@ -112,8 +68,8 @@ export async function prepareCommand(argv, styles, invocationDir) {
     }, dryRun, 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] : []);
+    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) {
     if (discovery.kind === 'single-package') {
@@ -159,33 +115,10 @@ function resolveSetVersions(setVersion, targets) {
     return parseSetVersions(setVersion, listMemberIds(targets));
 }
 function listSelectableIds(targets) {
-    return targets.flatMap((target) => (target.id === PROJECT_TARGET_ID ? [] : [target.id]));
+    return targets.flatMap((target) => (target.id === PROJECT_TARGET_ID ? [] : target.id));
 }
 function listMemberIds(targets) {
-    return targets.flatMap((target) => (target.kind === 'composite' ? [] : [target.id]));
-}
-function parseSetVersions(value, knownNames) {
-    const setVersions = new Map();
-    for (const entry of value.split(',')) {
-        const separatorIndex = entry.lastIndexOf('@');
-        const name = entry.slice(0, Math.max(0, separatorIndex));
-        const version = entry.slice(separatorIndex + 1);
-        if (separatorIndex <= 0 || !CANONICAL_SEMVER_PATTERN.test(version)) {
-            reportError(`Invalid --set-version entry "${entry}". In monorepo mode, each entry must be <target>@N.N.N ` +
-                '(canonical semver, no pre-release suffix), e.g. --set-version=arrays@1.0.0.');
-            process.exit(1);
-        }
-        if (!knownNames.includes(name)) {
-            reportError(`Unknown release target "${name}" in --set-version. Known targets: ${knownNames.join(', ')}`);
-            process.exit(1);
-        }
-        if (setVersions.has(name)) {
-            reportError(`--set-version names target "${name}" more than once`);
-            process.exit(1);
-        }
-        setVersions.set(name, version);
-    }
-    return setVersions;
+    return targets.flatMap((target) => (target.kind === 'composite' ? [] : target.id));
 }
 function runAndReport(computePlan, dryRun, style) {
     let plan;
@@ -212,11 +145,12 @@ function runAndReport(computePlan, dryRun, style) {
     const formatError = runFormatCommand(plan.formatCommand);
     process.stdout.write(reportPrepare(plan, { applied: true, style, ...(formatError !== undefined && { formatError }) }) + '\n');
     reportPlanFiles(plan, false);
-    if (formatError !== undefined) {
-        reportError(`The format command failed, but the release is prepared and ${RELEASE_TAGS_FILE} is written. ` +
-            `Format the release files and run 'release-kit commit'.`);
-        process.exit(1);
+    if (formatError === undefined) {
+        return;
     }
+    reportError(`The format command failed, but the release is prepared and ${RELEASE_TAGS_FILE} is written. ` +
+        `Format the release files and run 'release-kit commit'.`);
+    process.exit(1);
 }
 function runFormatCommand(formatCommand) {
     if (formatCommand === undefined) {

package/dist/esm/prepareComposite.d.ts

@@ -0,0 +1,16 @@
+import { type CollectedReleases, type RunContext } from './prepareRunContext.js';
+import type { CompositeTarget, ReleaseType, TargetPrepareResult } from './types.js';
+/**
+ * Describes why a run narrowed by `only` skips a composite and how to include it, or returns `undefined` when the run
+ * prepares it: every run that `only` doesn't narrow, and every one that names it. A `project` block's composite
+ * cannot be named.
+ */
+export declare function describeCompositeSkip(composite: CompositeTarget, only: readonly string[] | undefined): string | undefined;
+/**
+ * Prepares a composite target: reads its history, asserts its baseline, and decides and plans its release, appending
+ * its tag, writes, and modified files to the run's collection and its preview warnings to `warnings`.
+ */
+export declare function prepareComposite(composite: CompositeTarget, context: RunContext, options: {
+    force?: boolean;
+    bumpOverride?: ReleaseType;
+}, collected: CollectedReleases, warnings: string[]): TargetPrepareResult;

package/dist/esm/prepareComposite.js

@@ -0,0 +1,39 @@
+import { assertTaggedBaseline } from "./assertTaggedBaseline.js";
+import { collect } from "./prepareRunContext.js";
+import { buildSkippedTargetResult, decideTargetRelease, planTargetRelease, readTargetHistory, } from "./prepareTarget.js";
+import { PROJECT_TARGET_ID } from "./resolveReleaseTargets.js";
+export function describeCompositeSkip(composite, only) {
+    if (only === undefined || only.includes(composite.id)) {
+        return undefined;
+    }
+    if (composite.id === PROJECT_TARGET_ID) {
+        return (`Project release skipped: --only narrows this run to ${only.join(', ')}. ` +
+            'Run `release-kit prepare` without --only to include the project release.');
+    }
+    return `Release '${composite.id}' skipped: --only does not name it. Add ${composite.id} to --only to include it.`;
+}
+export function prepareComposite(composite, context, options, collected, warnings) {
+    const { history, untagged } = readTargetHistory(composite, context.settings);
+    assertTaggedBaseline([untagged]);
+    const decision = decideTargetRelease(composite, history, {
+        force: options.force === true,
+        bumpOverride: options.bumpOverride,
+        setVersion: undefined,
+    });
+    if (decision.outcome === 'skip') {
+        return buildSkippedTargetResult(composite, history, decision.skipReason);
+    }
+    if (decision.setVersion !== undefined) {
+        throw new Error('A composite target cannot take --set-version');
+    }
+    const planned = planTargetRelease({
+        ...context,
+        target: composite,
+        release: { releaseType: decision.releaseType },
+        decision,
+        history,
+    });
+    collect(collected, planned);
+    warnings.push(...planned.warnings);
+    return planned.result;
+}

package/dist/esm/prepareRunContext.d.ts

@@ -0,0 +1,38 @@
+import type { ReleaseHistory } from './buildChangelogEntries.js';
+import type { OverrideContext } from './changelogOverrides.js';
+import { type TargetPrepareSettings } from './prepareTarget.js';
+import type { PlannedWrite } from './releasePlan.js';
+import type { DirectoryTarget, PackageTarget, ReleaseTarget } from './types.js';
+/** Appends one planned release's tag, writes, removals, and modified files to the run's collection. */
+export declare function collect(collected: CollectedReleases, planned: {
+    tag: string;
+    writes: PlannedWrite[];
+    removals: string[];
+    modifiedFiles: string[];
+}): void;
+/** The tags, writes, removals, and modified files of the run's releases, in the order in which they were planned. */
+export interface CollectedReleases {
+    tags: string[];
+    writes: PlannedWrite[];
+    removals: string[];
+    modifiedFiles: string[];
+}
+/** Names the stage whose errors a target's work raises; the single-package root's errors are not labeled. */
+export declare function describeStage(target: ReleaseTarget): string | undefined;
+/** Reports whether a target is the directory target of the repo root, whose window is the whole repo. */
+export declare function isRepoRootTarget(target: MemberTarget): boolean;
+/** A target that releases on its own window and takes part in selection: a package or a directory. */
+export type MemberTarget = PackageTarget | DirectoryTarget;
+/** Returns the history that the direct-release pass read for a planned target. */
+export declare function readHistory(readings: ReadonlyMap<string, ReleaseHistory>, target: MemberTarget): ReleaseHistory;
+/** What every target's planning reads from the run. */
+export interface RunContext {
+    settings: TargetPrepareSettings;
+    overrideContext: OverrideContext;
+    sectionOrder: string[];
+    dependenciesHeader: string;
+    shouldPlanPreviews: boolean;
+    today: string;
+}
+/** Runs `fn`, rethrowing any thrown value behind the stage label as `<stage>: …`; runs it unlabeled without one. */
+export declare function runStage<T>(stage: string | undefined, fn: () => T): T;

package/dist/esm/prepareRunContext.js

@@ -0,0 +1,39 @@
+import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
+import { isRepoRoot } from "./prepareTarget.js";
+export function collect(collected, planned) {
+    collected.tags.push(planned.tag);
+    collected.writes.push(...planned.writes);
+    collected.removals.push(...planned.removals);
+    collected.modifiedFiles.push(...planned.modifiedFiles);
+}
+export function describeStage(target) {
+    switch (target.kind) {
+        case 'composite':
+            return 'project release stage';
+        case 'directory':
+            return `directory '${target.id}' release stage`;
+        case 'package':
+            return target.isWorkspace ? `workspace '${target.id}' release stage` : undefined;
+    }
+}
+export function isRepoRootTarget(target) {
+    return target.kind === 'directory' && isRepoRoot(target);
+}
+export function readHistory(readings, target) {
+    const history = readings.get(target.id);
+    if (history === undefined) {
+        throw new Error(`Target '${target.id}' was planned without a history`);
+    }
+    return history;
+}
+export function runStage(stage, fn) {
+    if (stage === undefined) {
+        return fn();
+    }
+    try {
+        return fn();
+    }
+    catch (error) {
+        throw chainError(stage, error);
+    }
+}

package/dist/esm/prepareTarget.d.ts

@@ -1,9 +1,10 @@
 import { type UntaggedBaseline } from './assertTaggedBaseline.js';
 import { type ReleaseHistory } from './buildChangelogEntries.js';
+import { type TargetRelease } from './buildReleasedResult.js';
 import { type OverrideContext } from './changelogOverrides.js';
 import { type GenerateChangelogOptions } from './generateChangelogs.js';
 import type { PlannedWrite } from './releasePlan.js';
-import type { DirectoryTarget, PropagationSource, ReleasedTargetResult, ReleaseSettings, ReleaseTarget, ReleaseType, TargetPrepareResult } from './types.js';
+import type { DirectoryTarget, ReleasedTargetResult, ReleaseSettings, ReleaseTarget, ReleaseType, TargetPrepareResult } from './types.js';
 /** The shared settings that the prepare step reads, which do not include the release-notes settings. */
 export type TargetPrepareSettings = Omit<ReleaseSettings, 'releaseNotes'>;
 /** One read of a target's release windows, and the untagged baseline that it found, if any. */
@@ -26,12 +27,6 @@ export type TargetDecision = {
     outcome: 'skip';
     skipReason: string;
 };
-/** The release level that a target takes, whether its own commits or a dependency's bump decided it. */
-export interface TargetRelease {
-    releaseType: ReleaseType;
-    /** Dependencies whose bumps this release records; present for a propagated or mixed release. */
-    propagatedFrom?: PropagationSource[];
-}
 /** Inputs to {@link planTargetRelease}. */
 export interface PlanTargetReleaseArgs {
     target: ReleaseTarget;

package/dist/esm/prepareTarget.js

@@ -1,17 +1,13 @@
-import { join as joinPath } from 'node:path';
 import { findUntaggedBaseline } from "./assertTaggedBaseline.js";
 import { attachChangelogDiagnostics } from "./attachChangelogDiagnostics.js";
 import { readReleaseHistory, toReleaseEntries } from "./buildChangelogEntries.js";
-import { buildSyntheticChangelogEntry } from "./buildSyntheticChangelogEntry.js";
-import { describeArchivePath, listArchiveFiles } from "./changelogArchive.js";
-import { mergeChangelogEntriesWithDisk, renderChangelogJson, resolveChangelogJsonPath } from "./changelogJsonFile.js";
+import { buildPropagationEntries, buildReleasedResult } from "./buildReleasedResult.js";
 import { applyWorkspaceOverrides } from "./changelogOverrides.js";
 import { decideRelease } from "./decideRelease.js";
 import { getAllTagPrefixes } from "./generateChangelogs.js";
+import { planChangelogFiles } from "./planChangelogFiles.js";
 import { planReleaseNotesPreviews } from "./planReleaseNotesPreviews.js";
 import { planVersionBump, planVersionSet } from "./planVersionBump.js";
-import { planPreservedSections } from "./readChangelogSections.js";
-import { renderChangelogFiles } from "./renderChangelogMarkdown.js";
 import { PROJECT_TARGET_ID } from "./resolveReleaseTargets.js";
 export function readTargetHistory(target, settings) {
     const options = describeHistoryWindow(target);
@@ -124,82 +120,6 @@ export function buildSkippedTargetResult(target, history, skipReason) {
 export function isRepoRoot(target) {
     return target.directoryPath === '.';
 }
-function buildReleasedDirectory(target, fields, release, decision, history) {
-    const { unreleased } = history;
-    const setVersion = decision?.setVersion;
-    const result = {
-        ...fields,
-        status: 'released',
-        kind: 'directory',
-        name: target.id,
-        commits: unreleased.commits,
-        ...(setVersion === undefined && {
-            releaseType: release.releaseType,
-            parsedCommitCount: unreleased.parsedCommitCount,
-        }),
-        ...(decision?.bumpOverride !== undefined && { bumpOverride: decision.bumpOverride }),
-        ...(setVersion !== undefined && { setVersion }),
-    };
-    if (setVersion === undefined && unreleased.unparseableCommits !== undefined) {
-        result.unparseableCommits = unreleased.unparseableCommits;
-    }
-    attachChangelogDiagnostics(result, unreleased.diagnostics);
-    return result;
-}
-function buildReleasedComposite(fields, release, decision, history) {
-    const { unreleased } = history;
-    const result = {
-        ...fields,
-        status: 'released',
-        kind: 'composite',
-        parsedCommitCount: unreleased.parsedCommitCount,
-        releaseType: release.releaseType,
-        commits: unreleased.commits,
-        ...(unreleased.unparseableCommits !== undefined && { unparseableCommits: unreleased.unparseableCommits }),
-        ...(decision?.bumpOverride !== undefined && { bumpOverride: decision.bumpOverride }),
-    };
-    attachChangelogDiagnostics(result, unreleased.diagnostics);
-    return result;
-}
-function buildReleasedPackage(target, fields, release, decision, history) {
-    const { unreleased } = history;
-    const setVersion = decision?.setVersion;
-    const hasParseCounts = decision !== undefined && setVersion === undefined;
-    const result = {
-        ...fields,
-        status: 'released',
-        kind: 'package',
-        commits: unreleased.commits,
-        ...(target.isWorkspace && { name: target.id }),
-        ...(setVersion === undefined && { releaseType: release.releaseType }),
-        ...(hasParseCounts && { parsedCommitCount: unreleased.parsedCommitCount }),
-        ...(decision === undefined && { propagatedOnly: true }),
-        ...(release.propagatedFrom !== undefined && { propagatedFrom: release.propagatedFrom }),
-        ...(decision?.bumpOverride !== undefined && { bumpOverride: decision.bumpOverride }),
-        ...(setVersion !== undefined && { setVersion }),
-    };
-    if (setVersion === undefined && unreleased.unparseableCommits !== undefined) {
-        result.unparseableCommits = unreleased.unparseableCommits;
-    }
-    attachChangelogDiagnostics(result, unreleased.diagnostics);
-    return result;
-}
-function buildReleasedResult(target, fields, release, decision, history) {
-    switch (target.kind) {
-        case 'package':
-            return buildReleasedPackage(target, fields, release, decision, history);
-        case 'directory':
-            return buildReleasedDirectory(target, fields, release, decision, history);
-        case 'composite':
-            return buildReleasedComposite(fields, release, decision, history);
-    }
-}
-function buildPropagationEntries(target, release, newVersion, today, dependenciesHeader) {
-    if (release.propagatedFrom === undefined) {
-        throw new Error(`Workspace '${target.id}' has neither a direct release nor a propagation source`);
-    }
-    return [buildSyntheticChangelogEntry(release.propagatedFrom, newVersion, today, dependenciesHeader)];
-}
 function describeBaselineLabel(target) {
     switch (target.kind) {
         case 'composite':
@@ -236,39 +156,3 @@ function isScopeRouted(target) {
     }
     return target.kind === 'package' && target.isWorkspace;
 }
-function planChangelogFiles(changelogDir, newEntries, settings, sectionOrder) {
-    const jsonPath = resolveChangelogJsonPath(settings, changelogDir);
-    const entries = mergeChangelogEntriesWithDisk(jsonPath, newEntries);
-    const writes = [];
-    const changelogJsonFiles = [];
-    if (settings.changelogJson.enabled) {
-        writes.push({ path: jsonPath, content: renderChangelogJson(entries) });
-        changelogJsonFiles.push(jsonPath);
-    }
-    const changelogFile = joinPath(changelogDir, 'CHANGELOG.md');
-    const preserved = planPreservedSections(changelogDir, entries);
-    const keepVersions = settings.changelogMarkdown?.keepVersions;
-    const rendered = renderChangelogFiles(entries, {
-        sectionOrder,
-        preservedSections: preserved.sections,
-        ...(keepVersions !== undefined && { keepVersions }),
-    });
-    writes.push({ path: changelogFile, content: rendered.main });
-    const archiveFiles = [];
-    for (const { major, content } of rendered.archives) {
-        const path = joinPath(changelogDir, describeArchivePath(major));
-        writes.push({ path, content });
-        archiveFiles.push(path);
-    }
-    const removals = listArchiveFiles(changelogDir)
-        .map((archive) => archive.path)
-        .filter((path) => !archiveFiles.includes(path));
-    return {
-        changelogFiles: [changelogFile, ...archiveFiles],
-        changelogJsonFiles,
-        entries,
-        preservation: preserved.preservation,
-        removals,
-        writes,
-    };
-}

package/dist/esm/previewTagPrefixes.d.ts

@@ -1,5 +1,5 @@
+import type { ReleaseKitConfig } from './configSchema.js';
 import { type UndeclaredTagPrefix } from './detectUndeclaredTagPrefixes.js';
-import type { ReleaseKitConfig } from './types.js';
 /** One workspace's or directory target's preview row in the tag-prefix preview. */
 export interface TagPrefixPreviewRow {
     /** Directory path relative to the repo root (e.g., `packages/core`). */