@exadev/semantic-release-workspace 3.1.29 → 3.2.1

package/dist/index.js

@@ -677,6 +677,65 @@ function mustGet(map, key, what) {
 	return value;
 }
 //#endregion
+//#region src/bundling.ts
+/**
+* Validates `bundlingPackages` against the workspace and works out, for every package, which workspace dependencies it bundles.
+*
+* A package named in `bundlingPackages` declares that its build inlines every workspace sibling it lists in `devDependencies`, so consumers never install those siblings from the registry and their code reaches consumers only through this package. When such a sibling releases, this package's release type is at least the sibling's shipped release type (a `feat` in the sibling releases this package as a minor), instead of the patch an ordinary dependency bump forces. Edges in `dependencies`, `peerDependencies` and `optionalDependencies` are installed by consumers, so they keep the forced patch.
+*
+* A private package's own release type never changes: it keeps the patch a dependency bump forces, so its versions and tags are exactly what they would be without `bundlingPackages`. What it gains is a carried release type (see `BundledDependencies.carried`), which lets a bundling package that lists only the private package still see the release type of a private sibling the private package depends on.
+*
+* `bundlingPackages` names public workspace packages whose builds bundle their workspace `devDependencies`; `undefined` or an empty list leaves every package's release type as it was. Returns one entry per package in the graph. Throws `ReleaseConfigurationError` when a name is not a package in the workspace, or names a private package, which never publishes and so ships nothing to consumers.
+*/
+function resolveBundledDependencies(graph, bundlingPackages) {
+	const bundling = new Set(bundlingPackages);
+	const unknown = [...bundling].filter((name) => !graph.packages.has(name));
+	if (unknown.length > 0) throw new ReleaseConfigurationError(`bundlingPackages names ${unknown.map((name) => `"${name}"`).join(", ")}, which ${unknown.length === 1 ? "is" : "are"} not a package in this workspace. Packages: ${[...graph.packages.keys()].join(", ")}.`);
+	const privateNames = [...bundling].filter((name) => mustGet(graph.packages, name, "package").private);
+	if (privateNames.length > 0) throw new ReleaseConfigurationError(`bundlingPackages names ${privateNames.map((name) => `"${name}"`).join(", ")}, which ${privateNames.length === 1 ? "is" : "are"} private. A private package is never published, so nothing it bundles reaches a consumer through it; list the public package whose build inlines it instead.`);
+	const resolved = /* @__PURE__ */ new Map();
+	for (const [name, pkg] of graph.packages) {
+		const edges = mustGet(graph.dependencies, name, "dependency edges");
+		const releaseTypeFrom = new Set(edges.filter((edge) => bundling.has(name) && edge.field === "devDependencies").map((edge) => edge.dependency));
+		const carried = /* @__PURE__ */ new Set([...releaseTypeFrom, ...edges.filter((edge) => pkg.private && isPrivateRuntimeEdge(edge, graph)).map((edge) => edge.dependency)]);
+		resolved.set(name, {
+			releaseTypeFrom,
+			carried
+		});
+	}
+	return resolved;
+}
+function isPrivateRuntimeEdge(edge, graph) {
+	return edge.field !== "devDependencies" && mustGet(graph.packages, edge.dependency, "package").private;
+}
+//#endregion
+//#region src/release-type.ts
+/** Every release type semantic-release knows, highest first: the order `@semantic-release/commit-analyzer` itself ranks them in (its `lib/default-release-types.js`), so comparing two types here agrees with how the analyzer picks the highest type among a package's own commits. */
+const RELEASE_TYPES_HIGHEST_FIRST = [
+	"major",
+	"premajor",
+	"minor",
+	"preminor",
+	"patch",
+	"prepatch",
+	"prerelease"
+];
+const KNOWN_RELEASE_TYPES = new Set(RELEASE_TYPES_HIGHEST_FIRST);
+/** Whether `value` is one of semantic-release's release types. */
+function isReleaseType(value) {
+	return typeof value === "string" && KNOWN_RELEASE_TYPES.has(value);
+}
+/** The highest of the given release types, ranked as `@semantic-release/commit-analyzer` ranks them, or `undefined` when `types` is empty. */
+function highestReleaseType(types) {
+	let highest;
+	for (const type of types) if (highest === void 0 || RELEASE_TYPES_HIGHEST_FIRST.indexOf(type) < RELEASE_TYPES_HIGHEST_FIRST.indexOf(highest)) highest = type;
+	return highest;
+}
+/** `base`, raised to `other` when `other` is the higher release type; an `undefined` `other` leaves `base` as it is. */
+function raiseReleaseType(base, other) {
+	return other === void 0 || RELEASE_TYPES_HIGHEST_FIRST.indexOf(base) <= RELEASE_TYPES_HIGHEST_FIRST.indexOf(other) ? base : other;
+}
+//#endregion
 //#region src/dependency-bump-commit.ts
 /**
 * The commit message format for a cross-package dependency-range bump, shared between the code that writes it (`bumpDependents` in `release.ts`) and the code that reads it back (`createScopedPlugins` in `plugins.ts`).
@@ -686,26 +745,30 @@ function mustGet(map, key, what) {
 const TRAILER_DEPENDENCY = "Bumped-Workspace-Dependency";
 const TRAILER_VERSION = "Bumped-Workspace-Dependency-Version";
 const TRAILER_RANGE = "Bumped-Workspace-Dependency-Range";
+const TRAILER_RELEASE_TYPE = "Bumped-Workspace-Dependency-Release-Type";
 /** Builds the full commit message (subject and trailer) for one dependency-range bump. */
 function formatDependencyBumpMessage(info) {
 	return `${`chore(deps): bump ${info.dependency} to ${info.range} in ${info.dependent} [skip ci]`}\n\n${[
 		`${TRAILER_DEPENDENCY}: ${info.dependency}`,
 		`${TRAILER_VERSION}: ${info.version}`,
-		`${TRAILER_RANGE}: ${info.range}`
+		`${TRAILER_RANGE}: ${info.range}`,
+		`${TRAILER_RELEASE_TYPE}: ${info.releaseType}`
 	].join("\n")}`;
 }
 /**
-* Recovers the dependency bump a `formatDependencyBumpMessage` commit recorded, from its full git message (subject and body), or `undefined` if the message carries no such trailer. All three lines must be present for the commit to be treated as a bump commit at all -- a message missing even one is left alone rather than partially trusted.
+* Recovers the dependency bump a `formatDependencyBumpMessage` commit recorded, from its full git message (subject and body), or `undefined` if the message carries no such trailer. The dependency, version and range lines must all be present for the commit to be treated as a bump commit at all -- a message missing even one is left alone rather than partially trusted. The release type line is optional, since bump commits written before it existed lack it; when it is absent or names no release type, `releaseType` is `undefined`.
 */
 function parseDependencyBumpTrailer(message) {
 	const dependency = matchTrailerLine(message, TRAILER_DEPENDENCY);
 	const version = matchTrailerLine(message, TRAILER_VERSION);
 	const range = matchTrailerLine(message, TRAILER_RANGE);
 	if (dependency === void 0 || version === void 0 || range === void 0) return;
+	const releaseType = matchTrailerLine(message, TRAILER_RELEASE_TYPE);
 	return {
 		dependency,
 		version,
-		range
+		range,
+		releaseType: isReleaseType(releaseType) ? releaseType : void 0
 	};
 }
 function matchTrailerLine(message, key) {
@@ -743,10 +806,11 @@ const STEP_PLUGINS_THE_ORCHESTRATOR_OWNS = /* @__PURE__ */ new Set(["@semantic-r
 *
 * Both apply the same path scoping before delegating to the real `@semantic-release/commit-analyzer` and `@semantic-release/release-notes-generator`: the commit list semantic-release already fetched for the release range is filtered down to commits whose `git log --name-only` file list intersects the package's own directory, and only the filtered list reaches the standard plugin. Conventional-commit parsing and changelog formatting stay entirely inside the standard plugins.
 *
-* The `analyzeCommits` wrapper carries one addition beyond filtering: when the standard analyzer finds no releasable commits but a workspace dependency range of the package's has changed, it returns 'patch' anyway. A dependent whose only change is a dependency bump still needs a release for that range to reach the registry. "Has changed" is read from two sources, merged: bumps recorded in memory earlier in the current run (`scope.bumps`), and bumps recorded in the package's own filtered commit history via the trailer `dependency-bump-commit.ts` writes and reads -- the latter is what lets a run that starts after a previous run already committed and pushed the bump (a crash recovery, or simply a later run) reach the same decision, rather than depending on state that existed only inside the process that made the commit.
+* The `analyzeCommits` wrapper carries two additions beyond filtering. When the standard analyzer finds no releasable commits but a workspace dependency range of the package's has changed, it returns 'patch' anyway: a dependent whose only change is a dependency bump still needs a release for that range to reach the registry. And when a bumped dependency is one the package bundles (`scope.bundled.releaseTypeFrom`), the package's release type is raised to at least that dependency's shipped release type, whether or not the package has releasable commits of its own, because the dependency's change reaches consumers only inside this package. "Has changed" is read from two sources, merged: bumps recorded in memory earlier in the current run (`scope.bumps`), and bumps recorded in the package's own filtered commit history via the trailer `dependency-bump-commit.ts` writes and reads -- the latter is what lets a run that starts after a previous run already committed and pushed the bump (a crash recovery, or simply a later run) reach the same decision, rather than depending on state that existed only inside the process that made the commit.
 */
 function createScopedPlugins(scope) {
 	let cached;
+	let carriedReleaseType;
 	async function commitsForPackage(context) {
 		const from = hasGitHead(context.lastRelease) ? context.lastRelease.gitHead : void 0;
 		if (cached === void 0) cached = {
@@ -764,13 +828,26 @@ function createScopedPlugins(scope) {
 	return {
 		async analyzeCommits(_pluginConfig, context) {
 			const commits = await commitsForPackage(context);
-			const type = await analyzeCommits(scope.analyzeCommitsConfig, {
+			const analysed = await analyzeCommits(scope.analyzeCommitsConfig, {
 				...context,
 				commits
 			});
-			if (typeof type === "string") return type;
+			if (typeof analysed === "string" && !isReleaseType(analysed)) throw new ReleaseConfigurationError(`@semantic-release/commit-analyzer returned "${analysed}" for ${scope.pkg.name}, which is not a semantic-release release type.`);
+			const own = typeof analysed === "string" ? analysed : void 0;
 			const bumps = mergeDependencyBumps(scope.bumps.bumpsFor(scope.pkg.name), commits);
+			carriedReleaseType = releaseTypeOfBumps(bumps.filter((bump) => scope.bundled?.carried.has(bump.dependency) === true));
+			const bundledBumps = bumps.filter((bump) => scope.bundled?.releaseTypeFrom.has(bump.dependency) === true);
+			const fromBundled = releaseTypeOfBumps(bundledBumps);
+			if (own !== void 0) {
+				const type = raiseReleaseType(own, fromBundled);
+				if (type !== own) context.logger.log(`${scope.pkg.name} bundles ${describeBundledBumps(bundledBumps)}; raising its ${own} release to ${type}.`);
+				return type;
+			}
 			if (bumps.length === 0) return false;
+			if (fromBundled !== void 0) {
+				context.logger.log(`No releasable commits under ${scope.pkg.relativeDirectory}, but it bundles ${describeBundledBumps(bundledBumps)}; releasing it as ${fromBundled}.`);
+				return fromBundled;
+			}
 			context.logger.log(`No releasable commits under ${scope.pkg.relativeDirectory}, but ${bumps.length === 1 ? "a workspace dependency range changed" : `${String(bumps.length)} workspace dependency ranges changed`}; forcing a patch release.`);
 			return "patch";
 		},
@@ -788,9 +865,19 @@ function createScopedPlugins(scope) {
 				...bumps.map((bump) => describeDependencyBump(bump))
 			].join("\n");
 			return typeof notes === "string" ? `${notes}\n\n${section}` : section;
+		},
+		shippedReleaseType(releaseType) {
+			return raiseReleaseType(releaseType, carriedReleaseType);
 		}
 	};
 }
+/** The highest release type among `bumps`, or `undefined` when there are none. A bump with no recorded type counts as the patch it always forced. */
+function releaseTypeOfBumps(bumps) {
+	return highestReleaseType(bumps.map((bump) => bump.releaseType ?? "patch"));
+}
+function describeBundledBumps(bumps) {
+	return bumps.map((bump) => `${bump.dependency} (released ${bump.version}, ${bump.releaseType ?? "patch"})`).join(", ");
+}
 /**
 * Combines the bumps recorded in memory earlier in the current run with bumps recovered from the package's own filtered commit history (a bump commit from this run, already visible because it touches the package's own directory, or one left over from a previous run), de-duplicated by dependency name. The in-memory entry wins on overlap: it carries the manifest field and dependent name a `resolved-at-publish` bump has no commit to recover from at all.
 */
@@ -989,6 +1076,7 @@ async function attemptSingleCommitRelease(options) {
 		requireGitPlugin: false,
 		forbidGitPlugin: true
 	});
+	const bundled = resolveBundledDependencies(graph, options.bundlingPackages);
 	const analyzeCommitsConfig = options.analyzeCommits ?? {};
 	const generateNotesConfig = options.generateNotes ?? {};
 	const tagFormat = validateTagFormat(options.tagFormat ?? "${name}@${version}");
@@ -1010,6 +1098,7 @@ async function attemptSingleCommitRelease(options) {
 			analyzeCommitsConfig,
 			generateNotesConfig,
 			bumpsForThisPackage,
+			bundled: mustGet(bundled, name, "bundled dependencies"),
 			env,
 			branches: options.branches,
 			onCommitsResolved: (commits) => {
@@ -1047,7 +1136,10 @@ async function attemptSingleCommitRelease(options) {
 			notes: nextRelease.notes,
 			bumps: bumpsForThisPackage
 		});
-		for (const bump of planDependentBumps(pkg, nextRelease.version, graph)) {
+		for (const bump of planDependentBumps(pkg, {
+			version: nextRelease.version,
+			releaseType: nextRelease.shippedReleaseType
+		}, graph)) {
 			const forDependent = pendingBumps.get(bump.dependent) ?? [];
 			forDependent.push(bump);
 			pendingBumps.set(bump.dependent, forDependent);
@@ -1153,6 +1245,7 @@ async function analysePackage(pkg, options) {
 		analyzeCommitsConfig: options.analyzeCommitsConfig,
 		generateNotesConfig: options.generateNotesConfig,
 		bumps: { bumpsFor: () => options.bumpsForThisPackage },
+		bundled: options.bundled,
 		onCommitsResolved: options.onCommitsResolved
 	});
 	const semanticReleaseOptions = {
@@ -1178,13 +1271,15 @@ async function analysePackage(pkg, options) {
 	if (result.nextRelease.notes === void 0) throw new ReleaseConfigurationError(`Internal error: ${pkg.name} released with no notes computed.`);
 	return {
 		type: result.nextRelease.type,
+		shippedReleaseType: scoped.shippedReleaseType(result.nextRelease.type),
 		version: result.nextRelease.version,
 		gitTag: result.nextRelease.gitTag,
 		notes: result.nextRelease.notes
 	};
 }
 /** Pure classification of what a released package's version does to each dependent's declared range -- the same logic `bumpDependents` in `release.ts` applies, minus the file write/commit/push: `commitStrategy: 'single'` defers every write to phase 3, applying the same classification once analysis has finished for the whole run. */
-function planDependentBumps(released, version, graph) {
+function planDependentBumps(released, release, graph) {
+	const { version, releaseType } = release;
 	const applied = [];
 	const dependents = graph.dependents.get(released.name);
 	if (dependents === void 0) return applied;
@@ -1197,7 +1292,8 @@ function planDependentBumps(released, version, graph) {
 			field: edge.field,
 			version,
 			range: update.kind === "rewritten" ? update.range : edge.range,
-			kind: update.kind
+			kind: update.kind,
+			releaseType
 		});
 	}
 	return applied;
@@ -1291,14 +1387,16 @@ async function detachWorkspaceRelease(options) {
 		plugins: options.plugins ?? DEFAULT_PUBLISH_PLUGINS,
 		packagePlugins: options.packagePlugins
 	}, workspace.root, { requireGitPlugin: !dryRun });
+	const bundled = resolveBundledDependencies(graph, options.bundlingPackages);
 	const analyzeCommitsConfig = options.analyzeCommits ?? {};
 	const generateNotesConfig = options.generateNotes ?? {};
 	const entries = await runReleaseLoop(graph, order, workspace, dryRun, log, async (pkg, bumpsForThisPackage) => {
-		const state = await runPackageDetach(pkg, {
+		const { state, releaseType } = await runPackageDetach(pkg, {
 			publishPlugins: mustGet(publishPlugins, pkg.name, "publish plugins"),
 			analyzeCommitsConfig,
 			generateNotesConfig,
 			bumpsForThisPackage,
+			bundled: mustGet(bundled, pkg.name, "bundled dependencies"),
 			tagFormat: validateTagFormat(options.tagFormat ?? "${name}@${version}"),
 			dryRun,
 			env,
@@ -1307,6 +1405,7 @@ async function detachWorkspaceRelease(options) {
 		return {
 			released: state !== null,
 			version: state?.nextRelease.version,
+			releaseType,
 			result: state
 		};
 	});
@@ -1339,7 +1438,8 @@ async function runPackageDetach(pkg, options) {
 		pkg,
 		analyzeCommitsConfig: options.analyzeCommitsConfig,
 		generateNotesConfig: options.generateNotesConfig,
-		bumps: { bumpsFor: () => options.bumpsForThisPackage }
+		bumps: { bumpsFor: () => options.bumpsForThisPackage },
+		bundled: options.bundled
 	});
 	const cliOptions = {
 		tagFormat: formatTagForPackage(options.tagFormat, pkg.name),
@@ -1350,10 +1450,14 @@ async function runPackageDetach(pkg, options) {
 	if (options.dryRun) cliOptions.dryRun = true;
 	if (options.branches !== void 0) cliOptions.branches = options.branches;
 	try {
-		return await detachRelease(cliOptions, {
+		const state = await detachRelease(cliOptions, {
 			cwd: pkg.directory,
 			env: { ...options.env }
 		});
+		return {
+			state,
+			releaseType: state === null ? void 0 : scoped.shippedReleaseType(state.nextRelease.type)
+		};
 	} catch (cause) {
 		throw new WorkspaceReleaseError(`Detaching ${pkg.name} failed: ${cause instanceof Error ? cause.message : String(cause)}`);
 	}
@@ -1433,17 +1537,19 @@ async function releaseWorkspace(options = {}) {
 		plugins: options.plugins ?? DEFAULT_PUBLISH_PLUGINS,
 		packagePlugins: options.packagePlugins
 	}, workspace.root, { requireGitPlugin: !dryRun });
+	const bundled = resolveBundledDependencies(graph, options.bundlingPackages);
 	const analyzeCommitsConfig = options.analyzeCommits ?? {};
 	const generateNotesConfig = options.generateNotes ?? {};
 	return {
 		order,
 		packages: (await runReleaseLoop(graph, order, workspace, dryRun, log, async (pkg, bumpsForThisPackage) => {
-			const result = await runPackageRelease(pkg, {
+			const { result, releaseType } = await runPackageRelease(pkg, {
 				tagFormat: validateTagFormat(options.tagFormat ?? "${name}@${version}"),
 				publishPlugins: mustGet(publishPlugins, pkg.name, "publish plugins"),
 				analyzeCommitsConfig,
 				generateNotesConfig,
 				bumpsForThisPackage,
+				bundled: mustGet(bundled, pkg.name, "bundled dependencies"),
 				dryRun,
 				env,
 				branches: options.branches
@@ -1452,6 +1558,7 @@ async function releaseWorkspace(options = {}) {
 			return {
 				released: nextRelease !== void 0,
 				version: nextRelease?.version,
+				releaseType,
 				result
 			};
 		})).map((entry) => {
@@ -1474,7 +1581,7 @@ async function releaseWorkspace(options = {}) {
 	};
 }
 /**
-* The per-package release loop shared by `releaseWorkspace` (normal per-package releases) and `detachWorkspaceRelease` (gated tag-only releases): iterate the topological `order`, call the caller's own `releaseOne` for each package, record which dependency-range bumps were already applied to it, and -- when it released -- bump every workspace dependent's manifest before that dependent's own turn (see `bumpDependents`'s doc comment for why this happens immediately rather than being staged). The two call sites differ only in how they call semantic-release (`semanticRelease(...)` vs `detachRelease(...)`) and how they read "did it release, and what version" off the result, both captured by `releaseOne`.
+* The per-package release loop shared by `releaseWorkspace` (normal per-package releases) and `detachWorkspaceRelease` (gated tag-only releases): iterate the topological `order`, call the caller's own `releaseOne` for each package, record which dependency-range bumps were already applied to it, and -- when it released -- bump every workspace dependent's manifest before that dependent's own turn (see `bumpDependents`'s doc comment for why this happens immediately rather than being staged). The two call sites differ only in how they call semantic-release (`semanticRelease(...)` vs `detachRelease(...)`) and how they read "did it release, at what version and with which shipped release type" off the result, all captured by `releaseOne`.
 */
 async function runReleaseLoop(graph, order, workspace, dryRun, log, releaseOne) {
 	const pendingBumps = /* @__PURE__ */ new Map();
@@ -1484,7 +1591,7 @@ async function runReleaseLoop(graph, order, workspace, dryRun, log, releaseOne)
 		const pkg = mustGet(graph.packages, name, "package");
 		const bumpsForThisPackage = pendingBumps.get(name) ?? [];
 		log(`Releasing ${name} from ${pkg.relativeDirectory}${bumpsForThisPackage.length > 0 ? ` (dependency ranges already bumped: ${bumpsForThisPackage.map((bump) => bump.dependency).join(", ")})` : ""}`);
-		const { released, version, result } = dryRun ? await releaseOne(pkg, bumpsForThisPackage) : await releasePackageAcrossBranchMoves(name, branchTracker(workspace, log), async () => await releaseOne(pkg, bumpsForThisPackage), log);
+		const { released, version, releaseType, result } = dryRun ? await releaseOne(pkg, bumpsForThisPackage) : await releasePackageAcrossBranchMoves(name, branchTracker(workspace, log), async () => await releaseOne(pkg, bumpsForThisPackage), log);
 		entries.push({
 			name,
 			directory: pkg.directory,
@@ -1493,13 +1600,16 @@ async function runReleaseLoop(graph, order, workspace, dryRun, log, releaseOne)
 			dependencyBumps: bumpsForThisPackage
 		});
 		pendingBumps.delete(name);
-		if (!released || version === void 0) {
+		if (!released || version === void 0 || releaseType === void 0) {
 			log(`${name}: no release`);
 			continue;
 		}
 		log(`${name}: released ${version}`);
 		identity ??= await resolveCommitIdentity({ cwd: workspace.root });
-		const bumps = await bumpDependents(pkg, version, graph, {
+		const bumps = await bumpDependents(pkg, {
+			version,
+			releaseType
+		}, graph, {
 			workspace,
 			dryRun,
 			identity,
@@ -1518,7 +1628,8 @@ async function runPackageRelease(pkg, options) {
 		pkg,
 		analyzeCommitsConfig: options.analyzeCommitsConfig,
 		generateNotesConfig: options.generateNotesConfig,
-		bumps: { bumpsFor: () => options.bumpsForThisPackage }
+		bumps: { bumpsFor: () => options.bumpsForThisPackage },
+		bundled: options.bundled
 	});
 	const semanticReleaseOptions = {
 		tagFormat: formatTagForPackage(options.tagFormat, pkg.name),
@@ -1529,10 +1640,14 @@ async function runPackageRelease(pkg, options) {
 	if (options.dryRun) semanticReleaseOptions.dryRun = true;
 	if (options.branches !== void 0) semanticReleaseOptions.branches = options.branches;
 	try {
-		return await semanticRelease(semanticReleaseOptions, {
+		const result = await semanticRelease(semanticReleaseOptions, {
 			cwd: pkg.directory,
 			env: { ...options.env }
 		});
+		return {
+			result,
+			releaseType: result === false ? void 0 : scoped.shippedReleaseType(result.nextRelease.type)
+		};
 	} catch (cause) {
 		throw new WorkspaceReleaseError(`Release of ${pkg.name} failed: ${cause instanceof Error ? cause.message : String(cause)}`);
 	}
@@ -1544,10 +1659,11 @@ const LOCKFILE_FILENAME = "pnpm-lock.yaml";
 *
 * The bump is committed (and pushed) right away rather than staged, because a dependent's semantic-release run analyses git history, not the working tree: an uncommitted bump would be invisible to its commit analysis, and would be stranded uncommitted if the dependent then released nothing -- a manifest that names versions the registry has never seen. Committing immediately means the dependent's own run sees the bump commit (it touches only the dependent's directory, so it passes that dependent's path filter), the forced-patch logic in the scoped analyzer covers the case where that bump is the dependent's only change, and a run interrupted partway leaves the remote describing exactly what was published. Pushing immediately mirrors what semantic-release itself does with release commits. The lockfile is regenerated (`pnpm install --lockfile-only`) and committed alongside the manifest for the same reason: a manifest bump committed without it leaves `pnpm-lock.yaml` naming the old range, which `pnpm install --frozen-lockfile` (what CI runs) then rejects.
 */
-async function bumpDependents(released, version, graph, options) {
+async function bumpDependents(released, release, graph, options) {
 	const applied = [];
 	const dependents = graph.dependents.get(released.name);
 	if (dependents === void 0) return applied;
+	const { version, releaseType } = release;
 	for (const edge of dependents) {
 		const update = updateDependencyRange(edge.range, version);
 		if (update.kind === "wildcard") continue;
@@ -1560,6 +1676,7 @@ async function bumpDependents(released, version, graph, options) {
 					dependency: released.name,
 					version,
 					range: update.range,
+					releaseType,
 					dependent: edge.dependent
 				});
 				await commitFiles([`${dependent.relativeDirectory}/package.json`, LOCKFILE_FILENAME], message, {
@@ -1576,7 +1693,8 @@ async function bumpDependents(released, version, graph, options) {
 			field: edge.field,
 			version,
 			range: update.kind === "rewritten" ? update.range : edge.range,
-			kind: update.kind
+			kind: update.kind,
+			releaseType
 		});
 	}
 	return applied;
@@ -1604,4 +1722,4 @@ function branchTracker(workspace, log) {
 	};
 }
 //#endregion
-export { DEFAULT_PUBLISH_PLUGINS, DependencyCycleError, GitCommandError, ReleaseConfigurationError, SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS, UnsupportedDependencyRangeError, WorkspaceDiscoveryError, WorkspaceReleaseError, WorkspaceStateError, buildDependencyGraph, classifyDependencyRange, createScopedPlugins, discoverWorkspace, filterCommitsToDirectory, orderedPackages, packageName, readManifest, releaseWorkspace, resolvePublishPlugins, resolveWorkspacePublishPlugins, resumeWorkspaceRelease, topologicalOrder, updateDependencyRange, writeDependencyRange };
+export { DEFAULT_PUBLISH_PLUGINS, DependencyCycleError, GitCommandError, ReleaseConfigurationError, SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS, UnsupportedDependencyRangeError, WorkspaceDiscoveryError, WorkspaceReleaseError, WorkspaceStateError, buildDependencyGraph, classifyDependencyRange, createScopedPlugins, discoverWorkspace, filterCommitsToDirectory, orderedPackages, packageName, readManifest, releaseWorkspace, resolveBundledDependencies, resolvePublishPlugins, resolveWorkspacePublishPlugins, resumeWorkspaceRelease, topologicalOrder, updateDependencyRange, writeDependencyRange };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exadev/semantic-release-workspace",
-  "version": "3.1.29",
+  "version": "3.2.1",
   "description": "Independent per-package semantic-release orchestration for pnpm workspaces, without lockstep versioning.",
   "type": "module",
   "repository": {