@pnpm/releasing.versioning 1100.1.0

package/lib/changelog.d.ts

@@ -0,0 +1,12 @@
+import { type PlannedRelease } from './assembleReleasePlan.js';
+export declare function composeChangelogSection(release: PlannedRelease): string;
+/**
+ * Places `section` at the top of a package's changelog: under the existing
+ * `# <name>` title when `existing` has one, or under a freshly created title
+ * when `existing` is `null`. This is the composition used both to write a
+ * committed CHANGELOG.md (`repository` storage) and to build the changelog
+ * packed into a published tarball on top of the previous version's
+ * (`registry` storage).
+ */
+export declare function renderChangelog(existing: string | null, pkgName: string, section: string): string;
+export declare function prependChangelogSection(pkgDir: string, pkgName: string, section: string): Promise<void>;

package/lib/changelog.js

@@ -0,0 +1,84 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import util from 'node:util';
+import { isDirRef } from './assembleReleasePlan.js';
+import { normalizeProjectDir } from './ledger.js';
+const SECTION_TITLES = {
+    major: 'Major Changes',
+    minor: 'Minor Changes',
+    patch: 'Patch Changes',
+};
+export function composeChangelogSection(release) {
+    const entriesByBump = { major: [], minor: [], patch: [] };
+    for (const intent of release.intents) {
+        const bumpType = releaseBumpFor(intent.releases, release);
+        if (bumpType == null || bumpType === 'none' || intent.summary === '')
+            continue;
+        entriesByBump[bumpType].push(formatListItem(intent.summary));
+    }
+    if (release.dependencyUpdates.length > 0) {
+        const depLines = release.dependencyUpdates.map((dep) => `  - ${dep.name}@${dep.newVersion}`);
+        entriesByBump.patch.push(`- Updated dependencies:\n${depLines.join('\n')}`);
+    }
+    const parts = [`## ${release.newVersion}`];
+    for (const bumpType of ['major', 'minor', 'patch']) {
+        if (entriesByBump[bumpType].length === 0)
+            continue;
+        parts.push(`### ${SECTION_TITLES[bumpType]}`);
+        parts.push(entriesByBump[bumpType].join('\n\n'));
+    }
+    return `${parts.join('\n\n')}\n`;
+}
+/**
+ * The bump an intent declares for this release, whichever way the intent
+ * references the project — by name (sound only when unambiguous, which plan
+ * assembly guarantees) or by directory.
+ */
+function releaseBumpFor(releases, release) {
+    for (const [ref, bumpType] of Object.entries(releases)) {
+        if (ref === release.name)
+            return bumpType;
+        if (isDirRef(ref) && normalizeProjectDir(ref) === release.dir)
+            return bumpType;
+    }
+    return undefined;
+}
+function formatListItem(summary) {
+    const [firstLine, ...restLines] = summary.split('\n');
+    const rest = restLines.map((line) => (line === '' ? '' : `  ${line}`));
+    return ['- ' + firstLine, ...rest].join('\n');
+}
+/**
+ * Places `section` at the top of a package's changelog: under the existing
+ * `# <name>` title when `existing` has one, or under a freshly created title
+ * when `existing` is `null`. This is the composition used both to write a
+ * committed CHANGELOG.md (`repository` storage) and to build the changelog
+ * packed into a published tarball on top of the previous version's
+ * (`registry` storage).
+ */
+export function renderChangelog(existing, pkgName, section) {
+    if (existing == null) {
+        return `# ${pkgName}\n\n${section}`;
+    }
+    const newlineIndex = existing.indexOf('\n');
+    const firstLine = newlineIndex === -1 ? existing : existing.slice(0, newlineIndex);
+    if (firstLine.startsWith('# ')) {
+        const body = (newlineIndex === -1 ? '' : existing.slice(newlineIndex + 1)).replace(/^[\r\n]+/, '');
+        return `${firstLine}\n\n${section}${body === '' ? '' : `\n${body}`}`;
+    }
+    return `${section}\n${existing}`;
+}
+export async function prependChangelogSection(pkgDir, pkgName, section) {
+    const changelogPath = path.join(pkgDir, 'CHANGELOG.md');
+    let existing = null;
+    try {
+        existing = await fs.readFile(changelogPath, 'utf8');
+    }
+    catch (err) {
+        if (!(util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT')) {
+            throw err;
+        }
+    }
+    await fs.writeFile(changelogPath, renderChangelog(existing, pkgName, section), 'utf8');
+}
+//# sourceMappingURL=changelog.js.map

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { type AppliedRelease, applyReleasePlan, type ApplyReleasePlanOptions, changelogStorage, } from './applyReleasePlan.js';
+export { assembleReleasePlan, type AssembleReleasePlanOptions, type DependencyUpdate, indexProjectRefs, isDirRef, materializeWorkspaceRange, type PlannedRelease, type ProjectRefIndex, type ReleaseCause, type ReleasePlan, toProjectDir, type WorkspaceProject, } from './assembleReleasePlan.js';
+export { composeChangelogSection, prependChangelogSection, renderChangelog, } from './changelog.js';
+export { BUMP_TYPES, type ChangeIntent, CHANGES_DIR, type IntentBumpType, parseChangeIntent, readChangeIntents, type ReleaseBumpType, writeChangeIntent, type WriteChangeIntentOptions, } from './intents.js';
+export { appendToLedger, buildConsumptionIndex, type Ledger, LEDGER_FILENAME, type LedgerEntry, ledgerEntryIds, normalizeProjectDir, type PackageConsumption, readLedger, } from './ledger.js';
+export { listPendingChangelogs, PENDING_CHANGELOGS_DIR, type PendingChangelog, pendingChangelogPath, readPendingChangelog, removePendingChangelog, writePendingChangelog, } from './pendingChangelog.js';

package/lib/index.js

@@ -0,0 +1,7 @@
+export { applyReleasePlan, changelogStorage, } from './applyReleasePlan.js';
+export { assembleReleasePlan, indexProjectRefs, isDirRef, materializeWorkspaceRange, toProjectDir, } from './assembleReleasePlan.js';
+export { composeChangelogSection, prependChangelogSection, renderChangelog, } from './changelog.js';
+export { BUMP_TYPES, CHANGES_DIR, parseChangeIntent, readChangeIntents, writeChangeIntent, } from './intents.js';
+export { appendToLedger, buildConsumptionIndex, LEDGER_FILENAME, ledgerEntryIds, normalizeProjectDir, readLedger, } from './ledger.js';
+export { listPendingChangelogs, PENDING_CHANGELOGS_DIR, pendingChangelogPath, readPendingChangelog, removePendingChangelog, writePendingChangelog, } from './pendingChangelog.js';
+//# sourceMappingURL=index.js.map

package/lib/intents.d.ts

@@ -0,0 +1,17 @@
+export declare const CHANGES_DIR = ".changeset";
+export declare const BUMP_TYPES: readonly ['none', 'patch', 'minor', 'major'];
+export type IntentBumpType = typeof BUMP_TYPES[number];
+export type ReleaseBumpType = Exclude<IntentBumpType, 'none'>;
+export interface ChangeIntent {
+    id: string;
+    filePath: string;
+    releases: Record<string, IntentBumpType>;
+    summary: string;
+}
+export declare function parseChangeIntent(content: string, id: string, filePath: string): ChangeIntent;
+export declare function readChangeIntents(workspaceDir: string): Promise<ChangeIntent[]>;
+export interface WriteChangeIntentOptions {
+    releases: Record<string, IntentBumpType>;
+    summary: string;
+}
+export declare function writeChangeIntent(workspaceDir: string, opts: WriteChangeIntentOptions): Promise<string>;

package/lib/intents.js

@@ -0,0 +1,76 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import util from 'node:util';
+import { PnpmError } from '@pnpm/error';
+import { humanId } from 'human-id';
+import * as yaml from 'yaml';
+export const CHANGES_DIR = '.changeset';
+export const BUMP_TYPES = ['none', 'patch', 'minor', 'major'];
+export function parseChangeIntent(content, id, filePath) {
+    const lines = content.replace(/^\uFEFF/, '').split(/\r?\n/);
+    const closingIndex = lines[0]?.trim() === '---'
+        ? lines.findIndex((line, index) => index > 0 && line.trim() === '---')
+        : -1;
+    if (closingIndex === -1) {
+        throw new PnpmError('INVALID_CHANGE_INTENT', `Change intent file ${filePath} has no YAML frontmatter`);
+    }
+    let frontmatter;
+    try {
+        frontmatter = yaml.parse(lines.slice(1, closingIndex).join('\n')) ?? {};
+    }
+    catch (err) {
+        throw new PnpmError('INVALID_CHANGE_INTENT', `Change intent file ${filePath} has invalid YAML frontmatter: ${util.types.isNativeError(err) ? err.message : String(err)}`);
+    }
+    if (typeof frontmatter !== 'object' || frontmatter === null || Array.isArray(frontmatter)) {
+        throw new PnpmError('INVALID_CHANGE_INTENT', `Change intent file ${filePath} frontmatter must be a mapping of package names to bump types`);
+    }
+    const releases = {};
+    for (const [pkgName, bumpType] of Object.entries(frontmatter)) {
+        if (typeof bumpType !== 'string' || !BUMP_TYPES.includes(bumpType)) {
+            throw new PnpmError('INVALID_CHANGE_INTENT', `Change intent file ${filePath} declares an invalid bump type for ${pkgName}: ${String(bumpType)}. Expected one of ${BUMP_TYPES.join(', ')}`);
+        }
+        releases[pkgName] = bumpType;
+    }
+    return {
+        id,
+        filePath,
+        releases,
+        summary: lines.slice(closingIndex + 1).join('\n').trim(),
+    };
+}
+export async function readChangeIntents(workspaceDir) {
+    const changesDir = path.join(workspaceDir, CHANGES_DIR);
+    let fileNames;
+    try {
+        fileNames = await fs.readdir(changesDir);
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return [];
+        }
+        throw err;
+    }
+    const intentFileNames = fileNames
+        .filter((fileName) => fileName.endsWith('.md') && fileName.toLowerCase() !== 'readme.md')
+        .sort();
+    return Promise.all(intentFileNames.map(async (fileName) => {
+        const filePath = path.join(changesDir, fileName);
+        const content = await fs.readFile(filePath, 'utf8');
+        return parseChangeIntent(content, fileName.slice(0, -'.md'.length), filePath);
+    }));
+}
+export async function writeChangeIntent(workspaceDir, opts) {
+    const changesDir = path.join(workspaceDir, CHANGES_DIR);
+    await fs.mkdir(changesDir, { recursive: true });
+    const existing = new Set(await fs.readdir(changesDir));
+    let id = humanId({ separator: '-', capitalize: false });
+    while (existing.has(`${id}.md`)) {
+        id = humanId({ separator: '-', capitalize: false });
+    }
+    const frontmatterLines = Object.entries(opts.releases)
+        .map(([pkgName, bumpType]) => `${JSON.stringify(pkgName)}: ${bumpType}`);
+    const content = `---\n${frontmatterLines.join('\n')}\n---\n\n${opts.summary.trim()}\n`;
+    await fs.writeFile(path.join(changesDir, `${id}.md`), content, 'utf8');
+    return id;
+}
+//# sourceMappingURL=intents.js.map

