@williamthorsen/release-kit 14.1.0 → 14.2.0

package/docs/project-releases.md

@@ -1,6 +1,6 @@
 # Project releases
 
-How to add a project-level release to a monorepo, what the `project` block accepts, and how that release interacts with `prepare`'s flags.
+How to add a project-level release to a monorepo, what the `project` block accepts, how that release interacts with `prepare`'s flags, and how to declare it as a `releases` composite instead.
 
 Some monorepos release a single combined deliverable, such as a Chrome extension, a CLI binary, or a packaged desktop app, for which the per-workspace tags and changelogs alone do not describe what the user actually receives. Declare the optional `project` block to add a project-level release stage that runs alongside the per-workspace pipeline.
 
@@ -69,6 +69,46 @@ CLI flag interactions:
 - `--bump=major|minor|patch` propagates to the project release as a level chooser. It does not trigger a release on its own when the window doesn't have any commits or any bump-worthy commits.
 - `--force` runs the project release even when the history since the last project tag doesn't have any commits or any bump-worthy commits. Defaults to patch when `--bump` is not given; combine with `--bump=X` to release at a different level.
 - `--only` narrows the run to the named workspaces and their dependents and skips the project release, which is reported as a warning. The project release rolls up every contributing workspace, and `--only` changes which workspaces those are, so rolling up a narrowed set would release a project version covering work that the run excluded. Run a full `prepare` (without `--only`) to include the project release.
