@exadev/semantic-release-workspace 2.0.0 → 2.1.0

package/README.md

@@ -206,7 +206,7 @@ Run it from the workspace root (or pass `--root <directory>`). A dry run analyse
 | `--commit-strategy <mode>` | `per-package` (default) or `single` — see [Commit strategies](#commit-strategies) |
 | `--gate-publish` | Tag and push each due package, but defer publishing — see [Gating publish](#gating-publish). Requires `--gate-state-file`; rejected with `--commit-strategy single` |
 | `--gate-state-file <path>` | With `--gate-publish`: where to write the state a later `resume` run needs |
-| `--config <file>` | A config file (`.json`, `.yaml`, `.yml`, `.js`, `.cjs`, `.mjs`, `.ts`, `.cts`, or `.mts`, loaded via [cosmiconfig](https://github.com/cosmiconfig/cosmiconfig)) providing any of the above through its default export; explicit flags win. TypeScript files are run by Node's own type stripping, so they may use only erasable type syntax (annotations and `import type`, not `enum` or `namespace`) |
+| `--config <file>` | A config file (`.json`, `.yaml`, `.yml`, `.js`, `.cjs`, `.mjs`, `.ts`, `.cts`, or `.mts`, loaded via [cosmiconfig](https://github.com/cosmiconfig/cosmiconfig)) providing any of the above, plus `packagePlugins` (see [Per-package publish plugins](#per-package-publish-plugins)), through its default export; explicit flags win. TypeScript files are run by Node's own type stripping, so they may use only erasable type syntax (annotations and `import type`, not `enum` or `namespace`) |
 
 `resume` (a separate subcommand, not a `release` flag) finishes publishing what a `--gate-publish` run tagged and pushed:
 
@@ -219,6 +219,27 @@ Listing `@semantic-release/commit-analyzer` or `@semantic-release/release-notes-
 
 Note that the orchestrator sets `tagFormat`, `plugins`, `analyzeCommits`, and `generateNotes` explicitly on every per-package run, so those keys in any `release.config.*` found in the workspace are overridden by construction — configure the release through the orchestrator, not through a leftover single-package config.
 
+### Per-package publish plugins
+
+`plugins` is one list for the whole workspace. `packagePlugins` (config file and programmatic API only, since a list keyed by package name has no natural flag form) replaces that list outright for the packages it names, and every other package keeps the workspace-wide list. The override is not merged with the workspace-wide list: it is the complete list for that package, subject to the same rules as any other (for instance `@semantic-release/git` is required under `commitStrategy: 'per-package'` and rejected under `'single'`). A name that is not a package in the workspace is rejected, so a misspelling cannot leave a package on the default list unnoticed.
+
+The case this exists for is a private package. Such a package still needs its `name@version` tag, its version bump and the dependency cascade to its dependents, because a dependent's own release can hinge on it (a private package whose build output ships inside a published one, for example). It does not need a public GitHub Release, and `@semantic-release/github` marks every release it creates from the release branch as the repository's Latest, so GitHub ends up showing whichever package the run released last, which is often a private one that depends on the rest. Leaving that plugin off the private package's list removes the Release and nothing else:
+
+```ts
+// release-workspace.config.ts
+import { DEFAULT_PUBLISH_PLUGINS, type ReleaseWorkspaceOptions } from '@exadev/semantic-release-workspace';
+
+const config: ReleaseWorkspaceOptions = {
+  packagePlugins: {
+    '@acme/web-console': DEFAULT_PUBLISH_PLUGINS.filter((plugin) => plugin !== '@semantic-release/github'),
+  },
+};
+
+export default config;
+```
+
+The override behaves the same under both commit strategies and with `gatePublish`. A gated run persists each package's pipeline in its state file, so the override reaches `resume` without being repeated there. Under `commitStrategy: 'single'` start from `SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS` instead of `DEFAULT_PUBLISH_PLUGINS`.
+
 ### Programmatic API
 
 ```ts

package/dist/cli.js

@@ -14,7 +14,7 @@ import { generateNotes } from "@semantic-release/release-notes-generator";
 import semanticRelease from "semantic-release";
 import { pathToFileURL } from "node:url";
 //#region package.json
-var version = "2.0.0";
+var version = "2.1.0";
 //#endregion
 //#region src/errors.ts
 /**
@@ -792,6 +792,26 @@ function resolvePublishPlugins(specs, workspaceRoot, options) {
 	return resolved;
 }
 /**
+* Resolves the publish plugin list of every package in the workspace: the workspace-wide list for each package, except where `packagePlugins` names a package, whose own list replaces it. Every list is held to the same rules as `resolvePublishPlugins` applies to a workspace-wide one, and a failure in an override names the package it belongs to.
+*
+* A `packagePlugins` key that matches no package is rejected rather than ignored: a misspelt name would otherwise leave the package it meant on the workspace-wide list with nothing to say so, which for the intended use (keeping a package out of a step such as GitHub Release creation) is a silent wrong result.
+*/
+function resolveWorkspacePublishPlugins(packageNames, specs, workspaceRoot, options) {
+	const overrides = specs.packagePlugins === void 0 ? [] : Object.entries(specs.packagePlugins);
+	const known = new Set(packageNames);
+	const unknown = overrides.map(([name]) => name).filter((name) => !known.has(name));
+	if (unknown.length > 0) throw new ReleaseConfigurationError(`packagePlugins names ${unknown.map((name) => `"${name}"`).join(", ")}, which ${unknown.length === 1 ? "is" : "are"} not a package in this workspace. Packages: ${packageNames.join(", ")}.`);
+	const workspaceWide = resolvePublishPlugins(specs.plugins, workspaceRoot, options);
+	const resolvedOverrides = /* @__PURE__ */ new Map();
+	for (const [name, list] of overrides) try {
+		resolvedOverrides.set(name, resolvePublishPlugins(list, workspaceRoot, options));
+	} catch (cause) {
+		if (cause instanceof ReleaseConfigurationError) throw new ReleaseConfigurationError(`packagePlugins for "${name}": ${cause.message}`);
+		throw cause;
+	}
+	return new Map(packageNames.map((name) => [name, resolvedOverrides.get(name) ?? workspaceWide]));
+}
+/**
 * Resolves a plugin module name to an absolute file path, first from this tool's own module context (its peer dependencies, which every workspace installing the orchestrator must provide) and then from the workspace root (a workspace's own plugin dependencies, such as a custom changelog plugin). Both bases are named in the error when neither can resolve the name.
 */
 function resolvePluginModule(name, requireFromTool, requireFromWorkspace) {
@@ -851,7 +871,10 @@ async function releaseWorkspaceSingleCommit(options) {
 	validateDependencyRanges(graph);
 	const order = topologicalOrder(graph);
 	log(`${packageName}: ${String(order.length)} packages in release order: ${order.join(" -> ")} (commitStrategy: single)`);
-	const resolvedPlugins = resolvePublishPlugins(options.plugins ?? SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS, workspace.root, {
+	const resolvedPlugins = resolveWorkspacePublishPlugins(order, {
+		plugins: options.plugins ?? SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS,
+		packagePlugins: options.packagePlugins
+	}, workspace.root, {
 		requireGitPlugin: false,
 		forbidGitPlugin: true
 	});
@@ -870,7 +893,7 @@ async function releaseWorkspaceSingleCommit(options) {
 		const bumpsForThisPackage = pendingBumps.get(name) ?? [];
 		pendingBumps.delete(name);
 		const nextRelease = await analysePackage(pkg, {
-			resolvedPlugins,
+			resolvedPlugins: mustGet(resolvedPlugins, name, "publish plugins"),
 			analyzeCommitsConfig,
 			generateNotesConfig,
 			bumpsForThisPackage,
@@ -931,7 +954,7 @@ async function releaseWorkspaceSingleCommit(options) {
 		log
 	};
 	const moduleCache = /* @__PURE__ */ new Map();
-	for (const release of planned) for (const [modulePath, pluginConfig] of resolvedPlugins) {
+	for (const release of planned) for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 		const plugin = await loadReleasePlugin(modulePath, moduleCache);
 		if (plugin.verifyConditions) await plugin.verifyConditions(pluginConfig, buildPluginContext(release, shared, capturedCommits, []));
 	}
@@ -942,7 +965,7 @@ async function releaseWorkspaceSingleCommit(options) {
 			await writeDependencyRange(release.pkg.manifestPath, bump.field, bump.dependency, bump.range);
 			anyRangeRewritten = true;
 		}
-		for (const [modulePath, pluginConfig] of resolvedPlugins) {
+		for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 			const plugin = await loadReleasePlugin(modulePath, moduleCache);
 			if (plugin.prepare) await plugin.prepare(pluginConfig, buildPluginContext(release, shared, capturedCommits, []));
 		}
@@ -962,14 +985,14 @@ async function releaseWorkspaceSingleCommit(options) {
 	log(`${packageName}: committed ${commitSha} and pushed ${String(tagNames.length)} tag(s): ${tagNames.join(", ")}`);
 	for (const release of planned) {
 		const releases = [];
-		for (const [modulePath, pluginConfig] of resolvedPlugins) {
+		for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 			const plugin = await loadReleasePlugin(modulePath, moduleCache);
 			if (plugin.publish) {
 				const result = await plugin.publish(pluginConfig, buildPluginContext(release, shared, capturedCommits, releases));
 				if (result !== false && result !== void 0) releases.push(result);
 			}
 		}
-		for (const [modulePath, pluginConfig] of resolvedPlugins) {
+		for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 			const plugin = await loadReleasePlugin(modulePath, moduleCache);
 			if (plugin.success) await plugin.success(pluginConfig, buildPluginContext(release, shared, capturedCommits, releases));
 		}
@@ -1130,14 +1153,17 @@ async function releaseWorkspace(options = {}) {
 	validateDependencyRanges(graph);
 	const order = topologicalOrder(graph);
 	log(`${packageName}: ${String(order.length)} packages in release order: ${order.join(" -> ")}`);
-	const publishPlugins = resolvePublishPlugins(options.plugins ?? DEFAULT_PUBLISH_PLUGINS, workspace.root, { requireGitPlugin: !dryRun });
+	const publishPlugins = resolveWorkspacePublishPlugins(order, {
+		plugins: options.plugins ?? DEFAULT_PUBLISH_PLUGINS,
+		packagePlugins: options.packagePlugins
+	}, workspace.root, { requireGitPlugin: !dryRun });
 	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, {
-				publishPlugins,
+				publishPlugins: mustGet(publishPlugins, pkg.name, "publish plugins"),
 				analyzeCommitsConfig,
 				generateNotesConfig,
 				bumpsForThisPackage,
@@ -1293,12 +1319,15 @@ async function detachWorkspaceRelease(options) {
 	validateDependencyRanges(graph);
 	const order = topologicalOrder(graph);
 	log(`${packageName}: ${String(order.length)} packages in release order (gated -- tag only, publish deferred): ${order.join(" -> ")}`);
-	const publishPlugins = resolvePublishPlugins(options.plugins ?? DEFAULT_PUBLISH_PLUGINS, workspace.root, { requireGitPlugin: !dryRun });
+	const publishPlugins = resolveWorkspacePublishPlugins(order, {
+		plugins: options.plugins ?? DEFAULT_PUBLISH_PLUGINS,
+		packagePlugins: options.packagePlugins
+	}, workspace.root, { requireGitPlugin: !dryRun });
 	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, {
-			publishPlugins,
+			publishPlugins: mustGet(publishPlugins, pkg.name, "publish plugins"),
 			analyzeCommitsConfig,
 			generateNotesConfig,
 			bumpsForThisPackage,
@@ -1427,6 +1456,7 @@ const CONFIG_OPTION_KEYS = /* @__PURE__ */ new Set([
 	"dryRun",
 	"branches",
 	"plugins",
+	"packagePlugins",
 	"analyzeCommits",
 	"generateNotes",
 	"commitStrategy",
@@ -1454,7 +1484,7 @@ function createProgram() {
 	release.option("--commit-strategy <mode>", "how the run commits its released changes: \"per-package\" (default; today's behaviour, one commit per release plus one per dependency bump) or \"single\" (one combined commit for the whole run, tagged once per released package)", parseCommitStrategy);
 	release.option("--gate-publish", "tag and push each due package via @exadev/release-gate, but defer publishing -- requires --gate-state-file, and cannot be combined with --commit-strategy single");
 	release.option("--gate-state-file <path>", "with --gate-publish: where to write the state a later \"resume\" run needs to finish publishing");
-	release.option("--config <file>", "config file (.json, .yaml, .yml, .js, .cjs, or .ts) providing any of the release options (dryRun, branches, plugins, analyzeCommits, generateNotes, commitStrategy, gatePublish); explicit flags win");
+	release.option("--config <file>", "config file (.json, .yaml, .yml, .js, .cjs, or .ts) providing any of the release options (dryRun, branches, plugins, packagePlugins, analyzeCommits, generateNotes, commitStrategy, gatePublish); explicit flags win");
 	release.action(runRelease);
 	const resume = program.command("resume");
 	resume.description("Finish publishing every package a --gate-publish release tagged and pushed but did not publish.");
@@ -1471,6 +1501,7 @@ const NO_CONFIG_FILE = {
 	dryRun: void 0,
 	branches: void 0,
 	plugins: void 0,
+	packagePlugins: void 0,
 	analyzeCommits: void 0,
 	generateNotes: void 0,
 	commitStrategy: void 0,
@@ -1485,6 +1516,7 @@ async function runRelease(flags) {
 		dryRun: flags.dryRun ?? (file.dryRun === true ? true : void 0),
 		branches: flags.branches.length > 0 ? flags.branches : file.branches,
 		plugins: flags.plugin.length > 0 ? flags.plugin.map((spec) => parsePluginSpec(spec)) : file.plugins,
+		packagePlugins: file.packagePlugins,
 		analyzeCommits: flags.analyzeCommits === void 0 ? file.analyzeCommits : parseJsonObjectFlag(flags.analyzeCommits, "--analyze-commits"),
 		generateNotes: flags.generateNotes === void 0 ? file.generateNotes : parseJsonObjectFlag(flags.generateNotes, "--generate-notes"),
 		commitStrategy: flags.commitStrategy ?? file.commitStrategy,
@@ -1549,10 +1581,11 @@ async function readReleaseConfigFile(path) {
 	const parsed = await readConfigFile(path);
 	if (!isJsonObject(parsed)) throw new InvalidArgumentError(`--config file ${path} must contain a JSON object`);
 	for (const key of Object.keys(parsed)) if (!CONFIG_OPTION_KEYS.has(key)) throw new InvalidArgumentError(`--config file ${path} has an unknown option "${key}"; recognised options: ${[...CONFIG_OPTION_KEYS].join(", ")}`);
-	const { dryRun, branches, plugins, analyzeCommits, generateNotes, commitStrategy, gatePublish } = parsed;
+	const { dryRun, branches, plugins, packagePlugins, analyzeCommits, generateNotes, commitStrategy, gatePublish } = parsed;
 	if (dryRun !== void 0 && typeof dryRun !== "boolean") throw new InvalidArgumentError(`--config file ${path}: "dryRun" must be a boolean`);
 	if (branches !== void 0 && !isStringArray(branches)) throw new InvalidArgumentError(`--config file ${path}: "branches" must be an array of branch name strings`);
 	if (plugins !== void 0 && !Array.isArray(plugins)) throw new InvalidArgumentError(`--config file ${path}: "plugins" must be an array`);
+	if (packagePlugins !== void 0 && !isJsonObject(packagePlugins)) throw new InvalidArgumentError(`--config file ${path}: "packagePlugins" must be an object mapping package names to plugin arrays`);
 	if (analyzeCommits !== void 0 && !isJsonObject(analyzeCommits)) throw new InvalidArgumentError(`--config file ${path}: "analyzeCommits" must be an object`);
 	if (generateNotes !== void 0 && !isJsonObject(generateNotes)) throw new InvalidArgumentError(`--config file ${path}: "generateNotes" must be an object`);
 	if (commitStrategy !== void 0 && (typeof commitStrategy !== "string" || !isCommitStrategy(commitStrategy))) throw new InvalidArgumentError(`--config file ${path}: "commitStrategy" must be one of: ${[...COMMIT_STRATEGIES].join(", ")}`);
@@ -1561,16 +1594,25 @@ async function readReleaseConfigFile(path) {
 		dryRun,
 		branches,
 		plugins: plugins === void 0 ? void 0 : plugins.map((spec) => parseConfigFilePlugin(spec, path)),
+		packagePlugins: packagePlugins === void 0 ? void 0 : parseConfigFilePackagePlugins(packagePlugins, path),
 		analyzeCommits,
 		generateNotes,
 		commitStrategy,
 		gatePublish
 	};
 }
-function parseConfigFilePlugin(spec, path) {
+function parseConfigFilePackagePlugins(packagePlugins, path) {
+	const parsed = {};
+	for (const [name, list] of Object.entries(packagePlugins)) {
+		if (!Array.isArray(list)) throw new InvalidArgumentError(`--config file ${path}: the "packagePlugins" entry for "${name}" must be an array`);
+		parsed[name] = list.map((spec) => parseConfigFilePlugin(spec, path, "packagePlugins"));
+	}
+	return parsed;
+}
+function parseConfigFilePlugin(spec, path, key = "plugins") {
 	if (typeof spec === "string") return spec;
 	if (isPluginSpecTuple(spec)) return spec;
-	throw new InvalidArgumentError(`--config file ${path}: each "plugins" entry must be a module name or a [name, config] array`);
+	throw new InvalidArgumentError(`--config file ${path}: each "${key}" entry must be a module name or a [name, config] array`);
 }
 function parseJson(raw, flag) {
 	try {

package/dist/index.cjs

@@ -805,6 +805,26 @@ function resolvePublishPlugins(specs, workspaceRoot, options) {
 	return resolved;
 }
 /**
+* Resolves the publish plugin list of every package in the workspace: the workspace-wide list for each package, except where `packagePlugins` names a package, whose own list replaces it. Every list is held to the same rules as `resolvePublishPlugins` applies to a workspace-wide one, and a failure in an override names the package it belongs to.
+*
+* A `packagePlugins` key that matches no package is rejected rather than ignored: a misspelt name would otherwise leave the package it meant on the workspace-wide list with nothing to say so, which for the intended use (keeping a package out of a step such as GitHub Release creation) is a silent wrong result.
+*/
+function resolveWorkspacePublishPlugins(packageNames, specs, workspaceRoot, options) {
+	const overrides = specs.packagePlugins === void 0 ? [] : Object.entries(specs.packagePlugins);
+	const known = new Set(packageNames);
+	const unknown = overrides.map(([name]) => name).filter((name) => !known.has(name));
+	if (unknown.length > 0) throw new ReleaseConfigurationError(`packagePlugins names ${unknown.map((name) => `"${name}"`).join(", ")}, which ${unknown.length === 1 ? "is" : "are"} not a package in this workspace. Packages: ${packageNames.join(", ")}.`);
+	const workspaceWide = resolvePublishPlugins(specs.plugins, workspaceRoot, options);
+	const resolvedOverrides = /* @__PURE__ */ new Map();
+	for (const [name, list] of overrides) try {
+		resolvedOverrides.set(name, resolvePublishPlugins(list, workspaceRoot, options));
+	} catch (cause) {
+		if (cause instanceof ReleaseConfigurationError) throw new ReleaseConfigurationError(`packagePlugins for "${name}": ${cause.message}`);
+		throw cause;
+	}
+	return new Map(packageNames.map((name) => [name, resolvedOverrides.get(name) ?? workspaceWide]));
+}
+/**
 * Resolves a plugin module name to an absolute file path, first from this tool's own module context (its peer dependencies, which every workspace installing the orchestrator must provide) and then from the workspace root (a workspace's own plugin dependencies, such as a custom changelog plugin). Both bases are named in the error when neither can resolve the name.
 */
 function resolvePluginModule(name, requireFromTool, requireFromWorkspace) {
@@ -864,7 +884,10 @@ async function releaseWorkspaceSingleCommit(options) {
 	validateDependencyRanges(graph);
 	const order = topologicalOrder(graph);
 	log(`${packageName}: ${String(order.length)} packages in release order: ${order.join(" -> ")} (commitStrategy: single)`);
-	const resolvedPlugins = resolvePublishPlugins(options.plugins ?? SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS, workspace.root, {
+	const resolvedPlugins = resolveWorkspacePublishPlugins(order, {
+		plugins: options.plugins ?? SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS,
+		packagePlugins: options.packagePlugins
+	}, workspace.root, {
 		requireGitPlugin: false,
 		forbidGitPlugin: true
 	});
@@ -883,7 +906,7 @@ async function releaseWorkspaceSingleCommit(options) {
 		const bumpsForThisPackage = pendingBumps.get(name) ?? [];
 		pendingBumps.delete(name);
 		const nextRelease = await analysePackage(pkg, {
-			resolvedPlugins,
+			resolvedPlugins: mustGet(resolvedPlugins, name, "publish plugins"),
 			analyzeCommitsConfig,
 			generateNotesConfig,
 			bumpsForThisPackage,
@@ -944,7 +967,7 @@ async function releaseWorkspaceSingleCommit(options) {
 		log
 	};
 	const moduleCache = /* @__PURE__ */ new Map();
-	for (const release of planned) for (const [modulePath, pluginConfig] of resolvedPlugins) {
+	for (const release of planned) for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 		const plugin = await loadReleasePlugin(modulePath, moduleCache);
 		if (plugin.verifyConditions) await plugin.verifyConditions(pluginConfig, buildPluginContext(release, shared, capturedCommits, []));
 	}
@@ -955,7 +978,7 @@ async function releaseWorkspaceSingleCommit(options) {
 			await writeDependencyRange(release.pkg.manifestPath, bump.field, bump.dependency, bump.range);
 			anyRangeRewritten = true;
 		}
-		for (const [modulePath, pluginConfig] of resolvedPlugins) {
+		for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 			const plugin = await loadReleasePlugin(modulePath, moduleCache);
 			if (plugin.prepare) await plugin.prepare(pluginConfig, buildPluginContext(release, shared, capturedCommits, []));
 		}
@@ -975,14 +998,14 @@ async function releaseWorkspaceSingleCommit(options) {
 	log(`${packageName}: committed ${commitSha} and pushed ${String(tagNames.length)} tag(s): ${tagNames.join(", ")}`);
 	for (const release of planned) {
 		const releases = [];
-		for (const [modulePath, pluginConfig] of resolvedPlugins) {
+		for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 			const plugin = await loadReleasePlugin(modulePath, moduleCache);
 			if (plugin.publish) {
 				const result = await plugin.publish(pluginConfig, buildPluginContext(release, shared, capturedCommits, releases));
 				if (result !== false && result !== void 0) releases.push(result);
 			}
 		}
-		for (const [modulePath, pluginConfig] of resolvedPlugins) {
+		for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 			const plugin = await loadReleasePlugin(modulePath, moduleCache);
 			if (plugin.success) await plugin.success(pluginConfig, buildPluginContext(release, shared, capturedCommits, releases));
 		}
@@ -1136,12 +1159,15 @@ async function detachWorkspaceRelease(options) {
 	validateDependencyRanges(graph);
 	const order = topologicalOrder(graph);
 	log(`${packageName}: ${String(order.length)} packages in release order (gated -- tag only, publish deferred): ${order.join(" -> ")}`);
-	const publishPlugins = resolvePublishPlugins(options.plugins ?? DEFAULT_PUBLISH_PLUGINS, workspace.root, { requireGitPlugin: !dryRun });
+	const publishPlugins = resolveWorkspacePublishPlugins(order, {
+		plugins: options.plugins ?? DEFAULT_PUBLISH_PLUGINS,
+		packagePlugins: options.packagePlugins
+	}, workspace.root, { requireGitPlugin: !dryRun });
 	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, {
-			publishPlugins,
+			publishPlugins: mustGet(publishPlugins, pkg.name, "publish plugins"),
 			analyzeCommitsConfig,
 			generateNotesConfig,
 			bumpsForThisPackage,
@@ -1274,14 +1300,17 @@ async function releaseWorkspace(options = {}) {
 	validateDependencyRanges(graph);
 	const order = topologicalOrder(graph);
 	log(`${packageName}: ${String(order.length)} packages in release order: ${order.join(" -> ")}`);
-	const publishPlugins = resolvePublishPlugins(options.plugins ?? DEFAULT_PUBLISH_PLUGINS, workspace.root, { requireGitPlugin: !dryRun });
+	const publishPlugins = resolveWorkspacePublishPlugins(order, {
+		plugins: options.plugins ?? DEFAULT_PUBLISH_PLUGINS,
+		packagePlugins: options.packagePlugins
+	}, workspace.root, { requireGitPlugin: !dryRun });
 	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, {
-				publishPlugins,
+				publishPlugins: mustGet(publishPlugins, pkg.name, "publish plugins"),
 				analyzeCommitsConfig,
 				generateNotesConfig,
 				bumpsForThisPackage,
@@ -1441,6 +1470,7 @@ exports.packageName = packageName;
 exports.readManifest = readManifest;
 exports.releaseWorkspace = releaseWorkspace;
 exports.resolvePublishPlugins = resolvePublishPlugins;
+exports.resolveWorkspacePublishPlugins = resolveWorkspacePublishPlugins;
 exports.resumeWorkspaceRelease = resumeWorkspaceRelease;
 exports.topologicalOrder = topologicalOrder;
 exports.updateDependencyRange = updateDependencyRange;

package/dist/index.d.cts

@@ -147,6 +147,8 @@ interface DependencyBumpSource {
 }
 /** A publish-pipeline plugin entry as the orchestrator accepts it: a module name, optionally with a config object. */
 type PublishPluginSpec = string | readonly [string] | readonly [string, Record<string, unknown>];
+/** Publish plugin lists keyed by package name. Each list replaces the workspace-wide list outright for that one package; it is not merged with it. */
+type PackagePluginSpecs = Readonly<Record<string, readonly PublishPluginSpec[]>>;
 /** The standard publish pipeline this orchestrator coordinates when a workspace configures none of its own. Every entry reuses the corresponding official plugin -- the orchestrator scopes and sequences them per package, it does not reimplement npm publishing, GitHub release creation, or changelog writing. */
 export declare const DEFAULT_PUBLISH_PLUGINS: readonly PublishPluginSpec[];
 /** The standard publish pipeline for `commitStrategy: 'single'`: the same as `DEFAULT_PUBLISH_PLUGINS` minus `@semantic-release/git`, which that mode never runs -- see `resolvePublishPlugins`'s `forbidGitPlugin` option for why it is rejected outright rather than merely unused. Single-commit mode does its own committing (one combined commit for every released package), so a `prepare`-step git plugin here would create the very per-package commits that mode exists to avoid. */
@@ -188,6 +190,18 @@ export declare function resolvePublishPlugins(specs: readonly PublishPluginSpec[
   readonly requireGitPlugin: boolean;
   readonly forbidGitPlugin?: boolean;
 }): readonly ResolvedPublishPlugin[];
+/**
+ * Resolves the publish plugin list of every package in the workspace: the workspace-wide list for each package, except where `packagePlugins` names a package, whose own list replaces it. Every list is held to the same rules as `resolvePublishPlugins` applies to a workspace-wide one, and a failure in an override names the package it belongs to.
+ *
+ * A `packagePlugins` key that matches no package is rejected rather than ignored: a misspelt name would otherwise leave the package it meant on the workspace-wide list with nothing to say so, which for the intended use (keeping a package out of a step such as GitHub Release creation) is a silent wrong result.
+ */
+export declare function resolveWorkspacePublishPlugins(packageNames: readonly string[], specs: {
+  readonly plugins: readonly PublishPluginSpec[];
+  readonly packagePlugins: PackagePluginSpecs | undefined;
+}, workspaceRoot: string, options: {
+  readonly requireGitPlugin: boolean;
+  readonly forbidGitPlugin?: boolean;
+}): ReadonlyMap<string, readonly ResolvedPublishPlugin[]>;
 //#endregion
 //#region src/gate-publish.d.ts
 /**
@@ -232,6 +246,8 @@ interface ReleaseWorkspaceOptions {
   readonly branches?: readonly BranchSpec[];
   /** Publish-pipeline plugins (changelog, npm, GitHub, git), each scoped per package by semantic-release's own `cwd`. Defaults to the standard pipeline in DEFAULT_PUBLISH_PLUGINS for `commitStrategy: 'per-package'`, or SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS (the same list minus `@semantic-release/git`) for `commitStrategy: 'single'`. */
   readonly plugins?: readonly PublishPluginSpec[];
+  /** Publish plugin lists for individual packages, keyed by package name, each replacing `plugins` (or its default) outright for that package. Every other package keeps the workspace-wide list. The usual use is keeping one package out of a step the rest need, for example leaving `@semantic-release/github` off a private package so it gets its tag, version bump and dependency cascade without a public GitHub Release. Applies under every `commitStrategy` and to `gatePublish`. A name that is not a package in the workspace is rejected. */
+  readonly packagePlugins?: PackagePluginSpecs;
   /** Options for the wrapped `@semantic-release/commit-analyzer`, applied per package after path filtering. */
   readonly analyzeCommits?: Record<string, unknown>;
   /** Options for the wrapped `@semantic-release/release-notes-generator`, applied per package after path filtering. */
@@ -310,4 +326,4 @@ export declare class GitCommandError extends WorkspaceReleaseError {
 /** The workspace's git state does not support the release operation -- for example a detached HEAD, which names no branch that dependency-bump commits could be pushed to. */
 export declare class WorkspaceStateError extends WorkspaceReleaseError {}
 //#endregion
-export type { AppliedDependencyBump, CommitStrategy, DependencyBump, DependencyBumpSource, DependencyField, DependencyGraph, DependencyRangeShape, DependencyRangeUpdate, DetachedPackageRelease, PackageManifest, PackageReleaseOutcome, PublishPluginSpec, ReleaseWorkspaceOptions, ResolvedPublishPlugin, ResumeWorkspaceReleaseOptions, ScopedPlugins, Workspace, WorkspaceDependency, WorkspacePackage, WorkspaceReleaseOutcome };
+export type { AppliedDependencyBump, CommitStrategy, DependencyBump, DependencyBumpSource, DependencyField, DependencyGraph, DependencyRangeShape, DependencyRangeUpdate, DetachedPackageRelease, PackageManifest, PackagePluginSpecs, PackageReleaseOutcome, PublishPluginSpec, ReleaseWorkspaceOptions, ResolvedPublishPlugin, ResumeWorkspaceReleaseOptions, ScopedPlugins, Workspace, WorkspaceDependency, WorkspacePackage, WorkspaceReleaseOutcome };

package/dist/index.d.ts

@@ -147,6 +147,8 @@ interface DependencyBumpSource {
 }
 /** A publish-pipeline plugin entry as the orchestrator accepts it: a module name, optionally with a config object. */
 type PublishPluginSpec = string | readonly [string] | readonly [string, Record<string, unknown>];
+/** Publish plugin lists keyed by package name. Each list replaces the workspace-wide list outright for that one package; it is not merged with it. */
+type PackagePluginSpecs = Readonly<Record<string, readonly PublishPluginSpec[]>>;
 /** The standard publish pipeline this orchestrator coordinates when a workspace configures none of its own. Every entry reuses the corresponding official plugin -- the orchestrator scopes and sequences them per package, it does not reimplement npm publishing, GitHub release creation, or changelog writing. */
 export declare const DEFAULT_PUBLISH_PLUGINS: readonly PublishPluginSpec[];
 /** The standard publish pipeline for `commitStrategy: 'single'`: the same as `DEFAULT_PUBLISH_PLUGINS` minus `@semantic-release/git`, which that mode never runs -- see `resolvePublishPlugins`'s `forbidGitPlugin` option for why it is rejected outright rather than merely unused. Single-commit mode does its own committing (one combined commit for every released package), so a `prepare`-step git plugin here would create the very per-package commits that mode exists to avoid. */
@@ -188,6 +190,18 @@ export declare function resolvePublishPlugins(specs: readonly PublishPluginSpec[
   readonly requireGitPlugin: boolean;
   readonly forbidGitPlugin?: boolean;
 }): readonly ResolvedPublishPlugin[];
+/**
+ * Resolves the publish plugin list of every package in the workspace: the workspace-wide list for each package, except where `packagePlugins` names a package, whose own list replaces it. Every list is held to the same rules as `resolvePublishPlugins` applies to a workspace-wide one, and a failure in an override names the package it belongs to.
+ *
+ * A `packagePlugins` key that matches no package is rejected rather than ignored: a misspelt name would otherwise leave the package it meant on the workspace-wide list with nothing to say so, which for the intended use (keeping a package out of a step such as GitHub Release creation) is a silent wrong result.
+ */
+export declare function resolveWorkspacePublishPlugins(packageNames: readonly string[], specs: {
+  readonly plugins: readonly PublishPluginSpec[];
+  readonly packagePlugins: PackagePluginSpecs | undefined;
+}, workspaceRoot: string, options: {
+  readonly requireGitPlugin: boolean;
+  readonly forbidGitPlugin?: boolean;
+}): ReadonlyMap<string, readonly ResolvedPublishPlugin[]>;
 //#endregion
 //#region src/gate-publish.d.ts
 /**
@@ -232,6 +246,8 @@ interface ReleaseWorkspaceOptions {
   readonly branches?: readonly BranchSpec[];
   /** Publish-pipeline plugins (changelog, npm, GitHub, git), each scoped per package by semantic-release's own `cwd`. Defaults to the standard pipeline in DEFAULT_PUBLISH_PLUGINS for `commitStrategy: 'per-package'`, or SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS (the same list minus `@semantic-release/git`) for `commitStrategy: 'single'`. */
   readonly plugins?: readonly PublishPluginSpec[];
+  /** Publish plugin lists for individual packages, keyed by package name, each replacing `plugins` (or its default) outright for that package. Every other package keeps the workspace-wide list. The usual use is keeping one package out of a step the rest need, for example leaving `@semantic-release/github` off a private package so it gets its tag, version bump and dependency cascade without a public GitHub Release. Applies under every `commitStrategy` and to `gatePublish`. A name that is not a package in the workspace is rejected. */
+  readonly packagePlugins?: PackagePluginSpecs;
   /** Options for the wrapped `@semantic-release/commit-analyzer`, applied per package after path filtering. */
   readonly analyzeCommits?: Record<string, unknown>;
   /** Options for the wrapped `@semantic-release/release-notes-generator`, applied per package after path filtering. */
@@ -310,4 +326,4 @@ export declare class GitCommandError extends WorkspaceReleaseError {
 /** The workspace's git state does not support the release operation -- for example a detached HEAD, which names no branch that dependency-bump commits could be pushed to. */
 export declare class WorkspaceStateError extends WorkspaceReleaseError {}
 //#endregion
-export type { AppliedDependencyBump, CommitStrategy, DependencyBump, DependencyBumpSource, DependencyField, DependencyGraph, DependencyRangeShape, DependencyRangeUpdate, DetachedPackageRelease, PackageManifest, PackageReleaseOutcome, PublishPluginSpec, ReleaseWorkspaceOptions, ResolvedPublishPlugin, ResumeWorkspaceReleaseOptions, ScopedPlugins, Workspace, WorkspaceDependency, WorkspacePackage, WorkspaceReleaseOutcome };
+export type { AppliedDependencyBump, CommitStrategy, DependencyBump, DependencyBumpSource, DependencyField, DependencyGraph, DependencyRangeShape, DependencyRangeUpdate, DetachedPackageRelease, PackageManifest, PackagePluginSpecs, PackageReleaseOutcome, PublishPluginSpec, ReleaseWorkspaceOptions, ResolvedPublishPlugin, ResumeWorkspaceReleaseOptions, ScopedPlugins, Workspace, WorkspaceDependency, WorkspacePackage, WorkspaceReleaseOutcome };

package/dist/index.js

@@ -780,6 +780,26 @@ function resolvePublishPlugins(specs, workspaceRoot, options) {
 	return resolved;
 }
 /**
+* Resolves the publish plugin list of every package in the workspace: the workspace-wide list for each package, except where `packagePlugins` names a package, whose own list replaces it. Every list is held to the same rules as `resolvePublishPlugins` applies to a workspace-wide one, and a failure in an override names the package it belongs to.
+*
+* A `packagePlugins` key that matches no package is rejected rather than ignored: a misspelt name would otherwise leave the package it meant on the workspace-wide list with nothing to say so, which for the intended use (keeping a package out of a step such as GitHub Release creation) is a silent wrong result.
+*/
+function resolveWorkspacePublishPlugins(packageNames, specs, workspaceRoot, options) {
+	const overrides = specs.packagePlugins === void 0 ? [] : Object.entries(specs.packagePlugins);
+	const known = new Set(packageNames);
+	const unknown = overrides.map(([name]) => name).filter((name) => !known.has(name));
+	if (unknown.length > 0) throw new ReleaseConfigurationError(`packagePlugins names ${unknown.map((name) => `"${name}"`).join(", ")}, which ${unknown.length === 1 ? "is" : "are"} not a package in this workspace. Packages: ${packageNames.join(", ")}.`);
+	const workspaceWide = resolvePublishPlugins(specs.plugins, workspaceRoot, options);
+	const resolvedOverrides = /* @__PURE__ */ new Map();
+	for (const [name, list] of overrides) try {
+		resolvedOverrides.set(name, resolvePublishPlugins(list, workspaceRoot, options));
+	} catch (cause) {
+		if (cause instanceof ReleaseConfigurationError) throw new ReleaseConfigurationError(`packagePlugins for "${name}": ${cause.message}`);
+		throw cause;
+	}
+	return new Map(packageNames.map((name) => [name, resolvedOverrides.get(name) ?? workspaceWide]));
+}
+/**
 * Resolves a plugin module name to an absolute file path, first from this tool's own module context (its peer dependencies, which every workspace installing the orchestrator must provide) and then from the workspace root (a workspace's own plugin dependencies, such as a custom changelog plugin). Both bases are named in the error when neither can resolve the name.
 */
 function resolvePluginModule(name, requireFromTool, requireFromWorkspace) {
@@ -839,7 +859,10 @@ async function releaseWorkspaceSingleCommit(options) {
 	validateDependencyRanges(graph);
 	const order = topologicalOrder(graph);
 	log(`${packageName}: ${String(order.length)} packages in release order: ${order.join(" -> ")} (commitStrategy: single)`);
-	const resolvedPlugins = resolvePublishPlugins(options.plugins ?? SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS, workspace.root, {
+	const resolvedPlugins = resolveWorkspacePublishPlugins(order, {
+		plugins: options.plugins ?? SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS,
+		packagePlugins: options.packagePlugins
+	}, workspace.root, {
 		requireGitPlugin: false,
 		forbidGitPlugin: true
 	});
@@ -858,7 +881,7 @@ async function releaseWorkspaceSingleCommit(options) {
 		const bumpsForThisPackage = pendingBumps.get(name) ?? [];
 		pendingBumps.delete(name);
 		const nextRelease = await analysePackage(pkg, {
-			resolvedPlugins,
+			resolvedPlugins: mustGet(resolvedPlugins, name, "publish plugins"),
 			analyzeCommitsConfig,
 			generateNotesConfig,
 			bumpsForThisPackage,
@@ -919,7 +942,7 @@ async function releaseWorkspaceSingleCommit(options) {
 		log
 	};
 	const moduleCache = /* @__PURE__ */ new Map();
-	for (const release of planned) for (const [modulePath, pluginConfig] of resolvedPlugins) {
+	for (const release of planned) for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 		const plugin = await loadReleasePlugin(modulePath, moduleCache);
 		if (plugin.verifyConditions) await plugin.verifyConditions(pluginConfig, buildPluginContext(release, shared, capturedCommits, []));
 	}
@@ -930,7 +953,7 @@ async function releaseWorkspaceSingleCommit(options) {
 			await writeDependencyRange(release.pkg.manifestPath, bump.field, bump.dependency, bump.range);
 			anyRangeRewritten = true;
 		}
-		for (const [modulePath, pluginConfig] of resolvedPlugins) {
+		for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 			const plugin = await loadReleasePlugin(modulePath, moduleCache);
 			if (plugin.prepare) await plugin.prepare(pluginConfig, buildPluginContext(release, shared, capturedCommits, []));
 		}
@@ -950,14 +973,14 @@ async function releaseWorkspaceSingleCommit(options) {
 	log(`${packageName}: committed ${commitSha} and pushed ${String(tagNames.length)} tag(s): ${tagNames.join(", ")}`);
 	for (const release of planned) {
 		const releases = [];
-		for (const [modulePath, pluginConfig] of resolvedPlugins) {
+		for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 			const plugin = await loadReleasePlugin(modulePath, moduleCache);
 			if (plugin.publish) {
 				const result = await plugin.publish(pluginConfig, buildPluginContext(release, shared, capturedCommits, releases));
 				if (result !== false && result !== void 0) releases.push(result);
 			}
 		}
-		for (const [modulePath, pluginConfig] of resolvedPlugins) {
+		for (const [modulePath, pluginConfig] of mustGet(resolvedPlugins, release.pkg.name, "publish plugins")) {
 			const plugin = await loadReleasePlugin(modulePath, moduleCache);
 			if (plugin.success) await plugin.success(pluginConfig, buildPluginContext(release, shared, capturedCommits, releases));
 		}
@@ -1111,12 +1134,15 @@ async function detachWorkspaceRelease(options) {
 	validateDependencyRanges(graph);
 	const order = topologicalOrder(graph);
 	log(`${packageName}: ${String(order.length)} packages in release order (gated -- tag only, publish deferred): ${order.join(" -> ")}`);
-	const publishPlugins = resolvePublishPlugins(options.plugins ?? DEFAULT_PUBLISH_PLUGINS, workspace.root, { requireGitPlugin: !dryRun });
+	const publishPlugins = resolveWorkspacePublishPlugins(order, {
+		plugins: options.plugins ?? DEFAULT_PUBLISH_PLUGINS,
+		packagePlugins: options.packagePlugins
+	}, workspace.root, { requireGitPlugin: !dryRun });
 	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, {
-			publishPlugins,
+			publishPlugins: mustGet(publishPlugins, pkg.name, "publish plugins"),
 			analyzeCommitsConfig,
 			generateNotesConfig,
 			bumpsForThisPackage,
@@ -1249,14 +1275,17 @@ async function releaseWorkspace(options = {}) {
 	validateDependencyRanges(graph);
 	const order = topologicalOrder(graph);
 	log(`${packageName}: ${String(order.length)} packages in release order: ${order.join(" -> ")}`);
-	const publishPlugins = resolvePublishPlugins(options.plugins ?? DEFAULT_PUBLISH_PLUGINS, workspace.root, { requireGitPlugin: !dryRun });
+	const publishPlugins = resolveWorkspacePublishPlugins(order, {
+		plugins: options.plugins ?? DEFAULT_PUBLISH_PLUGINS,
+		packagePlugins: options.packagePlugins
+	}, workspace.root, { requireGitPlugin: !dryRun });
 	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, {
-				publishPlugins,
+				publishPlugins: mustGet(publishPlugins, pkg.name, "publish plugins"),
 				analyzeCommitsConfig,
 				generateNotesConfig,
 				bumpsForThisPackage,
@@ -1398,4 +1427,4 @@ async function bumpDependents(released, version, graph, options) {
 	return applied;
 }
 //#endregion
-export { DEFAULT_PUBLISH_PLUGINS, DependencyCycleError, GitCommandError, ReleaseConfigurationError, SINGLE_COMMIT_DEFAULT_PUBLISH_PLUGINS, UnsupportedDependencyRangeError, WorkspaceDiscoveryError, WorkspaceReleaseError, WorkspaceStateError, buildDependencyGraph, classifyDependencyRange, createScopedPlugins, discoverWorkspace, filterCommitsToDirectory, packageName, readManifest, releaseWorkspace, resolvePublishPlugins, 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, packageName, readManifest, releaseWorkspace, resolvePublishPlugins, resolveWorkspacePublishPlugins, resumeWorkspaceRelease, topologicalOrder, updateDependencyRange, writeDependencyRange };

package/package.json

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