fireflyy 4.0.0-dev.644fea9 → 4.0.0-dev.df58d2b

package/dist/{program-CHc5t2Xm.js → program-CW3hIbzh.js}

@@ -1,7 +1,7 @@
 import { n as RuntimeEnv, t as logger } from "./main.js";
-import { _ as validationError, a as conflictErrAsync, c as notFoundErrAsync, d as validationErrAsync, f as conflictError, h as notFoundError, i as FireflyOkAsync, l as timeoutErrAsync, m as failedError, n as FireflyErrAsync, r as FireflyOk, s as invalidErr, t as FireflyErr, u as validationErr, v as wrapErrorMessage } from "./result.constructors-C9M1MP3_.js";
-import { n as wrapPromise, r as zip3Async, t as ensureNotAsync } from "./result.utilities-DC5shlhT.js";
-import { n as parseSchema, t as formatZodErrors } from "./schema.utilities-BGd9t1wm.js";
+import { _ as notFoundError, a as conflictErrAsync, b as wrapErrorMessage, c as invalidErrAsync, d as validationErr, f as validationErrAsync, h as failedError, i as FireflyOkAsync, l as notFoundErrAsync, n as FireflyErrAsync, p as conflictError, r as FireflyOk, s as invalidErr, t as FireflyErr, u as timeoutErrAsync, y as validationError } from "./result.constructors-D9jmQ0uj.js";
+import { n as wrapPromise, r as zip3Async, t as ensureNotAsync } from "./result.utilities-CdBL5noX.js";
+import { n as parseSchema, t as formatZodErrors } from "./schema.utilities-BOJqWEey.js";
 import { LogLevels } from "consola";
 import { colors } from "consola/utils";
 import { Command } from "commander";