-- `--set-version` is rejected with an error when `project` is configured. `--set-version` sets individual workspaces' versions, but a project release rolls up every contributing workspace; the two semantics don't compose. To use `--set-version`, run on a config without a `project` block.
+- `--set-version` is rejected with an error when `project` or a `releases` composite is configured. `--set-version` sets individual workspaces' versions, but a project release rolls up every contributing workspace; the two semantics don't compose. To use `--set-version`, run on a config without a `project` block.
+
+A `releases` composite has a name, so `--only` can select it: `--only suite` prepares the composite alone, from its own window, and `--only nmr,suite` prepares `nmr`, its dependents, and the composite. A run narrowed by `--only` that doesn't name the composite skips it with a warning.
 
 How `--bump` and `--force` combine for every target is in [Releasing](releasing.md#release-kit-prepare).
+
+## Moving to `releases`
+
+The [`releases`](configuration.md#releases) block declares the same targets by name, and every setting of the `workspaces` and `project` blocks has a counterpart in it, except `project.paths`. A config uses one surface or the other; tag prefixes are unchanged either way.
+
+| Legacy setting                                    | `releases` entry                                      |
+| ------------------------------------------------- | ----------------------------------------------------- |
+| `workspaces: [{ dir: 'x', shouldExclude: true }]` | `x: false`                                            |
+| `workspaces: [{ dir: 'x', legacyIdentities }]`    | `x: { path: 'packages/x', legacyIdentities }`         |
+| `project: {}`                                     | `<name>: { includes: [...every retained workspace] }` |
+| `project: { tagPrefix: 'app-v' }`                 | `<name>: { includes: [...], tagPrefix: 'app-v' }`     |
+| `project: { paths }`                              | No counterpart; keep the `project` block              |
+
+Unlike a `project` block, a composite releases only its listed members' commits, and it has a name that `--only` can select. A workspace left out of `includes` still releases on its own.
+
+A `project` block whose window covers the whole repo only because every workspace is excluded maps to the [repo-root target](configuration.md#the-repo-root), `<name>: { path: '.' }`, together with a `false` entry for each excluded workspace. The root target reads the whole repo by declaration, so a workspace added later doesn't narrow it.
+
+## Publishing and GitHub Releases
+
+`push`, `publish`, and `create-github-release` resolve the project tag on HEAD through the `tagPrefix` of the `project` block or the `releases` composite, alongside the workspace tags:
+
+- `release-kit push` pushes the project tag with the release commit, including when the project tag is the only release tag on HEAD.
+- `release-kit publish` never publishes the project tag, because the project does not have an npm package. When `--tags` names it, `publish` warns `Skipping v0.13.0: a project tag is not an npm package.` and publishes nothing for it.
+- `release-kit create-github-release` creates a GitHub Release for the project tag from `./.meta/changelog.json`, whatever the root `package.json#private` says. A private workspace's tag is still skipped, as [Publishing](publishing.md#publishability-filter) describes.
+
+The `create-github-release.yaml` workflow that `release-kit init` scaffolds for a monorepo triggers only on `'*-v[0-9]*.[0-9]*.[0-9]*'`, which requires a literal `-v` and does not match a `v<version>` project tag. Add the project pattern to its tag filter:
+
+```yaml
+on:
+  push:
+    tags:
+      - '*-v[0-9]*.[0-9]*.[0-9]*'
+      - 'v[0-9]*.[0-9]*.[0-9]*'
+```
+
+A GitHub tag filter matches from the start of the tag, so `'v[0-9]*.[0-9]*.[0-9]*'` does not match a workspace tag such as `core-v1.0.0`. A custom `tagPrefix` needs its own pattern, such as `'app-v[0-9]*.[0-9]*.[0-9]*'` for `tagPrefix: 'app-v'`. `publish.yaml` does not need the project pattern, because `publish` skips the project tag.
+
+When every workspace sets `private: true`, `init` does not create `create-github-release.yaml` (see [Releasing](releasing.md)). A project-release repo of that shape adds the workflow itself.

package/docs/publishing.md

@@ -8,14 +8,14 @@ Publishes packages that have release tags on HEAD. The publish workflow's reusab
 
 ### Publishability filter
 
-`publish` and `create-github-release` operate only on workspaces whose `package.json#private` is absent or `false`. A workspace marked `private: true` is "versioned but not published": It can still be tagged by `release-kit tag` and get a `CHANGELOG.md` entry, but it is skipped by both `release-kit publish` (no registry publish) and `release-kit create-github-release` (no GitHub Release). `private: true` alone excludes a workspace from publish and announce; it doesn't require any extra release config. Other commands ignore this filter and operate on private workspaces unchanged.
+`publish` and `create-github-release` operate only on workspaces whose `package.json#private` is absent or `false`. A workspace marked `private: true` is "versioned but not published": It can still be tagged by `release-kit tag` and get a `CHANGELOG.md` entry, but it is skipped by both `release-kit publish` (no registry publish) and `release-kit create-github-release` (no GitHub Release). `private: true` alone excludes a workspace from publish and announce; it doesn't require any extra release config. Other commands ignore this filter and operate on private workspaces unchanged. A project tag is the exception: `publish` never publishes it, and `create-github-release` creates a Release for it whatever the root `package.json#private` says (see [Project releases](project-releases.md#publishing-and-github-releases)).
 
 An unpublishable tag is always skipped cleanly, never fatal. For `release-kit publish`, whether the skip is announced depends on how the tag was resolved:
 
 - **Without `--tags`** (implicit resolution): Unpublishable tags on HEAD are silently filtered. The pre-publish listing shows only the publishable subset. If the filter empties the set, `release-kit publish` prints `Nothing to publish.` and exits 0.
 - **With `--tags`** (explicit naming): Each named tag pointing at an unpublishable workspace is skipped with a warning, and any publishable tags named in the same command are still published.
 
-`release-kit create-github-release` skips unpublishable workspaces with a warning regardless of `--tags`; an all-private tag set is a clean no-op.
+`release-kit create-github-release` skips unpublishable workspaces with a warning regardless of `--tags`; an all-private tag set is a clean no-op. A project tag is not skipped.
 
 Example warning when an explicit tag is unpublishable:
 
@@ -25,6 +25,6 @@ Skipping basic-v1.0.0 (packages/basic): package.json#private is true.
 
 ## `release-kit create-github-release`
 
-Creates GitHub Releases from `changelog.json` for tags on HEAD. Independent of `npm publish`: Invoking this command creates Releases for publishable packages whether or not they were published to a registry. Private workspaces are skipped (see [Publishability filter](#publishability-filter)).
+Creates GitHub Releases from `changelog.json` for tags on HEAD. Independent of `npm publish`: Invoking this command creates Releases for publishable packages whether or not they were published to a registry. Private workspaces are skipped, and a project tag gets a Release (see [Publishability filter](#publishability-filter)).
 
 When `--tags` is omitted, every release tag pointing at HEAD is processed. The CLI requires the `gh` CLI on `PATH` and `contents: write` permission. The bundled `create-github-release.reusable.yaml` GitHub Actions workflow runs this command in CI.

package/docs/releasing.md

@@ -15,7 +15,7 @@ Scaffolded files:
 - `.github/workflows/release.yaml`: Workflow that delegates to a reusable release workflow
 - `.config/release-kit.config.ts`: Starter config with commented-out customization examples (with `--with-config`)
 
-When every workspace, or the single package, sets `private: true`, `init` skips `create-github-release.yaml` and `publish.yaml`, `--force` included, and reports each skip: `publish` and `create-github-release` skip private packages, so neither workflow would do anything. Its next steps then leave out the provenance and trusted-publisher steps.
+When every workspace, or the single package, sets `private: true`, `init` skips `create-github-release.yaml` and `publish.yaml`, `--force` included, and reports each skip: `publish` and `create-github-release` skip private packages, so neither workflow would do anything. A repo with a `project` block is the exception: `create-github-release` still creates a Release for its project tag, so that repo adds `create-github-release.yaml` itself (see [Project releases](project-releases.md#publishing-and-github-releases)). Its next steps then leave out the provenance and trusted-publisher steps.
 
 ## `release-kit update-templates`
 
@@ -31,7 +31,7 @@ The workflows are managed files: release-kit renders them, and a change made by
 
 Runs release preparation with automatic workspace discovery.
 
-`--only` names the workspaces from which the release starts, by package directory name (e.g., `arrays`, `release-kit`). The run also releases every workspace that depends on one of them, directly or transitively: A dependent with commits of its own releases at its own bump, and one without releases at a propagated patch bump, so that it publishes against the new version. Workspaces outside that set are left out of the run.
+`--only` names the release targets from which the release starts, by target name: a workspace's directory name (e.g., `arrays`, `release-kit`) unless a [`releases`](configuration.md#releases) entry renames it, or a `releases` composite's name. A named composite releases from its own window, whether or not the run includes its members; a run narrowed by `--only` skips every composite that it doesn't name. The run also releases every workspace that depends on one of them, directly or transitively: A dependent with commits of its own releases at its own bump, and one without releases at a propagated patch bump, so that it publishes against the new version. Workspaces outside that set are left out of the run.
 
 `prepare` reads each target's history once and builds the changelog items of its unreleased commits. The bump is the highest level that those items call for, under [`versionPatterns`](configuration.md#versionpatterns), so the bump and the changelog describe the same release: A `feat` entry in a [change-record block](changelogs.md#change-record-blocks) bumps minor under a `docs:` title, and a breaking item bumps major.
 
@@ -88,7 +88,7 @@ docs/*.v*.md
 
 The `--set-version` flag is a first-class escape hatch for the cases in which the derived bump produces the wrong version, most notably when promoting a pre-1.0 package to 1.0.0. Pre-1.0 packages collapse a `feat!` breaking change to a minor bump (matching semantic-release's `initialMajor: false` and release-please's `bump-minor-pre-major`), so a deliberate promotion to 1.0.0 must be requested explicitly.
 
-In a single-package repo, the value is the version: `--set-version 1.0.0`. In a monorepo, it names the workspace with each version, as comma-separated `<workspace>@N.N.N` entries: `--set-version arrays@1.0.0,strings@2.0.0`. Each named workspace releases at its version whether or not it has commits, and starts the release like a workspace named by `--only`.
+In a single-package repo, the value is the version: `--set-version 1.0.0`. In a monorepo, it names the workspace or [directory target](configuration.md#directory-targets) with each version, as comma-separated `<name>@N.N.N` entries: `--set-version arrays@1.0.0,strings@2.0.0`. Each named target releases at its version whether or not it has commits, and starts the release like a target named by `--only`.
 
 The flag validates that:
 
@@ -126,7 +126,7 @@ The `init` command scaffolds a release workflow at `.github/workflows/release.ya
 
 | Input   | Type    | Description                                                                                                                                     |
 | ------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
-| `only`  | string  | Workspaces to release, with their dependents (comma-separated, leave empty for all)                                                             |
+| `only`  | string  | Release targets to release, with their dependents (comma-separated, leave empty for all)                                                        |
 | `bump`  | choice  | Bump type: `auto` (default, detects it from commits), `patch`, `minor`, or `major`                                                              |
 | `force` | boolean | Release even when the window doesn't have any commits or any bump-worthy commits (defaults to patch; combine with `bump` for a different level) |
 

package/docs/work-types.md

@@ -51,7 +51,7 @@ Each work-type has a `breakingPolicy` value:
 
 A `BREAKING CHANGE:` body footer on a `forbidden`-policy type triggers the same warning path as the prefix `!` does: A type that cannot be breaking is parsed as non-breaking whichever surface has the signal. The warning is all that a footer triggers; it doesn't raise a bump (see [`🚨 **Breaking:**` bullet marker](#-breaking-bullet-marker)).
 
-The release-prepare orchestrators (`releasePrepare`, `releasePrepareMono`, `releasePrepareProject`) apply `DEFAULT_BREAKING_POLICIES` automatically. Violations in the titles and change-record entries of each workspace's or project's unreleased window are collected onto the corresponding result's `policyViolations` field, on a skipped result as on a released one, and rendered under the section in the prepare report:
+The release-prepare orchestrator (`releasePrepareTargets`) applies `DEFAULT_BREAKING_POLICIES` automatically. Violations in the titles and change-record entries of each workspace's or project's unreleased window are collected onto the corresponding result's `policyViolations` field, on a skipped result as on a released one, and rendered under the section in the prepare report:
 
 ```
 arrays

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/release-kit",
-  "version": "14.1.0",
+  "version": "14.2.0",
   "description": "Version-bumping and changelog-generation toolkit for release workflows",
   "keywords": [
     "changelog",
@@ -51,7 +51,7 @@
   ],
   "dependencies": {
     "@williamthorsen/change-grammar": "0.2.0",
-    "@williamthorsen/nmr-core": "0.13.2",
+    "@williamthorsen/nmr-core": "0.13.3",
     "@williamthorsen/toolbelt.errors": "0.8.3",
     "json-stringify-pretty-compact": "4.0.0",
     "semver": "7.8.5",

package/presets/labels/common.yaml

@@ -53,6 +53,17 @@
 - name: 'value:questionable'
   color: c5def5
 
+# Confidence
+- name: 'confidence:high'
+  color: 0b7285
+  description: Clearly worth doing
+- name: 'confidence:medium'
+  color: 3bc9db
+  description: Worth doing, but arguable
+- name: 'confidence:low'
+  color: 99e9f2
+  description: Not worth a ticket now
+
 # Triage
 - name: duplicate
   color: cfd3d7

package/dist/esm/releasePrepare.d.ts

@@ -1,36 +0,0 @@
-import type { ReleasePlan } from './releasePlan.js';
-import type { PrepareConfig, ReleaseType } from './types.js';
-/** Options for the release preparation workflow. */
-export interface ReleasePrepareOptions {
-    /**
-     * Release even when the range since the last tag doesn't contain any commits or any bump-worthy commits.
-     * Orthogonal to `bumpOverride`: When `bumpOverride` is not given, the release falls back to `patch`.
-     */
-    force?: boolean;
-    /** Level of the release, in place of the level that the changelog items call for; it doesn't trigger a release. */
-    bumpOverride?: ReleaseType;
-    /**
-     * Explicit target version (canonical `N.N.N`) that bypasses commit-derived bump logic and takes precedence over
-     * `bumpOverride` and `force`.
-     */
-    setVersion?: string;
-    /**
-     * If true, plan per-workspace release-notes previews under `{workspacePath}/docs/`
-     * (`README.v{version}.md` and `RELEASE_NOTES.v{version}.md`) from each workspace's
-     * changelog entries. Requires `config.changelogJson.enabled`; when disabled,
-     * the planner records a warning on the plan and doesn't plan any previews.
-     */
-    withReleaseNotes?: boolean;
-}
-/**
- * Orchestrates the release preparation workflow for a single package.
- *
- * 1. Reads the release history once, and stops when the current version is recorded but untagged.
- * 2. Decides the release from the history's bump, `--force`, and `--bump` (or takes `--set-version`).
- * 3. Plans the bump of every configured `package.json` version field.
- * 4. Plans the changelogs from the same history, and the release-notes previews when requested.
- * 5. Renders the optional format command.
- *
- * Returns the plan without writing any file.
- */
-export declare function releasePrepare(config: PrepareConfig, options: ReleasePrepareOptions): ReleasePlan;

package/dist/esm/releasePrepare.js

@@ -1,230 +0,0 @@
-import { join as joinPath } from 'node:path';
-import { assertTaggedBaseline, findUntaggedBaseline } from "./assertTaggedBaseline.js";
-import { attachChangelogDiagnostics } from "./attachChangelogDiagnostics.js";
-import { readReleaseHistory, toReleaseEntries } from "./buildChangelogEntries.js";
-import { buildReleaseSummary } from "./buildReleaseSummary.js";
-import { mergeChangelogEntriesWithDisk, renderChangelogJson, resolveChangelogJsonPath } from "./changelogJsonFile.js";
-import { applyChangelogOverrides, formatStaleOverrideKeyWarning, loadOverridesForScopes, } from "./changelogOverrides.js";
-import { decideRelease } from "./decideRelease.js";
-import { deriveSectionOrder } from "./deriveReleaseNotesConfig.js";
-import { hasPrettierConfig } from "./hasPrettierConfig.js";
-import { resolveWorkTypes } from "./loadConfig.js";
-import { planReleaseNotesPreviews } from "./planReleaseNotesPreviews.js";
-import { planVersionBump, planVersionSet } from "./planVersionBump.js";
-import { planPreservedSections } from "./readChangelogSections.js";
-import { renderChangelogMarkdown } from "./renderChangelogMarkdown.js";
-export function releasePrepare(config, options) {
-    const { bumpOverride, force, setVersion, withReleaseNotes } = options;
-    const writes = [];
-    const overridesResult = loadOverridesForScopes({ project: '.' });
-    if (overridesResult.errors.length > 0) {
-        throw new Error(`Failed to load changelog overrides:\n  - ${overridesResult.errors.join('\n  - ')}`);
-    }
-    const overrides = overridesResult.project;
-    const history = readReleaseHistory(config, { tagPrefixes: [config.tagPrefix] });
-    assertTaggedBaseline([
-        findUntaggedBaseline({
-            label: 'package',
-            packageFiles: config.packageFiles,
-            changelogPaths: config.changelogPaths,
-            tagPrefixes: [config.tagPrefix],
-            previousTag: history.previousTag,
-        }, config),
-    ]);
-    const { commits } = history.unreleased;
-    const tag = history.previousTag;
-    const since = tag === undefined ? '(no previous release found)' : `since ${tag}`;
-    let releaseType;
-    let bump;
-    if (setVersion === undefined) {
-        const decision = decideRelease({
-            naturalBump: history.unreleased.bump,
-            commitCount: commits.length,
-            force,
-            bumpOverride,
-            skipReasons: {
-                noCommits: `No commits ${since}. Pass --force to release at patch. Skipping.`,
-                noBumpWorthy: `No bump-worthy commits ${since}. Pass --force to release at patch (or --force --bump=X for a different level). Skipping.`,
-            },
-        });
-        if (decision.outcome === 'skip') {
-            const skipped = buildSkippedSinglePackage(history, decision.skipReason);
-            return {
-                workspaces: [skipped],
-                tags: [],
-                writes: [],
-                summary: '',
-                formatCommand: undefined,
-            };
-        }
-        releaseType = decision.releaseType;
-        bump = planVersionBump(config.packageFiles, releaseType);
-    }
-    else {
-        bump = planVersionSet(config.packageFiles, setVersion);
-    }
-    writes.push(...bump.writes);
-    const newTag = `${config.tagPrefix}${bump.newVersion}`;
-    const planWarnings = [];
-    const changelogs = planSinglePackageChangelogs({
-        config,
-        history,
-        newTag,
-        overrides,
-        overrideWarnings: planWarnings,
-    });
-    const { changelogFiles, changelogJsonFiles, changelogPreservation } = changelogs;
-    const previewWrites = planSinglePackagePreviews(withReleaseNotes === true, config, newTag, changelogs.entries, planWarnings);
-    writes.push(...changelogs.writes, ...previewWrites);
-    const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? 'npx prettier --write' : undefined);
-    let formatCommand;
-    if (formatCommandStr !== undefined) {
-        const modifiedFiles = [
-            ...config.packageFiles,
-            ...config.changelogPaths.map((changelogPath) => joinPath(changelogPath, 'CHANGELOG.md')),
-            ...changelogJsonFiles,
-        ];
-        formatCommand = { command: `${formatCommandStr} ${modifiedFiles.join(' ')}`, files: modifiedFiles };
-    }
-    const released = buildReleasedSinglePackage({
-        history,
-        bump,
-        newTag,
-        changelogFiles,
-        changelogPreservation,
-        releaseType,
-        bumpOverride: setVersion === undefined ? bumpOverride : undefined,
-        setVersion,
-        previewFiles: previewWrites.map((write) => write.path),
-    });
-    const plan = {
-        workspaces: [released],
-        tags: [newTag],
-        writes,
-        summary: buildReleaseSummary({ workspaces: [released] }),
-        formatCommand,
-    };
-    if (planWarnings.length > 0) {
-        plan.warnings = planWarnings;
-    }
-    return plan;
-}
-function buildSkippedSinglePackage(history, skipReason) {
-    const { unreleased } = history;
-    const skipped = {
-        status: 'skipped',
-        commitCount: unreleased.commits.length,
-        parsedCommitCount: unreleased.parsedCommitCount,
-        skipReason,
-    };
-    if (history.previousTag !== undefined) {
-        skipped.previousTag = history.previousTag;
-    }
-    if (unreleased.unparseableCommits !== undefined) {
-        skipped.unparseableCommits = unreleased.unparseableCommits;
-    }
-    attachChangelogDiagnostics(skipped, unreleased.diagnostics);
-    return skipped;
-}
-function buildReleasedSinglePackage(args) {
-    const { history, bump, newTag, changelogFiles, releaseType, bumpOverride, setVersion } = args;
-    const { commits, diagnostics, parsedCommitCount, unparseableCommits } = history.unreleased;
-    const released = {
-        status: 'released',
-        commitCount: commits.length,
-        currentVersion: bump.currentVersion,
-        newVersion: bump.newVersion,
-        tag: newTag,
-        bumpedFiles: bump.writes.map((write) => write.path),
-        changelogFiles,
-        commits,
-    };
-    if (history.previousTag !== undefined) {
-        released.previousTag = history.previousTag;
-    }
-    if (releaseType !== undefined) {
-        released.releaseType = releaseType;
-        released.parsedCommitCount = parsedCommitCount;
-        if (unparseableCommits !== undefined) {
-            released.unparseableCommits = unparseableCommits;
-        }
-    }
-    if (bumpOverride !== undefined) {
-        released.bumpOverride = bumpOverride;
-    }
-    attachChangelogDiagnostics(released, diagnostics);
-    if (setVersion !== undefined) {
-        released.setVersion = setVersion;
-    }
-    if (args.previewFiles.length > 0) {
-        released.previewFiles = args.previewFiles;
-    }
-    if (args.changelogPreservation.length > 0) {
-        released.changelogPreservation = args.changelogPreservation;
-    }
-    return released;
-}
-function planSinglePackageChangelogs(args) {
-    const { config, history, newTag, overrides, overrideWarnings } = args;
-    const today = new Date().toISOString().slice(0, 10);
-    const builtEntries = toReleaseEntries(history, newTag, today);
-    const applied = applyChangelogOverrides(builtEntries, overrides);
-    if (applied.errors.length > 0) {
-        throw new Error(`Changelog override application failed:\n  - ${applied.errors.join('\n  - ')}`);
-    }
-    overrideWarnings.push(...applied.warnings);
-    const matchedSet = new Set(applied.matchedKeys);
-    for (const overrideKey of overrides.keys()) {
-        if (!matchedSet.has(overrideKey)) {
-            overrideWarnings.push(formatStaleOverrideKeyWarning(overrideKey));
-        }
-    }
-    const sectionOrder = deriveSectionOrder(resolveWorkTypes(config.workTypes));
-    const changelogFiles = [];
-    const changelogJsonFiles = [];
-    const changelogPreservation = [];
-    const writes = [];
-    let firstMergedEntries = [];
-    for (const changelogPath of config.changelogPaths) {
-        const jsonPath = resolveChangelogJsonPath(config, changelogPath);
-        const mergedEntries = mergeChangelogEntriesWithDisk(jsonPath, applied.entries);
-        if (changelogFiles.length === 0) {
-            firstMergedEntries = mergedEntries;
-        }
-        if (config.changelogJson.enabled) {
-            writes.push({ path: jsonPath, content: renderChangelogJson(mergedEntries) });
-            changelogJsonFiles.push(jsonPath);
-        }
-        const changelogFile = joinPath(changelogPath, 'CHANGELOG.md');
-        const preserved = planPreservedSections(changelogFile, mergedEntries);
-        writes.push({
-            path: changelogFile,
-            content: renderChangelogMarkdown(mergedEntries, { sectionOrder, preservedSections: preserved.sections }),
-        });
-        changelogFiles.push(changelogFile);
-        if (preserved.preservation !== undefined) {
-            changelogPreservation.push(preserved.preservation);
-        }
-    }
-    return { changelogFiles, changelogJsonFiles, changelogPreservation, entries: firstMergedEntries, writes };
-}
-function planSinglePackagePreviews(withReleaseNotes, config, newTag, entries, warnings) {
-    if (!withReleaseNotes) {
-        return [];
-    }
-    if (!config.changelogJson.enabled) {
-        warnings.push('--with-release-notes requires changelogJson.enabled; skipping preview generation');
-        return [];
-    }
-    if (config.changelogPaths.length === 0) {
-        return [];
-    }
-    const previews = planReleaseNotesPreviews({
-        workspacePath: '.',
-        tag: newTag,
-        entries,
-        sectionOrder: deriveSectionOrder(resolveWorkTypes(config.workTypes)),
-    });
-    warnings.push(...previews.warnings);
-    return previews.writes;
-}

package/dist/esm/releasePrepareMono.d.ts

@@ -1,29 +0,0 @@
-import type { ReleasePlan } from './releasePlan.js';
-import type { ReleasePrepareOptions } from './releasePrepare.js';
-import type { MonorepoPrepareConfig } from './types.js';
-/** Options for monorepo release preparation. */
-export interface MonorepoPrepareOptions extends Omit<ReleasePrepareOptions, 'setVersion'> {
-    /**
-     * Workspace `dir`s from which the release starts; the run plans them and their transitive dependents. Present only
-     * for a narrowed run, which skips the project release: The project tier rolls up every contributing workspace, and
-     * the narrowing has changed which workspaces those are.
-     */
-    only?: readonly string[];
-    /**
-     * Explicit target versions (canonical `N.N.N`), keyed by workspace `dir`. Each named workspace starts the release
-     * and releases at its version, which takes precedence over `bumpOverride` and `force`.
-     */
-    setVersions?: ReadonlyMap<string, string>;
-}
-/**
- * Orchestrates release preparation for a monorepo with multiple workspaces.
- *
- * Phase 0: Selects the planned workspaces: those from which the release starts and their transitive dependents.
- * Phase 1: Determines direct bumps from commits for each workspace.
- * Phase 2: Propagates bumps to dependents.
- * Phase 2b: Sorts the full release set topologically.
- * Phase 3: Plans bumps and changelogs in dependency order.
- * Phase 3b: Plans the project release.
- * Phase 4: Renders the format command.
- */
-export declare function releasePrepareMono(fullConfig: MonorepoPrepareConfig, options: MonorepoPrepareOptions): ReleasePlan;