fireflyy 4.0.0-dev.a10ed44 → 4.0.0-dev.a8aacbe

package/dist/{result.constructors-BMtOWD2-.js → result.constructors-DoAoYdfF.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 { toFireflyError as _, conflictErrAsync as a, notFoundErrAsync as c, validationErrAsync as d, conflictError as f, notFoundError as g, invalidError 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, validationError as v, wrapErrorMessage as y };
+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-BTVU-GsT.js → result.utilities-DXSJU70_.js}

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

package/dist/{schema.utilities-BxiRR-GI.js → schema.utilities-C1yimTtB.js}

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

package/dist/version-DJuocyXy.js

@@ -0,0 +1,164 @@
+import { r as FireflyOk, s as invalidErr } from "./result.constructors-DoAoYdfF.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 preReleaseId() {
+		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
+export { Version as t };

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

@@ -0,0 +1,171 @@
+import { c as invalidErrAsync, i as FireflyOkAsync, n as FireflyErrAsync, r as FireflyOk, s as invalidErr, t as FireflyErr } from "./result.constructors-DoAoYdfF.js";
+import { t as Version } from "./version-DJuocyXy.js";
+import semver from "semver";
+
+//#region src/services/implementations/version-bumper.service.ts
+/**
+* Default implementation of the version bumper service.
+*/
+var DefaultVersionBumperService = class {
+	bump(options) {
+		const { currentVersion, releaseType, preReleaseId, preReleaseBase } = options;
+		if (releaseType === "major" || releaseType === "minor" || releaseType === "patch") {
+			const result = this.bumpStandard(currentVersion, releaseType);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		if (releaseType === "premajor" || releaseType === "preminor" || releaseType === "prepatch") {
+			const result = this.bumpPreStandard(currentVersion, releaseType, preReleaseId, preReleaseBase);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		if (releaseType === "prerelease") {
+			const result = this.bumpPrerelease(currentVersion, preReleaseId, preReleaseBase);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		if (releaseType === "graduate") {
+			const result = this.graduatePrerelease(currentVersion);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		return invalidErrAsync({
+			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 preReleaseBase '${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, preReleaseId, preReleaseBase) {
+		const normalizedBaseResult = this.normalizeBase(preReleaseBase);
+		if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+		const normalizedBase = normalizedBaseResult.value;
+		let newVersionString = null;
+		if (normalizedBase !== void 0) newVersionString = preReleaseId ? semver.inc(currentVersion.raw, releaseType, preReleaseId, normalizedBase) : semver.inc(currentVersion.raw, releaseType, void 0, normalizedBase);
+		else newVersionString = preReleaseId ? semver.inc(currentVersion.raw, releaseType, preReleaseId) : semver.inc(currentVersion.raw, releaseType);
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump ${releaseType} version from '${currentVersion.raw}' with identifier '${preReleaseId}' and base '${preReleaseBase}'.`,
+			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, preReleaseId, preReleaseBase) {
+		let newVersionString = null;
+		if (this.isComplexIdentifier(preReleaseId)) newVersionString = this.bumpWithComplexIdentifier(currentVersion, preReleaseId);
+		else if (preReleaseBase !== void 0 && preReleaseBase !== null) {
+			const normalizedBaseResult = this.normalizeBase(preReleaseBase);
+			if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+			const normalizedBase = normalizedBaseResult.value;
+			newVersionString = preReleaseId ? semver.inc(currentVersion.raw, "prerelease", preReleaseId, normalizedBase) : semver.inc(currentVersion.raw, "prerelease", void 0, normalizedBase);
+		} else if (currentVersion.isPrerelease) newVersionString = this.bumpExistingPrerelease(currentVersion, preReleaseId);
+		else {
+			const defaultIdentifier = preReleaseId || "alpha";
+			newVersionString = semver.inc(currentVersion.raw, "prerelease", defaultIdentifier);
+		}
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump prerelease version from '${currentVersion.raw}' with identifier '${preReleaseId}' and base '${preReleaseBase}'.`,
+			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-CmfeZLYC.js → version-strategy.service-Dln42gxC.js}

@@ -1,6 +1,6 @@
-import { h as invalidError, r as FireflyOk, t as FireflyErr } from "./result.constructors-BMtOWD2-.js";
-import { t as logger } from "./logging-BuIkRrn1.js";
-import { Result } from "neverthrow";
+import { g as invalidError, i as FireflyOkAsync, n as FireflyErrAsync } from "./result.constructors-DoAoYdfF.js";
+import { t as logger } from "./logging-Bpk2RzGc.js";
+import { ResultAsync } from "neverthrow";
 
 //#region src/services/implementations/version-strategy.service.ts
 const TRANSITION_KEYWORDS = [
@@ -55,6 +55,9 @@ const VERSION_DESCRIPTIONS = {
 	prerelease: "Unstable pre-release continuation. Increments the pre-release number or changes identifier.",
 	graduate: "Promote pre-release to stable. Removes pre-release identifiers to create a stable version."
 };
+/**
+* Default implementation of the version strategy service.
+*/
 var DefaultVersionStrategyService = class {
 	bumper;
 	constructor(bumper) {
@@ -80,19 +83,19 @@ var DefaultVersionStrategyService = class {
 			return this.bumper.bump({
 				currentVersion: options.currentVersion,
 				releaseType: options.releaseType,
-				prereleaseIdentifier: options.prereleaseIdentifier,
-				prereleaseBase: options.prereleaseBase
+				preReleaseId: options.preReleaseId,
+				preReleaseBase: options.preReleaseBase
 			});
 		}
-		return FireflyErr(invalidError({ message: "Cannot determine next version: no release type or recommendation provided" }));
+		return FireflyErrAsync(invalidError({ message: "Cannot determine next version: no release type or recommendation provided" }));
 	}
 	generateChoices(options) {
 		logger.verbose(`DefaultVersionStrategyService: Creating version choices for '${options.currentVersion.raw}'...`);
-		const choicesResults = this.determineAvailableVersionTypes(options.currentVersion, options.releaseType).map((releaseType) => this.createSingleChoice(options.currentVersion, releaseType, options.prereleaseIdentifier, options.prereleaseBase));
-		const combinedResult = Result.combine(choicesResults);
-		if (combinedResult.isErr()) return FireflyErr(combinedResult.error);
-		logger.verbose(`DefaultVersionStrategyService: Created ${combinedResult.value.length} version choices.`);
-		return FireflyOk(combinedResult.value);
+		const choicesResults = this.determineAvailableVersionTypes(options.currentVersion, options.releaseType).map((releaseType) => this.createSingleChoice(options.currentVersion, releaseType, options.preReleaseId, options.preReleaseBase));
+		return ResultAsync.combine(choicesResults).map((choices) => {
+			logger.verbose(`DefaultVersionStrategyService: Created ${choices.length} version choices.`);
+			return choices;
+		});
 	}
 	/**
 	* Analyzes the current version and recommendation to determine pre-release context.
@@ -104,7 +107,7 @@ var DefaultVersionStrategyService = class {
 	analyzePreReleaseContext(currentVersion, recommendation) {
 		return {
 			isCurrentPreRelease: currentVersion.isPrerelease,
-			prereleaseIdentifier: currentVersion.prereleaseIdentifier,
+			preReleaseId: currentVersion.preReleaseId,
 			hasStableTransition: this.detectStableTransition(recommendation)
 		};
 	}
@@ -131,8 +134,8 @@ var DefaultVersionStrategyService = class {
 		return this.bumper.bump({
 			currentVersion: options.currentVersion,
 			releaseType: "prerelease",
-			prereleaseIdentifier: options.prereleaseIdentifier ?? context.prereleaseIdentifier ?? "alpha",
-			prereleaseBase: options.prereleaseBase
+			preReleaseId: options.preReleaseId ?? context.preReleaseId ?? "alpha",
+			preReleaseBase: options.preReleaseBase
 		});
 	}
 	/**
@@ -143,26 +146,25 @@ var DefaultVersionStrategyService = class {
 	* @returns A result containing the new stable version or an error
 	*/
 	handlePreReleaseToStableTransition(options, recommendation) {
-		if (!recommendation) return FireflyErr(invalidError({
+		if (!recommendation) return FireflyErrAsync(invalidError({
 			message: "Cannot transition to stable version without recommendation",
 			source: "services/version-strategy"
 		}));
-		const graduateResult = this.bumper.bump({
+		return this.bumper.bump({
 			currentVersion: options.currentVersion,
 			releaseType: "graduate"
+		}).andThen((stableVersion) => {
+			if (recommendation.level < 2) {
+				logger.verbose("DefaultVersionStrategyService: Further bumping after graduation...");
+				const releaseType = LEVEL_TO_RELEASE_TYPE[recommendation.level];
+				return this.bumper.bump({
+					currentVersion: stableVersion,
+					releaseType
+				});
+			}
+			logger.verbose("DefaultVersionStrategyService: Graduated to stable version:", stableVersion.raw);
+			return FireflyOkAsync(stableVersion);
 		});
-		if (graduateResult.isErr()) return FireflyErr(graduateResult.error);
-		const stableVersion = graduateResult.value;
-		if (recommendation.level < 2) {
-			logger.verbose("DefaultVersionStrategyService: Further bumping after graduation...");
-			const releaseType = LEVEL_TO_RELEASE_TYPE[recommendation.level];
-			return this.bumper.bump({
-				currentVersion: stableVersion,
-				releaseType
-			});
-		}
-		logger.verbose("DefaultVersionStrategyService: Graduated to stable version:", stableVersion.raw);
-		return FireflyOk(stableVersion);
 	}
 	/**
 	* Creates a new version based on the provided recommendation and pre-release context.
@@ -178,8 +180,8 @@ var DefaultVersionStrategyService = class {
 			return this.bumper.bump({
 				currentVersion: options.currentVersion,
 				releaseType: "prerelease",
-				prereleaseIdentifier: options.prereleaseIdentifier ?? context.prereleaseIdentifier ?? "alpha",
-				prereleaseBase: options.prereleaseBase
+				preReleaseId: options.preReleaseId ?? context.preReleaseId ?? "alpha",
+				preReleaseBase: options.preReleaseBase
 			});
 		}
 		const releaseType = LEVEL_TO_RELEASE_TYPE[recommendation.level];
@@ -187,8 +189,8 @@ var DefaultVersionStrategyService = class {
 		return this.bumper.bump({
 			currentVersion: options.currentVersion,
 			releaseType,
-			prereleaseIdentifier: options.prereleaseIdentifier,
-			prereleaseBase: options.prereleaseBase
+			preReleaseId: options.preReleaseId,
+			preReleaseBase: options.preReleaseBase
 		});
 	}
 	/**
@@ -225,25 +227,22 @@ var DefaultVersionStrategyService = class {
 	*
 	* @param currentVersion - The current version
 	* @param releaseType - The type of release to create
-	* @param prereleaseIdentifier - Optional pre-release identifier
-	* @param prereleaseBase - Optional base for pre-release
+	* @param preReleaseId - Optional pre-release identifier
+	* @param preReleaseBase - Optional base for pre-release
 	* @returns A result containing the version choice or an error
 	*/
-	createSingleChoice(currentVersion, releaseType, prereleaseIdentifier, prereleaseBase) {
+	createSingleChoice(currentVersion, releaseType, preReleaseId, preReleaseBase) {
 		const bumpOptions = {
 			currentVersion,
 			releaseType,
-			prereleaseIdentifier,
-			prereleaseBase
+			preReleaseId,
+			preReleaseBase
 		};
-		const newVersionResult = this.bumper.bump(bumpOptions);
-		if (newVersionResult.isErr()) return FireflyErr(newVersionResult.error);
-		const newVersion = newVersionResult.value;
-		return FireflyOk({
+		return this.bumper.bump(bumpOptions).map((newVersion) => ({
 			label: `${releaseType} (${newVersion.raw})`,
 			hint: this.getVersionDescription(releaseType),
 			value: newVersion.raw
-		});
+		}));
 	}
 };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fireflyy",
-  "version": "4.0.0-dev.a10ed44",
+  "version": "4.0.0-dev.a8aacbe",
   "description": " CLI orchestrator for automatic semantic versioning, changelog generation, and creating releases. Built for my own use cases.",
   "type": "module",
   "license": "MIT",
@@ -53,21 +53,21 @@
     "lint:fix": "biome lint . --fix --unsafe"
   },
   "dependencies": {
-    "c12": "^3.3.2",
+    "c12": "^3.3.3",
     "commander": "^14.0.2",
     "consola": "^3.4.2",
-    "git-cliff": "^2.10.1",
+    "git-cliff": "^2.11.0",
     "neverthrow": "^8.2.0",
     "semver": "^7.7.3",
-    "zod": "^4.1.13"
+    "zod": "^4.3.4"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.8",
-    "@types/bun": "^1.3.3",
+    "@biomejs/biome": "2.3.10",
+    "@types/bun": "^1.3.5",
     "@types/semver": "^7.7.1",
-    "tsdown": "^0.17.0-beta.6",
+    "tsdown": "^0.18.4",
     "typescript": "^5.9.3",
-    "ultracite": "6.3.9"
+    "ultracite": "6.5.1"
   },
   "keywords": [
     "cli",