@exadev/semantic-release-workspace 3.0.0 → 3.0.1

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 = "3.0.0";
+var version = "3.0.1";
 //#endregion
 //#region src/errors.ts
 /**
@@ -279,6 +279,53 @@ async function pushHeadAndTags(tagNames, options) {
 		...tagNames
 	], options);
 }
+/**
+* Fetches `branch` from origin and returns the commit it now points at.
+*
+* This is how a failed push is classified, in preference to reading the reason git printed for the rejection. The wording is not stable enough to branch on: the same race produces `! [rejected] ... (non-fast-forward)` from one server and `cannot lock ref 'refs/heads/main': is at <x> but expected <y>` from another (both observed, the first against GitHub and the second against a local bare repository under `--atomic`), and neither is a documented interface. Whether the branch actually moved is a fact about the remote rather than a string, it is the precise condition a retry can recover from, and it is knowable by asking.
+*/
+async function fetchBranchTip(branch, options) {
+	await git([
+		"fetch",
+		"origin",
+		branch
+	], options);
+	return (await git(["rev-parse", "FETCH_HEAD"], options)).trim();
+}
+/** Whether `ancestor` is reachable from `descendant`. `git merge-base --is-ancestor` reports the answer as an exit status rather than on stdout: 0 for yes and 1 for no are both answers, so only any other exit code is a failure. */
+async function isAncestor(ancestor, descendant, options) {
+	const args = [
+		"merge-base",
+		"--is-ancestor",
+		ancestor,
+		descendant
+	];
+	try {
+		await execGit(args, options.cwd);
+		return true;
+	} catch (cause) {
+		const error = toGitCommandError(args, options.cwd, cause);
+		if (error.exitCode === 1) return false;
+		throw error;
+	}
+}
+/** Discards every commit and working-tree change the current attempt made, putting the checkout back on exactly `ref`. */
+async function resetHardTo(ref, options) {
+	await git([
+		"reset",
+		"--hard",
+		ref
+	], options);
+}
+/** Deletes local tags. A retried attempt must drop the tags its predecessor created before it recreates them: `git tag` refuses a name that already exists, so without this the second attempt fails while tagging, before it ever reaches the push it was retrying. */
+async function deleteLocalTags(tagNames, options) {
+	if (tagNames.length === 0) return;
+	await git([
+		"tag",
+		"-d",
+		...tagNames
+	], options);
+}
 function toGitCommandError(args, cwd, cause) {
 	const exitCode = cause instanceof Error && "code" in cause && typeof cause.code === "number" ? cause.code : void 0;
 	const stderr = cause instanceof Error && "stderr" in cause && typeof cause.stderr === "string" ? cause.stderr.trim() : "";
@@ -887,6 +934,27 @@ async function regenerateLockfile(options) {
 * Why publish is not just another semantic-release() call: semantic-release's own `run()` unconditionally derives `lastRelease` from the newest tag already on the branch matching `tagFormat`, and this mode has, by the time phase 5 runs, already created and pushed that exact tag itself. A second real `semanticRelease()` call would see its own just-created tag as the already-published release and compute the wrong next version from it. Phase 5 instead calls each resolved plugin module's own exported `verifyConditions`/`publish`/`success` functions directly, with a hand-built context -- the same public per-plugin API surface semantic-release's own core calls internally, just invoked without going through the parts of `run()` that assume a not-yet-tagged repository.
 */
 async function releaseWorkspaceSingleCommit(options) {
+	const log = options.log ?? console.log;
+	const maxAttempts = resolvePushAttempts(options.pushAttempts);
+	let lastLoss;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+		const result = await attemptSingleCommitRelease(options);
+		if (result.kind === "complete") return result.outcome;
+		if (result.kind === "pushed") {
+			await result.publish();
+			return result.outcome;
+		}
+		lastLoss = result.error;
+		log(`${packageName}: attempt ${String(attempt)} of ${String(maxAttempts)} lost the push, because ${result.branch} advanced to ${result.remoteTip} before this run's own refs reached the remote. This attempt's commit and tags have been discarded; recomputing the release against the new tip.`);
+	}
+	throw new WorkspaceStateError(`${packageName}: gave up after ${String(maxAttempts)} attempt(s) to push the release, each overtaken by another commit landing on the release branch first. Nothing was published and no tag reached the remote, so re-running is safe and loses nothing. Raise "pushAttempts" if this branch is busy enough that ${String(maxAttempts)} is genuinely too few. The last push failed with: ${lastLoss === void 0 ? "unknown" : lastLoss.message}`);
+}
+function resolvePushAttempts(configured) {
+	if (configured === void 0) return 5;
+	if (!Number.isInteger(configured) || configured < 1) throw new ReleaseConfigurationError(`"pushAttempts" must be a positive integer; received ${String(configured)}.`);
+	return configured;
+}
+async function attemptSingleCommitRelease(options) {
 	const root = resolve(options.root ?? process.cwd());
 	const log = options.log ?? console.log;
 	const dryRun = options.dryRun === true;
@@ -970,8 +1038,11 @@ async function releaseWorkspaceSingleCommit(options) {
 		}
 	}
 	if (dryRun || planned.length === 0) return {
-		order,
-		packages: outcomes
+		kind: "complete",
+		outcome: {
+			order,
+			packages: outcomes
+		}
 	};
 	const branch = captured.branch;
 	const repositoryUrl = captured.repositoryUrl;
@@ -1010,26 +1081,51 @@ async function releaseWorkspaceSingleCommit(options) {
 	const commitSha = (await git(["rev-parse", "HEAD"], { cwd: repoRoot })).trim();
 	const tagNames = planned.map((release) => release.gitTag);
 	for (const tagName of tagNames) await createTag(tagName, commitSha, { cwd: repoRoot });
-	await pushHeadAndTags(tagNames, { cwd: repoRoot });
-	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 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 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));
+	const branchName = await currentBranch({ cwd: repoRoot });
+	try {
+		await pushHeadAndTags(tagNames, { cwd: repoRoot });
+	} catch (error) {
+		if (!(error instanceof GitCommandError)) throw error;
+		let remoteTip;
+		try {
+			remoteTip = await fetchBranchTip(branchName, { cwd: repoRoot });
+		} catch {
+			throw error;
 		}
-		log(`${release.pkg.name}: published ${release.gitTag}`);
+		if (await isAncestor(remoteTip, "HEAD", { cwd: repoRoot })) throw error;
+		await deleteLocalTags(tagNames, { cwd: repoRoot });
+		await resetHardTo(remoteTip, { cwd: repoRoot });
+		return {
+			kind: "lost",
+			error,
+			branch: branchName,
+			remoteTip
+		};
 	}