package/lib/ledger.d.ts

@@ -0,0 +1,50 @@
+export declare const LEDGER_FILENAME = "ledger.yaml";
+/**
+ * One consumed release: the workspace-relative directory of the project that
+ * released (the engine's unit of identity — package names may collide across
+ * workspace projects) and the ids of the intent files the release consumed.
+ * The bare id-list shape is accepted when read, for hand-written entries;
+ * its project is then resolved by the package name in the entry key, which
+ * must be unambiguous.
+ */
+export type LedgerEntry = string[] | {
+    dir: string;
+    intents: string[];
+};
+/**
+ * The committed, append-only record of consumed change intents: maps
+ * `<package name>@<released version>` to the released project and the ids of
+ * the intent files consumed by that release. Consumption is scoped per
+ * project — an intent file is fully consumed only once every project it
+ * names has an entry — which is what makes cherry-picked releases on
+ * maintenance branches and merge-backs safe, and what lets one intent be
+ * half-consumed by a package on a release lane.
+ */
+export type Ledger = Record<string, LedgerEntry>;
+export declare function ledgerEntryIds(entry: LedgerEntry): string[];
+export declare function readLedger(workspaceDir: string): Promise<Ledger>;
+export declare function appendToLedger(workspaceDir: string, newEntries: Record<string, {
+    dir: string;
+    intents: string[];
+}>): Promise<Ledger>;
+export interface PackageConsumption {
+    /** Intent ids the ledger records against any released version of the project. */
+    allIds: Set<string>;
+    /** Intent ids recorded only against prerelease versions of the project. */
+    prereleaseOnlyIds: Set<string>;
+}
+/**
+ * Indexes the ledger by workspace-relative project directory in a single
+ * pass. Bare id-list entries carry no directory, so their project is
+ * resolved from the entry key's package name via `resolveNameDirs`; a name
+ * matching several projects cannot be attributed and is an error — write
+ * such entries in the `dir`/`intents` shape instead. Entries whose name no
+ * longer exists in the workspace are inert. Projects without entries map to
+ * an empty consumption, so lookups never miss.
+ */
+export declare function buildConsumptionIndex(ledger: Ledger, resolveNameDirs: (pkgName: string) => string[]): (projectDir: string) => PackageConsumption;
+/**
+ * The canonical spelling of a workspace-relative project directory: forward
+ * slashes, no leading `./`, no trailing slash.
+ */
+export declare function normalizeProjectDir(dir: string): string;