@@ -1003,9 +1003,10 @@ function createBumpExecutionGroup() {
 */
 function shouldSkipBumpStrategy(ctx) {
 	const { skipBump, releaseType, bumpStrategy } = ctx.config;
+	const { selectedReleaseType, selectedBumpStrategy } = ctx.data;
 	if (skipBump) return true;
-	if (releaseType) return true;
-	if (!bumpStrategy) return true;
+	if (releaseType || selectedReleaseType) return true;
+	if (!Boolean(bumpStrategy || selectedBumpStrategy)) return true;
 	return false;
 }
 /**
@@ -1013,9 +1014,11 @@ function shouldSkipBumpStrategy(ctx) {
 */
 function getSkipReason(ctx) {
 	const { skipBump, releaseType, bumpStrategy } = ctx.config;
+	const { selectedReleaseType, selectedBumpStrategy } = ctx.data;
 	if (skipBump) return "skipBump is enabled";
-	if (releaseType) return `releaseType already set to '${releaseType}'`;
-	if (!bumpStrategy) return "no bumpStrategy configured";
+	if (releaseType) return `releaseType already set to '${releaseType}' (config)`;
+	if (selectedReleaseType) return `releaseType already set to '${selectedReleaseType}' (data)`;
+	if (!Boolean(bumpStrategy || selectedBumpStrategy)) return "no bumpStrategy configured";
 	return "unknown reason";
 }
 function createDelegateBumpStrategyTask() {
@@ -1034,7 +1037,10 @@ function createDelegateBumpStrategyTask() {
 //#endregion
 //#region src/commands/release/tasks/determine-automatic-bump.task.ts
 function createDetermineAutomaticBump() {
-	return TaskBuilder.create("determine-automatic-bump").description("Automatically determines the version bump from commit messages").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => ctx.config.skipBump || ctx.config.bumpStrategy !== BUMP_STRATEGY_AUTO, "Skipped: skipBump enabled or bumpStrategy is not 'auto'").execute((ctx) => {
+	return TaskBuilder.create("determine-automatic-bump").description("Automatically determines the version bump from commit messages").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => {
+		const bumpStrategy = ctx.data.selectedBumpStrategy ?? ctx.config.bumpStrategy;
+		return ctx.config.skipBump || bumpStrategy !== BUMP_STRATEGY_AUTO;
+	}, "Skipped: skipBump enabled or bumpStrategy is not 'auto'").execute((ctx) => {
 		logger.info("determine-automatic-bump");
 		return FireflyOkAsync(ctx);
 	}).build();
@@ -1042,17 +1048,61 @@ function createDetermineAutomaticBump() {
 
 //#endregion
 //#region src/commands/release/tasks/prompt-bump-strategy.task.ts
+const BUMP_STRATEGIES = [{
+	label: "Automatic Bump",
+	value: BUMP_STRATEGY_AUTO,
+	hint: "Determines the next version based on conventional commits history"
+}, {
+	label: "Manual Bump",
+	value: BUMP_STRATEGY_MANUAL,
+	hint: "Manually specify the next version"
+}];
+const VALID_STRATEGY_VALUES = BUMP_STRATEGIES.map((s) => s.value);
+/**
+* Validates that the selected strategy is one of the allowed values.
+*
+* @param strategy The selected version bump strategy.
+* @returns A FireflyResult indicating success or failure of validation.
+*/
+function validateStrategy(strategy) {
+	if (!VALID_STRATEGY_VALUES.includes(strategy)) return invalidErr({ message: `Invalid version bump strategy: ${strategy}` });
+	return FireflyOk(strategy);
+}
+/**
+* Prompts the user to select a bump strategy using the logger's prompt API.
+*/
+function promptBumpStrategy() {
+	const defaultStrategy = BUMP_STRATEGIES[0];
+	if (!defaultStrategy) return notFoundErrAsync({ message: "No default version bump strategy found" });
+	logger.verbose("PromptBumpStrategyTask: Prompting user for version bump strategy.");
+	const prompt = logger.prompt("Select version bump strategy", {
+		type: "select",
+		options: BUMP_STRATEGIES,
+		initial: defaultStrategy.value,
+		cancel: "reject"
+	});
+	if (logger.level !== LogLevels.verbose) logger.log("");
+	return wrapPromise(prompt).andTee(() => {
+		if (logger.level === LogLevels.verbose) logger.log("");
+	}).andThen((selected) => {
+		if (!selected || selected === "") return invalidErrAsync({ message: "No version bump strategy selected" });
+		const validationResult = validateStrategy(selected);
+		if (validationResult.isErr()) return FireflyErrAsync(validationResult.error);
+		logger.verbose(`PromptBumpStrategyTask: Selected version bump strategy: '${selected}'`);
+		return FireflyOkAsync(selected);
+	});
+}
 function createPromptBumpStrategyTask() {
-	return TaskBuilder.create("prompt-bump-strategy").description("Prompts the user for a version bump strategy").dependsOn("initialize-release-version").skipWhenWithReason((ctx) => ctx.config.skipBump || Boolean(ctx.config.bumpStrategy) || Boolean(ctx.config.releaseType), "Skipped: skipBump enabled, or bumpStrategy/releaseType already specified").execute((ctx) => {
-		logger.info("prompt-bump-strategy");
-		return FireflyOkAsync(ctx);
-	}).build();
+	return TaskBuilder.create("prompt-bump-strategy").description("Prompts the user for a version bump strategy").dependsOn("initialize-release-version").skipWhenWithReason((ctx) => ctx.config.skipBump || Boolean(ctx.config.bumpStrategy) || Boolean(ctx.config.releaseType), "Skipped: skipBump enabled, or bumpStrategy/releaseType already specified").execute((ctx) => promptBumpStrategy().andThen((strategy) => FireflyOkAsync(ctx.fork("selectedBumpStrategy", strategy)))).build();
 }
 
 //#endregion
 //#region src/commands/release/tasks/prompt-manual-bump.task.ts
 function createPromptManualVersionTask() {
-	return TaskBuilder.create("prompt-manual-version").description("Prompts the user for a manual version bump selections").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => ctx.config.skipBump || Boolean(ctx.config.bumpStrategy) || Boolean(ctx.config.releaseType), "Skipped: skipBump enabled, or bumpStrategy/releaseType already specified").execute((ctx) => {
+	return TaskBuilder.create("prompt-manual-version").description("Prompts the user for a manual version bump selections").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => {
+		const bumpStrategy = ctx.data.selectedBumpStrategy ?? ctx.config.bumpStrategy;
+		return ctx.config.skipBump || bumpStrategy !== BUMP_STRATEGY_MANUAL;
+	}, "Skipped: skipBump enabled or bumpStrategy is not 'manual'").execute((ctx) => {
 		logger.info("prompt-manual-version");
 		return FireflyOkAsync(ctx);
 	}).build();
@@ -1611,21 +1661,41 @@ function defineService(definition) {
 */
 const SERVICE_DEFINITIONS = {
 	fs: defineService({ factory: async ({ basePath }) => {
-		const { createFileSystemService } = await import("./filesystem.service-9VHML130.js");
+		const { createFileSystemService } = await import("./filesystem.service-BcQtLzfl.js");
 		return createFileSystemService(basePath);
 	} }),
 	packageJson: defineService({
 		dependencies: ["fs"],
 		factory: async ({ getService }) => {
 			const fs = await getService("fs");
-			const { createPackageJsonService } = await import("./package-json.service-DACeZzRg.js");
+			const { createPackageJsonService } = await import("./package-json.service-BKbXaHXQ.js");
 			return createPackageJsonService(fs);
 		}
 	}),
 	git: defineService({ factory: async ({ basePath }) => {
-		const { createGitService } = await import("./git.service-CACrfCW8.js");
+		const { createGitService } = await import("./git.service-D1Mf6LZ0.js");
 		return createGitService(basePath);
-	} })
+	} }),
+	versionBumper: defineService({ factory: async () => {
+		const { createVersionBumperService } = await import("./version-bumper.service-CvPx7EZx.js");
+		return createVersionBumperService();
+	} }),
+	versionStrategy: defineService({
+		dependencies: ["versionBumper"],
+		factory: async ({ getService }) => {
+			const versionBumper = await getService("versionBumper");
+			const { createVersionStrategyService } = await import("./version-strategy.service-BO_7MY5O.js");
+			return createVersionStrategyService(versionBumper);
+		}
+	}),
+	commitAnalysis: defineService({
+		dependencies: ["git"],
+		factory: async ({ getService }) => {
+			const git = await getService("git");
+			const { createCommitAnalysisService } = await import("./commit-analysis.service-CtIh7eez.js");
+			return createCommitAnalysisService(git);
+		}
+	})
 };
 /**
 * Array of all service keys for iteration
@@ -2264,7 +2334,11 @@ var WorkflowExecutor = class {
 		const startTime = /* @__PURE__ */ new Date();
 		const executedTaskIds = [];
 		const skippedTaskIds = [];
-		if (this.options.dryRun) logger.warn("Workflow executing in DRY RUN mode - no actual changes will be made");
+		if (this.options.dryRun) logger.warn("Running in DRY-RUN mode: No changes will be made.");
+		const version = RuntimeEnv.version;
+		const dashIndex = version.indexOf("-");
+		if (dashIndex !== -1) if (dashIndex === version.length - 1 || version[dashIndex + 1] === "n") logger.warn(`You are running a DEVELOPMENT build of Firefly (${colors.dim(version)}). This is a 'next' build and may be unstable.`);
+		else logger.warn(`You are running a PRE-RELEASE version of Firefly (${colors.dim(version)}). Unexpected behavior or bugs may occur.`);
 		logger.verbose(`WorkflowExecutor: Starting execution of ${tasks.length} tasks`);
 		return this.executeTasksSequentially(tasks, initialContext, executedTaskIds, skippedTaskIds).andThen(() => this.buildExecutionSuccessResult(startTime, executedTaskIds, skippedTaskIds)).orElse((error) => this.handleExecutionFailure({
 			error,

package/dist/{result.constructors-C9M1MP3_.js → result.constructors-D9jmQ0uj.js}

@@ -253,9 +253,13 @@ const failedErrAsync = (opts) => errAsync(failedError(opts));
 */
 const invalidErr = (opts) => err(invalidError(opts));
 /**
+* Creates an async invalid error result.
+*/
+const invalidErrAsync = (opts) => errAsync(invalidError(opts));
+/**
 * Creates an async timeout error result.
 */
 const timeoutErrAsync = (opts) => errAsync(timeoutError(opts));
 
 //#endregion
-export { validationError as _, conflictErrAsync as a, notFoundErrAsync as c, validationErrAsync as d, conflictError as f, toFireflyError as g, notFoundError as h, FireflyOkAsync as i, timeoutErrAsync as l, failedError as m, FireflyErrAsync as n, failedErrAsync as o, createFireflyError as p, FireflyOk as r, invalidErr as s, FireflyErr as t, validationErr as u, wrapErrorMessage as v };
+export { notFoundError as _, conflictErrAsync as a, wrapErrorMessage as b, invalidErrAsync as c, validationErr as d, validationErrAsync as f, invalidError as g, failedError as h, FireflyOkAsync as i, notFoundErrAsync as l, createFireflyError as m, FireflyErrAsync as n, failedErrAsync as o, conflictError as p, FireflyOk as r, invalidErr as s, FireflyErr as t, timeoutErrAsync as u, toFireflyError as v, validationError as y };

package/dist/{result.utilities-DC5shlhT.js → result.utilities-CdBL5noX.js}

@@ -1,4 +1,4 @@
-import { d as validationErrAsync, g as toFireflyError, i as FireflyOkAsync, p as createFireflyError } from "./result.constructors-C9M1MP3_.js";
+import { f as validationErrAsync, i as FireflyOkAsync, m as createFireflyError, v as toFireflyError } from "./result.constructors-D9jmQ0uj.js";
 import { ResultAsync } from "neverthrow";
 
 //#region src/core/result/result.utilities.ts

package/dist/{schema.utilities-BGd9t1wm.js → schema.utilities-BOJqWEey.js}

@@ -1,4 +1,4 @@
-import { g as toFireflyError, p as createFireflyError, r as FireflyOk, t as FireflyErr } from "./result.constructors-C9M1MP3_.js";
+import { m as createFireflyError, r as FireflyOk, t as FireflyErr, v as toFireflyError } from "./result.constructors-D9jmQ0uj.js";
 import { ResultAsync } from "neverthrow";
 import z$1 from "zod";
 

package/dist/version-bumper.service-CvPx7EZx.js

@@ -0,0 +1,318 @@
+import { r as FireflyOk, s as invalidErr, t as FireflyErr } from "./result.constructors-D9jmQ0uj.js";
+import semver from "semver";
+
+//#region src/domain/semver/version.ts
+/**
+* Represents a parsed semantic version with immutable access.
+*
+* @example
+* ```ts
+* const result = Version.from("1.2.3-alpha.1");
+* if (result.isOk()) {
+*   console.log(result.value.major); // 1
+*   console.log(result.value.isPrerelease); // true
+* }
+* ```
+*/
+var Version = class Version {
+	_raw;
+	_parsed;
+	constructor(version, parsed) {
+		this._raw = version;
+		this._parsed = parsed;
+	}
+	/**
+	* Creates a Version from any valid semver string.
+	* Handles cleaning (removing 'v' prefix, etc.).
+	*/
+	static from(input) {
+		const cleaned = semver.clean(input);
+		if (!cleaned) return invalidErr({ message: `"${input}" is not a valid semantic version.` });
+		const parsed = semver.parse(cleaned);
+		if (!parsed) return invalidErr({ message: `Failed to parse semantic version "${cleaned}".` });
+		return FireflyOk(new Version(cleaned, parsed));
+	}
+	/**
+	* Creates a Version from an already-clean semver string.
+	* Use when you know the input is already normalized.
+	*/
+	static fromClean(cleanVersion) {
+		const parsed = semver.parse(cleanVersion);
+		if (!parsed) return invalidErr({ message: `Expected clean version but got invalid: ${cleanVersion}` });
+		return FireflyOk(new Version(cleanVersion, parsed));
+	}
+	/**
+	* The raw version string.
+	*/
+	get raw() {
+		return this._raw;
+	}
+	/**
+	* Major version number.
+	*/
+	get major() {
+		return this._parsed.major;
+	}
+	/**
+	* Minor version number.
+	*/
+	get minor() {
+		return this._parsed.minor;
+	}
+	/**
+	* Patch version number.
+	*/
+	get patch() {
+		return this._parsed.patch;
+	}
+	/**
+	* Whether this version has prerelease identifiers.
+	*/
+	get isPrerelease() {
+		return this._parsed.prerelease.length > 0;
+	}
+	/**
+	* Prerelease identifiers (e.g., ["alpha", 1] for "1.0.0-alpha.1").
+	*/
+	get prerelease() {
+		return this._parsed.prerelease;
+	}
+	/**
+	* The prerelease identifier (e.g., "alpha" from "1.0.0-alpha.1").
+	*/
+	get prereleaseIdentifier() {
+		if (!this.isPrerelease) return null;
+		const first = this._parsed.prerelease[0];
+		return typeof first === "string" ? first : null;
+	}
+	/**
+	* The prerelease number (e.g., 1 from "1.0.0-alpha.1").
+	*/
+	get prereleaseNumber() {
+		if (!this.isPrerelease) return null;
+		const last = this._parsed.prerelease.at(-1);
+		return typeof last === "number" ? last : null;
+	}
+	/**
+	* Build metadata identifiers.
+	*/
+	get build() {
+		return this._parsed.build;
+	}
+	/**
+	* Returns the raw version string.
+	*/
+	toString() {
+		return this._raw;
+	}
+	/**
+	* Checks equality with another Version.
+	*
+	* @param other - The other Version to compare with
+	* @returns True if equal, false otherwise
+	*/
+	equals(other) {
+		return semver.eq(this._raw, other._raw);
+	}
+	/**
+	* Compares with another Version: -1 (less), 0 (equal), 1 (greater).
+	*
+	* @param other - The other Version to compare with
+	* @returns -1, 0, or 1 based on comparison
+	*/
+	compare(other) {
+		return semver.compare(this._raw, other._raw);
+	}
+	/**
+	* Checks if this version is greater than another.
+	*
+	* @param other - The other Version to compare with
+	* @returns True if this version is greater, false otherwise
+	*/
+	isGreaterThan(other) {
+		return semver.gt(this._raw, other._raw);
+	}
+	/**
+	* Checks if this version is less than another.
+	*
+	* @param other - The other Version to compare with
+	* @returns True if this version is less, false otherwise
+	*/
+	isLessThan(other) {
+		return semver.lt(this._raw, other._raw);
+	}
+	/**
+	* Checks if this version satisfies a semver range.
+	*
+	* @param range - The semver range to check against
+	* @returns True if it satisfies the range, false otherwise
+	*/
+	satisfies(range) {
+		return semver.satisfies(this._raw, range);
+	}
+	/**
+	* Converts a prerelease version to its stable form.
+	* "1.2.3-alpha.1" → "1.2.3"
+	*/
+	toStable() {
+		const stableVersion = `${this.major}.${this.minor}.${this.patch}`;
+		return Version.fromClean(stableVersion);
+	}
+};
+
+//#endregion
+//#region src/services/implementations/version-bumper.service.ts
+/**
+* Default implementation of the version bumper service.
+*/
+var DefaultVersionBumperService = class {
+	bump(options) {
+		const { currentVersion, releaseType, prereleaseIdentifier, prereleaseBase } = options;
+		if (releaseType === "major" || releaseType === "minor" || releaseType === "patch") return this.bumpStandard(currentVersion, releaseType);
+		if (releaseType === "premajor" || releaseType === "preminor" || releaseType === "prepatch") return this.bumpPreStandard(currentVersion, releaseType, prereleaseIdentifier, prereleaseBase);
+		if (releaseType === "prerelease") return this.bumpPrerelease(currentVersion, prereleaseIdentifier, prereleaseBase);
+		if (releaseType === "graduate") return this.graduatePrerelease(currentVersion);
+		return invalidErr({
+			message: `Unsupported release type: ${releaseType}`,
+			source: "services/version-bumper"
+		});
+	}
+	/**
+	* Normalizes the prerelease base to a string "0" or "1".
+	*
+	* @param base - The prerelease base to normalize
+	* @returns The normalized base or an error if invalid
+	*/
+	normalizeBase(base) {
+		if (base === void 0 || base === null) return FireflyOk(void 0);
+		if (base === "0" || base === "1") return FireflyOk(base);
+		if (typeof base === "number" && (base === 0 || base === 1)) return FireflyOk(base.toString());
+		return invalidErr({ message: `Invalid prerelease base '${base}'. Must be "0", "1", 0, or 1.` });
+	}
+	/**
+	* Determines if the prerelease identifier is complex (contains dots).
+	*
+	* @param identifier - The prerelease identifier to check
+	* @returns True if the identifier is complex, false otherwise
+	*/
+	isComplexIdentifier(identifier) {
+		return typeof identifier === "string" && identifier.includes(".");
+	}
+	/**
+	* Bumps a version with a complex prerelease identifier (e.g., "canary.abc123").
+	*
+	* @param currentVersion - The current version to bump
+	* @param identifier - The complex prerelease identifier
+	* @returns The new version with the complex identifier
+	*/
+	bumpWithComplexIdentifier(currentVersion, identifier) {
+		if (!identifier) return semver.inc(currentVersion.raw, "prerelease", void 0, "0");
+		return semver.inc(currentVersion.raw, "prerelease", identifier, false);
+	}
+	/**
+	* Bumps an existing prerelease version.
+	*
+	* @param currentVersion - The current version to bump
+	* @param identifier - Optional prerelease identifier
+	* @returns The new prerelease version
+	*/
+	bumpExistingPrerelease(currentVersion, identifier) {
+		return identifier ? semver.inc(currentVersion.raw, "prerelease", identifier) : semver.inc(currentVersion.raw, "prerelease");
+	}
+	/**
+	* Bumps a standard version (major, minor, patch) according to the provided release type.
+	*
+	* @param currentVersion - The current version to bump
+	* @param releaseType - The type of standard release
+	* @returns The new standard version
+	*/
+	bumpStandard(currentVersion, releaseType) {
+		let baseVersionString = currentVersion.raw;
+		if (currentVersion.isPrerelease) {
+			const stableResult = currentVersion.toStable();
+			if (stableResult.isErr()) return FireflyErr(stableResult.error);
+			baseVersionString = stableResult.value.raw;
+		}
+		const newVersionString = semver.inc(baseVersionString, releaseType);
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump ${releaseType} version from '${baseVersionString}'.`,
+			source: "services/version-bumper"
+		});
+		return Version.fromClean(newVersionString);
+	}
+	/**
+	* Bumps a pre-standard version (premajor, preminor, prepatch) according to the provided options.
+	*
+	* @param currentVersion - The current version to bump
+	* @param releaseType - The type of pre-standard release
+	* @param identifier - Optional prerelease identifier (e.g., "alpha", "beta")
+	* @param base - Optional base number for the prerelease
+	* @returns The new pre-standard version
+	*/
+	bumpPreStandard(currentVersion, releaseType, identifier, base) {
+		const normalizedBaseResult = this.normalizeBase(base);
+		if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+		const normalizedBase = normalizedBaseResult.value;
+		let newVersionString = null;
+		if (normalizedBase !== void 0) newVersionString = identifier ? semver.inc(currentVersion.raw, releaseType, identifier, normalizedBase) : semver.inc(currentVersion.raw, releaseType, void 0, normalizedBase);
+		else newVersionString = identifier ? semver.inc(currentVersion.raw, releaseType, identifier) : semver.inc(currentVersion.raw, releaseType);
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump ${releaseType} version from '${currentVersion.raw}' with identifier '${identifier}' and base '${base}'.`,
+			source: "services/version-bumper"
+		});
+		return Version.fromClean(newVersionString);
+	}
+	/**
+	* Bumps a prerelease version according to the provided options.
+	* Handles complex identifiers, explicit bases, continuing existing
+	* prereleases, and starting new prereleases from stable versions.
+	*
+	* @param currentVersion - The current version to bump
+	* @param identifier - Optional prerelease identifier (e.g., "alpha", "beta")
+	* @param base - Optional base number for the prerelease
+	* @returns The new prerelease version
+	*/
+	bumpPrerelease(currentVersion, identifier, base) {
+		let newVersionString = null;
+		if (this.isComplexIdentifier(identifier)) newVersionString = this.bumpWithComplexIdentifier(currentVersion, identifier);
+		else if (base !== void 0 && base !== null) {
+			const normalizedBaseResult = this.normalizeBase(base);
+			if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+			const normalizedBase = normalizedBaseResult.value;
+			newVersionString = identifier ? semver.inc(currentVersion.raw, "prerelease", identifier, normalizedBase) : semver.inc(currentVersion.raw, "prerelease", void 0, normalizedBase);
+		} else if (currentVersion.isPrerelease) newVersionString = this.bumpExistingPrerelease(currentVersion, identifier);
+		else {
+			const defaultIdentifier = identifier || "alpha";
+			newVersionString = semver.inc(currentVersion.raw, "prerelease", defaultIdentifier);
+		}
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump prerelease version from '${currentVersion.raw}' with identifier '${identifier}' and base '${base}'.`,
+			source: "services/version-bumper"
+		});
+		return Version.fromClean(newVersionString);
+	}
+	/**
+	* Graduates a prerelease version to its stable counterpart.
+	*
+	* @param currentVersion - The current prerelease version
+	* @returns The stable version
+	*/
+	graduatePrerelease(currentVersion) {
+		if (!currentVersion.isPrerelease) return invalidErr({
+			message: `Cannot graduate non-prerelease version '${currentVersion.raw}'. Only prerelease versions can be graduated.`,
+			source: "services/version-bumper"
+		});
+		const stableVersionResult = currentVersion.toStable();
+		if (stableVersionResult.isErr()) return FireflyErr(stableVersionResult.error);
+		return FireflyOk(stableVersionResult.value);
+	}
+};
+/**
+* Creates a version bumper service instance.
+*/
+function createVersionBumperService() {
+	return new DefaultVersionBumperService();
+}
+
+//#endregion
+export { createVersionBumperService };

package/dist/version-strategy.service-BO_7MY5O.js

@@ -0,0 +1,4 @@
+import "./result.constructors-D9jmQ0uj.js";
+import { n as TRANSITION_KEYWORDS, r as createVersionStrategyService, t as DefaultVersionStrategyService } from "./version-strategy.service-vh5KeNCA.js";
+
+export { createVersionStrategyService };