+	log(`${packageName}: committed ${commitSha} and pushed ${String(tagNames.length)} tag(s): ${tagNames.join(", ")}`);
 	return {
-		order,
-		packages: outcomes
+		kind: "pushed",
+		outcome: {
+			order,
+			packages: outcomes
+		},
+		publish: async () => {
+			for (const release of planned) {
+				const releases = [];
+				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 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));
+				}
+				log(`${release.pkg.name}: published ${release.gitTag}`);
+			}
+		}
 	};
 }
 /**

package/dist/index.cjs

@@ -286,6 +286,53 @@ async function pushHeadAndTags(tagNames, options) {
 		...tagNames
 	], options);
 }
+/**
+* Fetches `branch` from origin and returns the commit it now points at.
+*
+* This is how a failed push is classified, in preference to reading the reason git printed for the rejection. The wording is not stable enough to branch on: the same race produces `! [rejected] ... (non-fast-forward)` from one server and `cannot lock ref 'refs/heads/main': is at <x> but expected <y>` from another (both observed, the first against GitHub and the second against a local bare repository under `--atomic`), and neither is a documented interface. Whether the branch actually moved is a fact about the remote rather than a string, it is the precise condition a retry can recover from, and it is knowable by asking.
+*/
+async function fetchBranchTip(branch, options) {
+	await git([
+		"fetch",
+		"origin",
+		branch
+	], options);
+	return (await git(["rev-parse", "FETCH_HEAD"], options)).trim();
+}
+/** Whether `ancestor` is reachable from `descendant`. `git merge-base --is-ancestor` reports the answer as an exit status rather than on stdout: 0 for yes and 1 for no are both answers, so only any other exit code is a failure. */
+async function isAncestor(ancestor, descendant, options) {
+	const args = [
+		"merge-base",
+		"--is-ancestor",
+		ancestor,
+		descendant
+	];
+	try {
+		await execGit(args, options.cwd);
+		return true;
+	} catch (cause) {
+		const error = toGitCommandError(args, options.cwd, cause);
+		if (error.exitCode === 1) return false;
+		throw error;
+	}
+}
+/** Discards every commit and working-tree change the current attempt made, putting the checkout back on exactly `ref`. */
+async function resetHardTo(ref, options) {
+	await git([
+		"reset",
+		"--hard",
+		ref
+	], options);
+}
+/** Deletes local tags. A retried attempt must drop the tags its predecessor created before it recreates them: `git tag` refuses a name that already exists, so without this the second attempt fails while tagging, before it ever reaches the push it was retrying. */
+async function deleteLocalTags(tagNames, options) {
+	if (tagNames.length === 0) return;
+	await git([
+		"tag",
+		"-d",
+		...tagNames
+	], options);
+}
 function toGitCommandError(args, cwd, cause) {
 	const exitCode = cause instanceof Error && "code" in cause && typeof cause.code === "number" ? cause.code : void 0;
 	const stderr = cause instanceof Error && "stderr" in cause && typeof cause.stderr === "string" ? cause.stderr.trim() : "";
@@ -900,6 +947,27 @@ function formatTagForPackage(tagFormat, name) {
 * Why publish is not just another semantic-release() call: semantic-release's own `run()` unconditionally derives `lastRelease` from the newest tag already on the branch matching `tagFormat`, and this mode has, by the time phase 5 runs, already created and pushed that exact tag itself. A second real `semanticRelease()` call would see its own just-created tag as the already-published release and compute the wrong next version from it. Phase 5 instead calls each resolved plugin module's own exported `verifyConditions`/`publish`/`success` functions directly, with a hand-built context -- the same public per-plugin API surface semantic-release's own core calls internally, just invoked without going through the parts of `run()` that assume a not-yet-tagged repository.
 */
 async function releaseWorkspaceSingleCommit(options) {
+	const log = options.log ?? console.log;
+	const maxAttempts = resolvePushAttempts(options.pushAttempts);
+	let lastLoss;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+		const result = await attemptSingleCommitRelease(options);
+		if (result.kind === "complete") return result.outcome;
+		if (result.kind === "pushed") {
+			await result.publish();
+			return result.outcome;
+		}
+		lastLoss = result.error;
+		log(`${packageName}: attempt ${String(attempt)} of ${String(maxAttempts)} lost the push, because ${result.branch} advanced to ${result.remoteTip} before this run's own refs reached the remote. This attempt's commit and tags have been discarded; recomputing the release against the new tip.`);
+	}
+	throw new WorkspaceStateError(`${packageName}: gave up after ${String(maxAttempts)} attempt(s) to push the release, each overtaken by another commit landing on the release branch first. Nothing was published and no tag reached the remote, so re-running is safe and loses nothing. Raise "pushAttempts" if this branch is busy enough that ${String(maxAttempts)} is genuinely too few. The last push failed with: ${lastLoss === void 0 ? "unknown" : lastLoss.message}`);
+}
+function resolvePushAttempts(configured) {
+	if (configured === void 0) return 5;
+	if (!Number.isInteger(configured) || configured < 1) throw new ReleaseConfigurationError(`"pushAttempts" must be a positive integer; received ${String(configured)}.`);
+	return configured;
+}
+async function attemptSingleCommitRelease(options) {
 	const root = (0, node_path.resolve)(options.root ?? process.cwd());
 	const log = options.log ?? console.log;
 	const dryRun = options.dryRun === true;
@@ -983,8 +1051,11 @@ async function releaseWorkspaceSingleCommit(options) {
 		}
 	}
 	if (dryRun || planned.length === 0) return {
-		order,
-		packages: outcomes
+		kind: "complete",
+		outcome: {
+			order,
+			packages: outcomes
+		}
 	};
 	const branch = captured.branch;
 	const repositoryUrl = captured.repositoryUrl;
@@ -1023,26 +1094,51 @@ async function releaseWorkspaceSingleCommit(options) {
 	const commitSha = (await git(["rev-parse", "HEAD"], { cwd: repoRoot })).trim();
 	const tagNames = planned.map((release) => release.gitTag);
 	for (const tagName of tagNames) await createTag(tagName, commitSha, { cwd: repoRoot });
-	await pushHeadAndTags(tagNames, { cwd: repoRoot });
-	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 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 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));
+	const branchName = await currentBranch({ cwd: repoRoot });
+	try {
+		await pushHeadAndTags(tagNames, { cwd: repoRoot });
+	} catch (error) {
+		if (!(error instanceof GitCommandError)) throw error;
+		let remoteTip;
+		try {
+			remoteTip = await fetchBranchTip(branchName, { cwd: repoRoot });
+		} catch {
+			throw error;
 		}
-		log(`${release.pkg.name}: published ${release.gitTag}`);
+		if (await isAncestor(remoteTip, "HEAD", { cwd: repoRoot })) throw error;
+		await deleteLocalTags(tagNames, { cwd: repoRoot });
+		await resetHardTo(remoteTip, { cwd: repoRoot });
+		return {
+			kind: "lost",
+			error,
+			branch: branchName,
+			remoteTip
+		};
 	}