package/lib/ledger.js

@@ -0,0 +1,130 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import util from 'node:util';
+import { PnpmError } from '@pnpm/error';
+import * as yaml from 'yaml';
+import { CHANGES_DIR } from './intents.js';
+export const LEDGER_FILENAME = 'ledger.yaml';
+export function ledgerEntryIds(entry) {
+    return Array.isArray(entry) ? entry : entry.intents;
+}
+export async function readLedger(workspaceDir) {
+    const ledgerPath = path.join(workspaceDir, CHANGES_DIR, LEDGER_FILENAME);
+    let content;
+    try {
+        content = await fs.readFile(ledgerPath, 'utf8');
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return {};
+        }
+        throw err;
+    }
+    const parsed = yaml.parse(content) ?? {};
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new PnpmError('INVALID_VERSIONING_LEDGER', `Expected ${ledgerPath} to be a mapping of package@version keys to consumed-intent entries`);
+    }
+    // A null prototype so a key like "__proto__" lands as an own property
+    // instead of mutating the prototype.
+    const ledger = Object.create(null);
+    for (const [key, entry] of Object.entries(parsed)) {
+        if (!isValidLedgerEntry(entry)) {
+            throw new PnpmError('INVALID_VERSIONING_LEDGER', `Invalid entry for ${key} in ${ledgerPath}. Expected a list of intent ids, or a mapping with "dir" and "intents"`);
+        }
+        ledger[key] = entry;
+    }
+    return ledger;
+}
+function isValidLedgerEntry(entry) {
+    if (Array.isArray(entry)) {
+        return entry.every((id) => typeof id === 'string');
+    }
+    if (typeof entry !== 'object' || entry === null)
+        return false;
+    const { dir, intents } = entry;
+    return typeof dir === 'string' && Array.isArray(intents) && intents.every((id) => typeof id === 'string');
+}
+export async function appendToLedger(workspaceDir, newEntries) {
+    const ledger = await readLedger(workspaceDir);
+    if (Object.keys(newEntries).length === 0)
+        return ledger;
+    for (const [key, entry] of Object.entries(newEntries)) {
+        const existingIds = ledger[key] != null ? ledgerEntryIds(ledger[key]) : [];
+        ledger[key] = {
+            dir: entry.dir,
+            intents: Array.from(new Set([...existingIds, ...entry.intents])).sort(),
+        };
+    }
+    const sorted = Object.fromEntries(Object.entries(ledger).sort(([left], [right]) => left.localeCompare(right)));
+    const changesDir = path.join(workspaceDir, CHANGES_DIR);
+    await fs.mkdir(changesDir, { recursive: true });
+    await fs.writeFile(path.join(changesDir, LEDGER_FILENAME), yaml.stringify(sorted), 'utf8');
+    return sorted;
+}
+/**
+ * Indexes the ledger by workspace-relative project directory in a single
+ * pass. Bare id-list entries carry no directory, so their project is
+ * resolved from the entry key's package name via `resolveNameDirs`; a name
+ * matching several projects cannot be attributed and is an error — write
+ * such entries in the `dir`/`intents` shape instead. Entries whose name no
+ * longer exists in the workspace are inert. Projects without entries map to
+ * an empty consumption, so lookups never miss.
+ */
+export function buildConsumptionIndex(ledger, resolveNameDirs) {
+    const stableIdsByDir = new Map();
+    const prereleaseIdsByDir = new Map();
+    for (const [key, entry] of Object.entries(ledger)) {
+        const atIndex = key.lastIndexOf('@');
+        if (atIndex <= 0)
+            continue;
+        const version = key.slice(atIndex + 1);
+        let dir;
+        if (Array.isArray(entry)) {
+            const pkgName = key.slice(0, atIndex);
+            const dirs = resolveNameDirs(pkgName);
+            if (dirs.length === 0)
+                continue;
+            if (dirs.length > 1) {
+                throw new PnpmError('INVALID_VERSIONING_LEDGER', `The ledger entry ${key} names ${pkgName}, which matches multiple workspace projects (${dirs.join(', ')}). Rewrite the entry with an explicit "dir".`);
+            }
+            dir = dirs[0];
+        }
+        else {
+            dir = normalizeProjectDir(entry.dir);
+        }
+        // Build metadata (after "+") may itself contain hyphens and never makes a
+        // version a prerelease.
+        const isPrerelease = version.split('+')[0].includes('-');
+        const byDir = isPrerelease ? prereleaseIdsByDir : stableIdsByDir;
+        let idSet = byDir.get(dir);
+        if (idSet == null) {
+            idSet = new Set();
+            byDir.set(dir, idSet);
+        }
+        for (const id of ledgerEntryIds(entry)) {
+            idSet.add(id);
+        }
+    }
+    const consumptionByDir = new Map();
+    for (const dir of new Set([...stableIdsByDir.keys(), ...prereleaseIdsByDir.keys()])) {
+        const stableIds = stableIdsByDir.get(dir) ?? new Set();
+        const prereleaseIds = prereleaseIdsByDir.get(dir) ?? new Set();
+        consumptionByDir.set(dir, {
+            allIds: new Set([...stableIds, ...prereleaseIds]),
+            prereleaseOnlyIds: new Set([...prereleaseIds].filter((id) => !stableIds.has(id))),
+        });
+    }
+    return (projectDir) => consumptionByDir.get(projectDir) ?? { allIds: new Set(), prereleaseOnlyIds: new Set() };
+}
+/**
+ * The canonical spelling of a workspace-relative project directory: forward
+ * slashes, no leading `./`, no trailing slash.
+ */
+export function normalizeProjectDir(dir) {
+    let normalized = dir.replaceAll('\\', '/');
+    while (normalized.startsWith('./')) {
+        normalized = normalized.slice(2);
+    }
+    return normalized.replace(/\/+$/, '');
+}
+//# sourceMappingURL=ledger.js.map

