fireflyy 4.0.0-dev.644fea9 → 4.0.0-dev.988c93c

package/dist/main.js

@@ -1,7 +1,4 @@
 #!/usr/bin/env bun
-import { createConsola } from "consola";
-import { colors } from "consola/utils";
-
 //#region src/core/environment/runtime-env.ts
 /**
 * These are set during CLI initialization in main.ts and provide
@@ -53,25 +50,9 @@ var RuntimeEnv = class {
 	}
 };
 
-//#endregion
-//#region src/infrastructure/logging/index.ts
-const opts = {
-	date: false,
-	compact: true,
-	columns: 0
-};
-const _logger = createConsola({ formatOptions: opts });
-const logger = createConsola({
-	formatOptions: opts,
-	reporters: [{ log(logObj) {
-		if (logObj.type === "verbose") console.log(colors.gray(logObj.args.join(" ")));
-		else _logger.log(logObj);
-	} }]
-});
-
 //#endregion
 //#region package.json
-var version = "4.0.0-dev.644fea9";
+var version = "4.0.0-dev.988c93c";
 var description = " CLI orchestrator for automatic semantic versioning, changelog generation, and creating releases. Built for my own use cases.";
 var dependencies = {
 	"c12": "^3.3.2",
@@ -99,13 +80,10 @@ async function main() {
 		description,
 		gitCliffVersion: dependencies["git-cliff"]?.replace("^", "") || "unknown"
 	});
-	const { createFireflyCLI } = await import("./program-CHc5t2Xm.js");
-	createFireflyCLI().parseAsync(process.argv).catch((error) => {
-		logger.error("Fatal error:", error);
-		process.exit(1);
-	});
+	const { createFireflyCLI } = await import("./program-Dqo9sQjU.js");
+	createFireflyCLI().parseAsync(process.argv).catch(() => process.exit(1));
 }
 main();
 
 //#endregion
-export { RuntimeEnv as n, logger as t };
+export { RuntimeEnv as t };

package/dist/{package-json.service-DACeZzRg.js → package-json.service-CHmtIoQQ.js}

@@ -1,6 +1,6 @@
-import { t as logger } from "./main.js";
-import { d as validationErrAsync, g as toFireflyError, i as FireflyOkAsync, u as validationErr } from "./result.constructors-C9M1MP3_.js";
-import { n as parseSchema } from "./schema.utilities-BGd9t1wm.js";
+import { _ as toFireflyError, d as validationErrAsync, i as FireflyOkAsync, u as validationErr } from "./result.constructors-BMtOWD2-.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
+import { n as parseSchema } from "./schema.utilities-BxiRR-GI.js";
 import { Result } from "neverthrow";
 import z$1 from "zod";
 

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

@@ -1,10 +1,11 @@
-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 { t as RuntimeEnv } from "./main.js";
+import { a as conflictErrAsync, c as notFoundErrAsync, d as validationErrAsync, f as conflictError, g as notFoundError, i as FireflyOkAsync, l as timeoutErrAsync, m as failedError, n as FireflyErrAsync, o as failedErrAsync, r as FireflyOk, s as invalidErr, t as FireflyErr, u as validationErr, v as validationError, y as wrapErrorMessage } from "./result.constructors-BMtOWD2-.js";
+import { n as wrapPromise, t as ensureNotAsync } from "./result.utilities-BTVU-GsT.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
+import { n as parseSchema, t as formatZodErrors } from "./schema.utilities-BxiRR-GI.js";
+import { Command } from "commander";
 import { LogLevels } from "consola";
 import { colors } from "consola/utils";
-import { Command } from "commander";
 import { loadConfig } from "c12";
 import { Result, ResultAsync, err, ok } from "neverthrow";
 import z$1 from "zod";
@@ -1003,9 +1004,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 +1015,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 +1038,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 +1049,59 @@ 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.");
+	return wrapPromise(logger.prompt("Select version bump strategy", {
+		type: "select",
+		options: BUMP_STRATEGIES,
+		initial: defaultStrategy.value,
+		cancel: "undefined"
+	})).andThen((selected) => {
+		if (!selected || selected === "") return failedErrAsync({ message: "Operation cancelled by user" });
+		if (logger.level === LogLevels.verbose) logger.log("");
+		if (logger.level !== LogLevels.verbose) logger.log("");
+		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();
@@ -1130,6 +1179,12 @@ const SSH_REMOTE_REGEX = /git@[^:]+:([^/]+)\/([^/.]+)(?:\.git)?/;
 const SCOPED_PACKAGE_REGEX = /^@([^/]+)\/(.+)$/;
 const PRERELEASE_REGEX = /^\d+\.\d+\.\d+-([a-zA-Z]+)/;
 /**
+* Terminologies:
+*
+* Prepared: The value has been determined and set in the context.
+* Using: The value was explicitly provided in the config and is used as-is.
+*/
+/**
 * Parses a git remote URL to extract owner and repository name.
 * Supports both HTTPS and SSH formats.
 *
@@ -1176,46 +1231,6 @@ function extractPreReleaseId(version) {
 	return version.match(PRERELEASE_REGEX)?.[1];
 }
 /**
-* Hydrates the repository field from git remote URL.
-*
-* Behavior:
-* - If not inside a git repository, resolves to undefined.
-* - If inside a repository, detect the repository URL
-*   using a fall-through strategy (upstream remote → origin → first remote).
-* - Parses the URL and returns "owner/repo" when possible.
-*/
-function hydrateRepository(ctx) {
-	return ctx.services.git.inferRepositoryUrl().map((url) => {
-		if (!url) return null;
-		const parsed = parseGitRemoteUrl(url);
-		if (parsed) return `${parsed.owner}/${parsed.repo}`;
-		return null;
-	}).map((val) => val ?? void 0).andTee((repository) => logger.verbose(`PrepareReleaseConfigTask: Prepared repository: ${repository}`));
-}
-/**
-* Hydrates name, scope, and preReleaseId from package.json.
-*
-* Behavior:
-* - If package.json does not exist, returns all values as undefined.
-* - If it exists, reads package.json and returns parsed results for name, scope and preReleaseId.
-*/
-function hydrateFromPackageJson(ctx) {
-	return ctx.services.fs.exists("package.json").andThen((exists) => {
-		if (!exists) return FireflyOkAsync({
-			name: void 0,
-			scope: void 0,
-			preReleaseId: void 0
-		});
-		return ctx.services.packageJson.read("package.json").andThen((pkg) => zip3Async(hydrateNameFromPackageJson(ctx, pkg), hydrateScopeFromPackageJson(ctx, pkg), hydratePreReleaseIdFromPackageJson(ctx, pkg)).map(([name, scope, preReleaseId]) => {
-			const result = {};
-			if (name) result.name = name;
-			if (scope) result.scope = scope;
-			if (preReleaseId) result.preReleaseId = preReleaseId;
-			return result;
-		}));
-	});
-}
-/**
 * Hydrates the `name` field from package.json when not provided in config.
 *
 * Cases:
@@ -1282,6 +1297,46 @@ function hydratePreReleaseIdFromPackageJson(ctx, packageJson) {
 	return FireflyOkAsync("alpha");
 }
 /**
+* Hydrates name, scope, and preReleaseId from package.json.
+*
+* Behavior:
+* - If package.json does not exist, returns all values as undefined.
+* - If it exists, reads package.json and returns parsed results for name, scope and preReleaseId.
+*/
+function hydrateFromPackageJson(ctx) {
+	return ctx.services.fs.exists("package.json").andThen((exists) => {
+		if (!exists) return FireflyOkAsync({
+			name: void 0,
+			scope: void 0,
+			preReleaseId: void 0
+		});
+		return ctx.services.packageJson.read("package.json").andThen((pkg) => hydrateNameFromPackageJson(ctx, pkg).andThen((name) => hydrateScopeFromPackageJson(ctx, pkg).andThen((scope) => hydratePreReleaseIdFromPackageJson(ctx, pkg).map((preReleaseId) => {
+			const result = {};
+			if (name) result.name = name;
+			if (scope) result.scope = scope;
+			if (preReleaseId) result.preReleaseId = preReleaseId;
+			return result;
+		}))));
+	});
+}
+/**
+* Hydrates the repository field from git remote URL.
+*
+* Behavior:
+* - If not inside a git repository, resolves to undefined.
+* - If inside a repository, detect the repository URL
+*   using a fall-through strategy (upstream remote → origin → first remote).
+* - Parses the URL and returns "owner/repo" when possible.
+*/
+function hydrateRepository(ctx) {
+	return ctx.services.git.inferRepositoryUrl().andThen((url) => {
+		if (!url) return validationErrAsync({ message: "Could not determine git remote URL to infer repository information" });
+		const parsed = parseGitRemoteUrl(url);
+		if (parsed) return FireflyOkAsync(`${parsed.owner}/${parsed.repo}`);
+		return validationErrAsync({ message: `Could not parse repository information from git remote URL: ${url}` });
+	}).andTee((repository) => logger.verbose(`PrepareReleaseConfigTask: Prepared repository: ${repository}`));
+}
+/**
 * Hydrates branch setting from git.
 *
 * Behavior:
@@ -1305,6 +1360,71 @@ function hydrateBranch(ctx) {
 	});
 }
 /**
+* Hydrates repository and branch information from git.
+*
+* Behavior:
+* - If not inside a git repository, resolves both values to undefined.
+* - Otherwise it composes `hydrateRepository` and `hydrateBranch` and returns both values.
+*/
+function hydrateFromGit(ctx) {
+	return ctx.services.git.isInsideRepository().andThen((isRepo) => {
+		if (!isRepo) return FireflyOkAsync({
+			repository: void 0,
+			branch: void 0
+		});
+		return hydrateRepository(ctx).andThen((repository) => hydrateBranch(ctx).map((branch) => {
+			const result = {};
+			if (repository) result.repository = repository;
+			if (branch) result.branch = branch;
+			return result;
+		}));
+	});
+}
+/**
+* Hydrates release flags (releaseLatest, releasePreRelease, releaseDraft).
+*
+* Behavior:
+* - If exactly one flag is explicitly set to true, use that and set others to false.
+* - If no flags are explicitly set, default to releaseLatest = true, others = false.
+* - Validation of exclusivity is handled by the schema, so we only need to determine defaults.
+*/
+function hydrateReleaseFlags(ctx) {
+	const { releaseLatest, releasePreRelease, releaseDraft } = ctx.config;
+	const latestExplicit = releaseLatest === true;
+	const preReleaseExplicit = releasePreRelease === true;
+	const draftExplicit = releaseDraft === true;
+	if (preReleaseExplicit) {
+		logger.verbose(`PrepareReleaseConfigTask: Using "releasePreRelease" as it is explicitly set`);
+		return FireflyOkAsync({
+			releaseLatest: false,
+			releasePreRelease: true,
+			releaseDraft: false
+		});
+	}
+	if (draftExplicit) {
+		logger.verbose(`PrepareReleaseConfigTask: Using "releaseDraft" as it is explicitly set`);
+		return FireflyOkAsync({
+			releaseLatest: false,
+			releasePreRelease: false,
+			releaseDraft: true
+		});
+	}
+	if (latestExplicit) {
+		logger.verbose(`PrepareReleaseConfigTask: Using "releaseLatest" as it is explicitly set`);
+		return FireflyOkAsync({
+			releaseLatest: true,
+			releasePreRelease: false,
+			releaseDraft: false
+		});
+	}
+	logger.verbose("PrepareReleaseConfigTask: Prepared releaseLatest as default since no flag was explicitly set");
+	return FireflyOkAsync({
+		releaseLatest: true,
+		releasePreRelease: false,
+		releaseDraft: false
+	});
+}
+/**
 * Creates the Prepare Release Config Task.
 *
 * This task determines and hydrates configuration settings, by inferring values from the environment.
@@ -1314,17 +1434,24 @@ function hydrateBranch(ctx) {
 * 2. Extracts name and scope from package.json
 * 3. Extracts preReleaseId from package.json version
 * 4. Detects current git branch if not provided
+* 5. Determines release flags (latest, preRelease, draft) with proper defaults
 */
 function createPrepareReleaseConfigTask() {
 	return TaskBuilder.create("prepare-release-config").description("Hydrate and prepare the release configuration").execute((ctx) => {
 		const hydrated = {};
-		return zip3Async(hydrateRepository(ctx), hydrateFromPackageJson(ctx), hydrateBranch(ctx)).map(([repository, pkgData, branch]) => {
-			if (repository) hydrated.repository = repository;
+		return hydrateFromGit(ctx).andThen((gitData) => {
+			if (gitData.repository) hydrated.repository = gitData.repository;
+			if (gitData.branch) hydrated.branch = gitData.branch;
+			return hydrateFromPackageJson(ctx);
+		}).andThen((pkgData) => {
 			if (pkgData.name) hydrated.name = pkgData.name;
 			if (pkgData.scope) hydrated.scope = pkgData.scope;
 			if (pkgData.preReleaseId) hydrated.preReleaseId = pkgData.preReleaseId;
-			if (branch) hydrated.branch = branch;
-			logger.verbose(`PrepareReleaseConfigTask: Hydrated config: ${JSON.stringify(hydrated)}`);
+			return hydrateReleaseFlags(ctx);
+		}).map((releaseFlags) => {
+			hydrated.releaseLatest = releaseFlags.releaseLatest;
+			hydrated.releasePreRelease = releaseFlags.releasePreRelease;
+			hydrated.releaseDraft = releaseFlags.releaseDraft;
 			return ctx.fork("hydratedConfig", hydrated);
 		});
 	}).build();
@@ -1492,7 +1619,7 @@ function validateReleaseFlagExclusivity(ctx) {
 		"releasePreRelease",
 		"releaseDraft"
 	];
-	if (flagNames.filter((k) => ctx.value[k]).length > 1) ctx.issues.push({
+	if (flagNames.filter((k) => ctx.value[k] === true).length > 1) ctx.issues.push({
 		code: "custom",
 		message: `Only one of ${flagNames.join(", ")} can be set to true.`,
 		input: ctx.value,
@@ -1555,9 +1682,9 @@ const ReleaseConfigSchema = z$1.object({
 	skipGit: z$1.coerce.boolean().default(false).describe("Skip all git-related steps."),
 	skipPreflightCheck: z$1.coerce.boolean().default(false).describe("Skip preflight checks."),
 	releaseTitle: z$1.string().default(RELEASE_TITLE_TEMPLATE).describe("GitHub release title with placeholders."),
-	releaseLatest: z$1.coerce.boolean().default(true).describe("Mark as latest release."),
-	releasePreRelease: z$1.coerce.boolean().default(false).describe("Mark as pre-release."),
-	releaseDraft: z$1.coerce.boolean().default(false).describe("Release as draft version.")
+	releaseLatest: z$1.coerce.boolean().optional().describe("Mark as latest release."),
+	releasePreRelease: z$1.coerce.boolean().optional().describe("Mark as pre-release."),
+	releaseDraft: z$1.coerce.boolean().optional().describe("Release as draft version.")
 }).check((ctx) => {
 	validateReleaseFlagExclusivity(ctx);
 	validateSkipGitRedundancy(ctx);
@@ -1611,21 +1738,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-B8qg87n-.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-CHmtIoQQ.js");
 			return createPackageJsonService(fs);
 		}
 	}),
 	git: defineService({ factory: async ({ basePath }) => {
-		const { createGitService } = await import("./git.service-CACrfCW8.js");
+		const { createGitService } = await import("./git.service-BBqDH7qx.js");
 		return createGitService(basePath);
-	} })
+	} }),
+	versionBumper: defineService({ factory: async () => {
+		const { createVersionBumperService } = await import("./version-bumper.service-DMYR0npB.js");
+		return createVersionBumperService();
+	} }),
+	versionStrategy: defineService({
+		dependencies: ["versionBumper"],
+		factory: async ({ getService }) => {
+			const versionBumper = await getService("versionBumper");
+			const { createVersionStrategyService } = await import("./version-strategy.service-CmfeZLYC.js");
+			return createVersionStrategyService(versionBumper);
+		}
+	}),
+	commitAnalysis: defineService({
+		dependencies: ["git"],
+		factory: async ({ getService }) => {
+			const git = await getService("git");
+			const { createCommitAnalysisService } = await import("./commit-analysis.service-Ba6hLgsr.js");
+			return createCommitAnalysisService(git);
+		}
+	})
 };
 /**
 * Array of all service keys for iteration
@@ -2264,7 +2411,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,
@@ -2292,6 +2443,8 @@ var WorkflowExecutor = class {
 	handleExecutionFailure(args) {
 		const { error, startTime, executedTaskIds, skippedTaskIds, initialContext } = args;
 		const endTime = /* @__PURE__ */ new Date();
+		if (DebugFlags.showRawError) logger.error(error);
+		else logger.error(error.message);
 		if (this.options.enableRollback && this.executedTasks.length > 0) {
 			logger.verbose(`WorkflowExecutor: Attempting rollback of ${this.executedTasks.length} tasks`);
 			return this.rollback(initialContext).andThen((rollbackSuccess) => {
@@ -2367,9 +2520,6 @@ var WorkflowExecutor = class {
 			executionLists.executedTaskIds.push(currentTask.meta.id);
 			this.executedTasks.push(currentTask);
 			return this.executeTasksSequentially(remainingTasks, updatedContext, executionLists.executedTaskIds, executionLists.skippedTaskIds);
-		}).mapErr((error) => {
-			logger.error(error.message);
-			return error;
 		});
 	}
 	rollback(context) {

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

@@ -258,4 +258,4 @@ const invalidErr = (opts) => err(invalidError(opts));
 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 { 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 };

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

@@ -1,4 +1,4 @@
-import { d as validationErrAsync, g as toFireflyError, i as FireflyOkAsync, p as createFireflyError } from "./result.constructors-C9M1MP3_.js";
+import { _ as toFireflyError, d as validationErrAsync, i as FireflyOkAsync, p as createFireflyError } from "./result.constructors-BMtOWD2-.js";
 import { ResultAsync } from "neverthrow";
 
 //#region src/core/result/result.utilities.ts
@@ -17,16 +17,6 @@ function wrapPromise(promise) {
 function ensureNotAsync(condition, errorOpts) {
 	return condition ? validationErrAsync(errorOpts) : FireflyOkAsync(void 0);
 }
-/**
-* Async version of zip3.
-*/
-function zip3Async(resultA, resultB, resultC) {
-	return ResultAsync.combine([
-		resultA,
-		resultB,
-		resultC
-	]);
-}
 
 //#endregion
-export { wrapPromise as n, zip3Async as r, ensureNotAsync as t };
+export { wrapPromise as n, ensureNotAsync as t };

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

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