+	log(`${packageName}: committed ${commitSha} and pushed ${String(tagNames.length)} tag(s): ${tagNames.join(", ")}`);
 	return {
-		order,
-		packages: outcomes
+		kind: "pushed",
+		outcome: {
+			order,
+			packages: outcomes
+		},
+		publish: async () => {
+			for (const release of planned) {
+				const releases = [];
+				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 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));
+				}
+				log(`${release.pkg.name}: published ${release.gitTag}`);
+			}
+		}
 	};
 }
 /**

package/dist/index.d.cts

@@ -279,6 +279,14 @@ interface ReleaseWorkspaceOptions {
    * and pins `...@<action>-v1`. Validated once per run by `validateTagFormat`.
    */
   readonly tagFormat?: string;
+  /**
+   * How many times `commitStrategy: 'single'` will compute and push a release before giving up, when each attempt is lost to another commit landing on the release branch first. Defaults to `DEFAULT_PUSH_ATTEMPTS`. Ignored by `commitStrategy: 'per-package'`, which pushes incrementally and has no all-or-nothing attempt to repeat.
+   *
+   * The default is derived rather than chosen. An attempt is lost if any commit lands during its own window, so with pushes arriving at rate `L` and an attempt taking `W`, an attempt survives with probability `e^(-L*W)` and `n` attempts all fail with probability `(1 - e^(-L*W))^n`. On the busiest repository this tool serves, pushes to the release branch arrived at roughly one every 7.4 minutes while a merge queue was landing pull requests continuously (measured over the busiest 60, 90 and 120 minute windows, which agreed to within 6%), and analysing, preparing, committing and pushing 23 packages took about 2.2 minutes, so `W = 3` minutes leaves headroom for a larger workspace. That gives about a one-in-three chance of losing any single attempt, which matches what was observed when there was no retry at all, and 5 attempts put the chance of losing all of them near 0.4%, or roughly one lost release a month at ten releases a day. Five attempts also bound the added time at about 15 minutes, well inside the hour-long job timeouts these releases run under.
+   *
+   * Raise it for a busier branch or a slower workspace; the cost of a higher bound is only paid when attempts are actually being lost.
+   */
+  readonly pushAttempts?: number;
 }
 /** One dependency-range change applied to a dependent package's manifest during the run, attached to the dependent's own outcome. */
 interface AppliedDependencyBump extends DependencyBump {

package/dist/index.d.ts

@@ -279,6 +279,14 @@ interface ReleaseWorkspaceOptions {
    * and pins `...@<action>-v1`. Validated once per run by `validateTagFormat`.
    */
   readonly tagFormat?: string;
+  /**
+   * How many times `commitStrategy: 'single'` will compute and push a release before giving up, when each attempt is lost to another commit landing on the release branch first. Defaults to `DEFAULT_PUSH_ATTEMPTS`. Ignored by `commitStrategy: 'per-package'`, which pushes incrementally and has no all-or-nothing attempt to repeat.
+   *
+   * The default is derived rather than chosen. An attempt is lost if any commit lands during its own window, so with pushes arriving at rate `L` and an attempt taking `W`, an attempt survives with probability `e^(-L*W)` and `n` attempts all fail with probability `(1 - e^(-L*W))^n`. On the busiest repository this tool serves, pushes to the release branch arrived at roughly one every 7.4 minutes while a merge queue was landing pull requests continuously (measured over the busiest 60, 90 and 120 minute windows, which agreed to within 6%), and analysing, preparing, committing and pushing 23 packages took about 2.2 minutes, so `W = 3` minutes leaves headroom for a larger workspace. That gives about a one-in-three chance of losing any single attempt, which matches what was observed when there was no retry at all, and 5 attempts put the chance of losing all of them near 0.4%, or roughly one lost release a month at ten releases a day. Five attempts also bound the added time at about 15 minutes, well inside the hour-long job timeouts these releases run under.
+   *
+   * Raise it for a busier branch or a slower workspace; the cost of a higher bound is only paid when attempts are actually being lost.
+   */
+  readonly pushAttempts?: number;
 }
 /** One dependency-range change applied to a dependent package's manifest during the run, attached to the dependent's own outcome. */
 interface AppliedDependencyBump extends DependencyBump {

package/dist/index.js

@@ -261,6 +261,53 @@ async function pushHeadAndTags(tagNames, options) {
 		...tagNames
 	], options);
 }