package/lib/pendingChangelog.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Directory (under the workspace's `.changeset/`) holding the composed
+ * changelog sections of releases whose intents are not yet published. In
+ * `registry` changelog storage no `CHANGELOG.md` is committed, so a release's
+ * section is parked here at `pnpm version -r` time and consumed at publish,
+ * when it is prepended to the previously published tarball's changelog. Each
+ * file is garbage-collected together with the intents it was composed from,
+ * under the same registry-confirmed gate.
+ */
+export declare const PENDING_CHANGELOGS_DIR = "changelogs";
+export declare function pendingChangelogPath(workspaceDir: string, pkgName: string, version: string): string;
+export interface PendingChangelog {
+    name: string;
+    version: string;
+}
+/**
+ * The `package@version` of every parked section. The release-driven garbage
+ * collector consults this rather than the ledger so it also collects the
+ * sections of dependency-propagated releases, which carry no consumed intents
+ * and therefore have no ledger entry.
+ */
+export declare function listPendingChangelogs(workspaceDir: string): Promise<PendingChangelog[]>;
+export declare function writePendingChangelog(workspaceDir: string, pkgName: string, version: string, section: string): Promise<void>;
+export declare function readPendingChangelog(workspaceDir: string, pkgName: string, version: string): Promise<string | null>;
+/** Removes a parked section. A missing file is not an error — it may already have been collected. */
+export declare function removePendingChangelog(workspaceDir: string, pkgName: string, version: string): Promise<void>;

package/lib/pendingChangelog.js

@@ -0,0 +1,84 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import util from 'node:util';
+import { CHANGES_DIR } from './intents.js';
+/**
+ * Directory (under the workspace's `.changeset/`) holding the composed
+ * changelog sections of releases whose intents are not yet published. In
+ * `registry` changelog storage no `CHANGELOG.md` is committed, so a release's
+ * section is parked here at `pnpm version -r` time and consumed at publish,
+ * when it is prepended to the previously published tarball's changelog. Each
+ * file is garbage-collected together with the intents it was composed from,
+ * under the same registry-confirmed gate.
+ */
+export const PENDING_CHANGELOGS_DIR = 'changelogs';
+/**
+ * A published `package@version` names one artifact, so it is a stable key for
+ * its parked section. The only character in the key that a filesystem rejects
+ * is the `/` of a scoped name, encoded here as `!` (a character neither a
+ * package name nor a semver version can contain, so the mapping is reversible).
+ */
+function pendingChangelogFilename(pkgName, version) {
+    return `${pkgName}@${version}`.replaceAll('/', '!') + '.md';
+}
+export function pendingChangelogPath(workspaceDir, pkgName, version) {
+    return path.join(workspaceDir, CHANGES_DIR, PENDING_CHANGELOGS_DIR, pendingChangelogFilename(pkgName, version));
+}
+/**
+ * The `package@version` of every parked section. The release-driven garbage
+ * collector consults this rather than the ledger so it also collects the
+ * sections of dependency-propagated releases, which carry no consumed intents
+ * and therefore have no ledger entry.
+ */
+export async function listPendingChangelogs(workspaceDir) {
+    const dir = path.join(workspaceDir, CHANGES_DIR, PENDING_CHANGELOGS_DIR);
+    let fileNames;
+    try {
+        fileNames = await fs.readdir(dir);
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return [];
+        }
+        throw err;
+    }
+    const pending = [];
+    for (const fileName of fileNames) {
+        if (!fileName.endsWith('.md'))
+            continue;
+        const key = fileName.slice(0, -'.md'.length);
+        const atIndex = key.lastIndexOf('@');
+        if (atIndex <= 0)
+            continue;
+        pending.push({ name: key.slice(0, atIndex).replaceAll('!', '/'), version: key.slice(atIndex + 1) });
+    }
+    return pending;
+}
+export async function writePendingChangelog(workspaceDir, pkgName, version, section) {
+    const filePath = pendingChangelogPath(workspaceDir, pkgName, version);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, section, 'utf8');
+}
+export async function readPendingChangelog(workspaceDir, pkgName, version) {
+    try {
+        return await fs.readFile(pendingChangelogPath(workspaceDir, pkgName, version), 'utf8');
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return null;
+        }
+        throw err;
+    }
+}
+/** Removes a parked section. A missing file is not an error — it may already have been collected. */
+export async function removePendingChangelog(workspaceDir, pkgName, version) {
+    try {
+        await fs.rm(pendingChangelogPath(workspaceDir, pkgName, version));
+    }
+    catch (err) {
+        if (!(util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT')) {
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=pendingChangelog.js.map

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@pnpm/releasing.versioning",
+  "version": "1100.1.0",
+  "description": "Native workspace release management: change intents, release-plan assembly, and changelog writing",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pnpm/pnpm/tree/main/pnpm11/releasing/versioning"
+  },
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/pnpm11/releasing/versioning#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "@pnpm/error": "1100.0.1",
+    "@pnpm/types": "1101.4.0",
+    "@pnpm/workspace.project-manifest-reader": "1100.0.15",
+    "@pnpm/workspace.spec-parser": "1100.0.0",
+    "human-id": "^4.2.0",
+    "semver": "^7.8.4",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.4.1",
+    "@pnpm/releasing.versioning": "1100.1.0",
+    "@types/semver": "7.7.1",
+    "tempy": "3.0.0"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "test": "pn compile && pn .test",
+    "compile": "tsgo --build && pn lint --fix",
+    ".test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest"
+  }
+}