+/**
+* Fetches `branch` from origin and returns the commit it now points at.
+*
+* This is how a failed push is classified, in preference to reading the reason git printed for the rejection. The wording is not stable enough to branch on: the same race produces `! [rejected] ... (non-fast-forward)` from one server and `cannot lock ref 'refs/heads/main': is at <x> but expected <y>` from another (both observed, the first against GitHub and the second against a local bare repository under `--atomic`), and neither is a documented interface. Whether the branch actually moved is a fact about the remote rather than a string, it is the precise condition a retry can recover from, and it is knowable by asking.
+*/
+async function fetchBranchTip(branch, options) {
+	await git([
+		"fetch",
+		"origin",
+		branch
+	], options);
+	return (await git(["rev-parse", "FETCH_HEAD"], options)).trim();
+}
+/** Whether `ancestor` is reachable from `descendant`. `git merge-base --is-ancestor` reports the answer as an exit status rather than on stdout: 0 for yes and 1 for no are both answers, so only any other exit code is a failure. */
+async function isAncestor(ancestor, descendant, options) {
+	const args = [
+		"merge-base",
+		"--is-ancestor",
+		ancestor,
+		descendant
+	];
+	try {
+		await execGit(args, options.cwd);
+		return true;
+	} catch (cause) {
+		const error = toGitCommandError(args, options.cwd, cause);
+		if (error.exitCode === 1) return false;
+		throw error;
+	}
+}
+/** Discards every commit and working-tree change the current attempt made, putting the checkout back on exactly `ref`. */
+async function resetHardTo(ref, options) {
+	await git([
+		"reset",
+		"--hard",
+		ref
+	], options);
+}
+/** Deletes local tags. A retried attempt must drop the tags its predecessor created before it recreates them: `git tag` refuses a name that already exists, so without this the second attempt fails while tagging, before it ever reaches the push it was retrying. */
+async function deleteLocalTags(tagNames, options) {
+	if (tagNames.length === 0) return;
+	await git([
+		"tag",
+		"-d",
+		...tagNames
+	], options);
+}
 function toGitCommandError(args, cwd, cause) {
 	const exitCode = cause instanceof Error && "code" in cause && typeof cause.code === "number" ? cause.code : void 0;
 	const stderr = cause instanceof Error && "stderr" in cause && typeof cause.stderr === "string" ? cause.stderr.trim() : "";
@@ -875,6 +922,27 @@ function formatTagForPackage(tagFormat, name) {
 * Why publish is not just another semantic-release() call: semantic-release's own `run()` unconditionally derives `lastRelease` from the newest tag already on the branch matching `tagFormat`, and this mode has, by the time phase 5 runs, already created and pushed that exact tag itself. A second real `semanticRelease()` call would see its own just-created tag as the already-published release and compute the wrong next version from it. Phase 5 instead calls each resolved plugin module's own exported `verifyConditions`/`publish`/`success` functions directly, with a hand-built context -- the same public per-plugin API surface semantic-release's own core calls internally, just invoked without going through the parts of `run()` that assume a not-yet-tagged repository.
 */
 async function releaseWorkspaceSingleCommit(options) {
+	const log = options.log ?? console.log;
+	const maxAttempts = resolvePushAttempts(options.pushAttempts);
+	let lastLoss;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+		const result = await attemptSingleCommitRelease(options);
+		if (result.kind === "complete") return result.outcome;
+		if (result.kind === "pushed") {
+			await result.publish();
+			return result.outcome;
+		}
+		lastLoss = result.error;
+		log(`${packageName}: attempt ${String(attempt)} of ${String(maxAttempts)} lost the push, because ${result.branch} advanced to ${result.remoteTip} before this run's own refs reached the remote. This attempt's commit and tags have been discarded; recomputing the release against the new tip.`);
+	}
+	throw new WorkspaceStateError(`${packageName}: gave up after ${String(maxAttempts)} attempt(s) to push the release, each overtaken by another commit landing on the release branch first. Nothing was published and no tag reached the remote, so re-running is safe and loses nothing. Raise "pushAttempts" if this branch is busy enough that ${String(maxAttempts)} is genuinely too few. The last push failed with: ${lastLoss === void 0 ? "unknown" : lastLoss.message}`);
+}
+function resolvePushAttempts(configured) {
+	if (configured === void 0) return 5;
+	if (!Number.isInteger(configured) || configured < 1) throw new ReleaseConfigurationError(`"pushAttempts" must be a positive integer; received ${String(configured)}.`);
+	return configured;
+}
+async function attemptSingleCommitRelease(options) {
 	const root = resolve(options.root ?? process.cwd());
 	const log = options.log ?? console.log;
 	const dryRun = options.dryRun === true;
@@ -958,8 +1026,11 @@ async function releaseWorkspaceSingleCommit(options) {
 		}
 	}
 	if (dryRun || planned.length === 0) return {
-		order,
-		packages: outcomes
+		kind: "complete",
+		outcome: {
+			order,
+			packages: outcomes
+		}
 	};
 	const branch = captured.branch;
 	const repositoryUrl = captured.repositoryUrl;
@@ -998,26 +1069,51 @@ async function releaseWorkspaceSingleCommit(options) {
 	const commitSha = (await git(["rev-parse", "HEAD"], { cwd: repoRoot })).trim();
 	const tagNames = planned.map((release) => release.gitTag);
 	for (const tagName of tagNames) await createTag(tagName, commitSha, { cwd: repoRoot });
-	await pushHeadAndTags(tagNames, { cwd: repoRoot });
-	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 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 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));
+	const branchName = await currentBranch({ cwd: repoRoot });
+	try {
+		await pushHeadAndTags(tagNames, { cwd: repoRoot });
+	} catch (error) {
+		if (!(error instanceof GitCommandError)) throw error;
+		let remoteTip;
+		try {
+			remoteTip = await fetchBranchTip(branchName, { cwd: repoRoot });
+		} catch {
+			throw error;
 		}
-		log(`${release.pkg.name}: published ${release.gitTag}`);
+		if (await isAncestor(remoteTip, "HEAD", { cwd: repoRoot })) throw error;
+		await deleteLocalTags(tagNames, { cwd: repoRoot });
+		await resetHardTo(remoteTip, { cwd: repoRoot });
+		return {
+			kind: "lost",
+			error,
+			branch: branchName,
+			remoteTip
+		};
 	}
+	log(`${packageName}: committed ${commitSha} and pushed ${String(tagNames.length)} tag(s): ${tagNames.join(", ")}`);
 	return {
-		order,
-		packages: outcomes
+		kind: "pushed",
+		outcome: {
+			order,
+			packages: outcomes
+		},
+		publish: async () => {
+			for (const release of planned) {
+				const releases = [];
+				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 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));
+				}
+				log(`${release.pkg.name}: published ${release.gitTag}`);
+			}
+		}
 	};
 }
 /**

package/package.json

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