@fuzdev/fuz_gitops 0.77.0 → 0.78.1

package/src/lib/operations_defaults.ts

@@ -7,15 +7,15 @@
  * @module
  */
 
-import {spawn_out} from '@fuzdev/fuz_util/process.js';
-import {readFile, writeFile, mkdir, stat} from 'node:fs/promises';
-import {git_checkout, type GitBranch, type GitOrigin} from '@fuzdev/fuz_util/git.js';
-import {fs_classify_error} from '@fuzdev/fuz_util/fs.js';
-import {EMPTY_OBJECT} from '@fuzdev/fuz_util/object.js';
-
-import {has_changesets, read_changesets, predict_next_version} from './changeset_reader.js';
-import {wait_for_package} from './npm_registry.js';
-import {run_preflight_checks} from './preflight_checks.js';
+import { spawn_out } from '@fuzdev/fuz_util/process.ts';
+import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+import { git_checkout, type GitBranch, type GitOrigin } from '@fuzdev/fuz_util/git.ts';
+import { fs_classify_error } from '@fuzdev/fuz_util/fs.ts';
+import { EMPTY_OBJECT } from '@fuzdev/fuz_util/object.ts';
+
+import { has_changesets, read_changesets, predict_next_version } from './changeset_reader.ts';
+import { wait_for_package } from './npm_registry.ts';
+import { run_preflight_checks } from './preflight_checks.ts';
 import {
 	git_add,
 	git_commit,
@@ -31,8 +31,8 @@ import {
 	git_current_branch_name_required,
 	git_current_commit_hash_required,
 	git_check_clean_workspace_as_boolean,
-	git_has_remote,
-} from './git_operations.js';
+	git_has_remote
+} from './git_operations.ts';
 import type {
 	ChangesetOperations,
 	GitOperations,
@@ -41,200 +41,202 @@ import type {
 	PreflightOperations,
 	FsOperations,
 	BuildOperations,
-	GitopsOperations,
-} from './operations.js';
+	GitopsOperations
+} from './operations.ts';
 
 /** Wrap an async function that returns a value */
 const wrap_with_value = async <T>(
-	fn: () => Promise<T>,
-): Promise<{ok: true; value: T} | {ok: false; message: string}> => {
+	fn: () => Promise<T>
+): Promise<{ ok: true; value: T } | { ok: false; message: string }> => {
 	try {
 		const value = await fn();
-		return {ok: true, value};
+		return { ok: true, value };
 	} catch (error) {
-		return {ok: false, message: String(error)};
+		return { ok: false, message: String(error) };
 	}
 };
 
 /** Wrap an async function, ignoring its return value */
 const wrap_void = async (
-	fn: () => Promise<unknown>,
-): Promise<{ok: true} | {ok: false; message: string}> => {
+	fn: () => Promise<unknown>
+): Promise<{ ok: true } | { ok: false; message: string }> => {
 	try {
 		await fn();
-		return {ok: true};
+		return { ok: true };
 	} catch (error) {
-		return {ok: false, message: String(error)};
+		return { ok: false, message: String(error) };
 	}
 };
 
 export const default_changeset_operations: ChangesetOperations = {
 	has_changesets: async (options) => {
-		const {repo} = options;
+		const { repo } = options;
 		return wrap_with_value(() => has_changesets(repo));
 	},
 
 	read_changesets: async (options) => {
-		const {repo, log} = options;
+		const { repo, log } = options;
 		return wrap_with_value(() => read_changesets(repo, log));
 	},
 
 	predict_next_version: async (options) => {
-		const {repo, log} = options;
+		const { repo, log } = options;
 		try {
 			const result = await predict_next_version(repo, log);
 			if (result === null) {
 				return null;
 			}
-			return {ok: true, ...result};
+			return { ok: true, ...result };
 		} catch (error) {
-			return {ok: false, message: String(error)};
+			return { ok: false, message: String(error) };
 		}
-	},
+	}
 };
 
 export const default_git_operations: GitOperations = {
 	// Core git info
 	current_branch_name: async (options) => {
-		const {cwd} = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() => git_current_branch_name_required(cwd ? {cwd} : undefined));
+		const { cwd } = options ?? EMPTY_OBJECT;
+		return wrap_with_value(() => git_current_branch_name_required(cwd ? { cwd } : undefined));
 	},
 
 	current_commit_hash: async (options) => {
-		const {branch, cwd} = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() => git_current_commit_hash_required(branch, cwd ? {cwd} : undefined));
+		const { branch, cwd } = options ?? EMPTY_OBJECT;
+		return wrap_with_value(() =>
+			git_current_commit_hash_required(branch, cwd ? { cwd } : undefined)
+		);
 	},
 
 	check_clean_workspace: async (options) => {
-		const {cwd} = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() => git_check_clean_workspace_as_boolean(cwd ? {cwd} : undefined));
+		const { cwd } = options ?? EMPTY_OBJECT;
+		return wrap_with_value(() => git_check_clean_workspace_as_boolean(cwd ? { cwd } : undefined));
 	},
 
 	// Branch operations
 	checkout: async (options) => {
-		const {branch, cwd} = options;
-		return wrap_void(() => git_checkout(branch, cwd ? {cwd} : undefined));
+		const { branch, cwd } = options;
+		return wrap_void(() => git_checkout(branch, cwd ? { cwd } : undefined));
 	},
 
 	pull: async (options) => {
-		const {origin, branch, cwd} = options ?? EMPTY_OBJECT;
+		const { origin, branch, cwd } = options ?? EMPTY_OBJECT;
 		try {
 			// Omit the branch arg when absent: a trailing `''` makes git pull the remote's
 			// default branch (origin/HEAD) instead of the current branch's upstream.
 			const spawned = await spawn_out(
 				'git',
 				['pull', origin || 'origin', ...(branch ? [branch] : [])],
-				cwd ? {cwd} : undefined,
+				cwd ? { cwd } : undefined
 			);
 			if (spawned.result.ok) {
-				return {ok: true};
+				return { ok: true };
 			} else {
-				return {ok: false, message: spawned.stderr || 'Pull failed'};
+				return { ok: false, message: spawned.stderr || 'Pull failed' };
 			}
 		} catch (error) {
-			return {ok: false, message: String(error)};
+			return { ok: false, message: String(error) };
 		}
 	},
 
 	switch_branch: async (options) => {
-		const {branch, pull, cwd} = options;
-		return wrap_void(() => git_switch_branch(branch as GitBranch, pull, cwd ? {cwd} : undefined));
+		const { branch, pull, cwd } = options;
+		return wrap_void(() => git_switch_branch(branch as GitBranch, pull, cwd ? { cwd } : undefined));
 	},
 
 	has_remote: async (options) => {
-		const {remote, cwd} = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() => git_has_remote(remote, cwd ? {cwd} : undefined));
+		const { remote, cwd } = options ?? EMPTY_OBJECT;
+		return wrap_with_value(() => git_has_remote(remote, cwd ? { cwd } : undefined));
 	},
 
 	// Staging and committing
 	add: async (options) => {
-		const {files, cwd} = options;
-		return wrap_void(() => git_add(files, cwd ? {cwd} : undefined));
+		const { files, cwd } = options;
+		return wrap_void(() => git_add(files, cwd ? { cwd } : undefined));
 	},
 
 	commit: async (options) => {
-		const {message, cwd} = options;
-		return wrap_void(() => git_commit(message, cwd ? {cwd} : undefined));
+		const { message, cwd } = options;
+		return wrap_void(() => git_commit(message, cwd ? { cwd } : undefined));
 	},
 
 	add_and_commit: async (options) => {
-		const {files, message, cwd} = options;
-		return wrap_void(() => git_add_and_commit(files, message, cwd ? {cwd} : undefined));
+		const { files, message, cwd } = options;
+		return wrap_void(() => git_add_and_commit(files, message, cwd ? { cwd } : undefined));
 	},
 
 	has_changes: async (options) => {
-		const {cwd} = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() => git_has_changes(cwd ? {cwd} : undefined));
+		const { cwd } = options ?? EMPTY_OBJECT;
+		return wrap_with_value(() => git_has_changes(cwd ? { cwd } : undefined));
 	},
 
 	list_uncommitted_files: async (options) => {
-		const {cwd} = options ?? EMPTY_OBJECT;
-		return wrap_with_value(() => git_list_uncommitted_files(cwd ? {cwd} : undefined));
+		const { cwd } = options ?? EMPTY_OBJECT;
+		return wrap_with_value(() => git_list_uncommitted_files(cwd ? { cwd } : undefined));
 	},
 
 	// Tagging
 	tag: async (options) => {
-		const {tag_name, message, cwd} = options;
-		return wrap_void(() => git_tag(tag_name, message, cwd ? {cwd} : undefined));
+		const { tag_name, message, cwd } = options;
+		return wrap_void(() => git_tag(tag_name, message, cwd ? { cwd } : undefined));
 	},
 
 	push_tag: async (options) => {
-		const {tag_name, origin, cwd} = options;
-		return wrap_void(() => git_push_tag(tag_name, origin as GitOrigin, cwd ? {cwd} : undefined));
+		const { tag_name, origin, cwd } = options;
+		return wrap_void(() => git_push_tag(tag_name, origin as GitOrigin, cwd ? { cwd } : undefined));
 	},
 
 	// Stashing
 	stash: async (options) => {
-		const {message, cwd} = options ?? EMPTY_OBJECT;
-		return wrap_void(() => git_stash(message, cwd ? {cwd} : undefined));
+		const { message, cwd } = options ?? EMPTY_OBJECT;
+		return wrap_void(() => git_stash(message, cwd ? { cwd } : undefined));
 	},
 
 	stash_pop: async (options) => {
-		const {cwd} = options ?? EMPTY_OBJECT;
-		return wrap_void(() => git_stash_pop(cwd ? {cwd} : undefined));
+		const { cwd } = options ?? EMPTY_OBJECT;
+		return wrap_void(() => git_stash_pop(cwd ? { cwd } : undefined));
 	},
 
 	// File change detection
 	has_file_changed: async (options) => {
-		const {from_commit, to_commit, file_path, cwd} = options;
+		const { from_commit, to_commit, file_path, cwd } = options;
 		return wrap_with_value(() =>
-			git_has_file_changed(from_commit, to_commit, file_path, cwd ? {cwd} : undefined),
+			git_has_file_changed(from_commit, to_commit, file_path, cwd ? { cwd } : undefined)
 		);
-	},
+	}
 };
 
 export const default_process_operations: ProcessOperations = {
 	spawn: async (options) => {
-		const {cmd, args, cwd} = options;
+		const { cmd, args, cwd } = options;
 		try {
-			const spawned = await spawn_out(cmd, args, cwd ? {cwd} : undefined);
+			const spawned = await spawn_out(cmd, args, cwd ? { cwd } : undefined);
 			if (spawned.result.ok) {
 				return {
 					ok: true,
 					stdout: spawned.stdout || undefined,
-					stderr: spawned.stderr || undefined,
+					stderr: spawned.stderr || undefined
 				};
 			} else {
 				return {
 					ok: false,
 					message: 'Command failed',
-					stderr: spawned.stderr || undefined,
+					stderr: spawned.stderr || undefined
 				};
 			}
 		} catch (error) {
-			return {ok: false, message: String(error)};
+			return { ok: false, message: String(error) };
 		}
-	},
+	}
 };
 
 export const default_npm_operations: NpmOperations = {
 	wait_for_package: async (options) => {
-		const {pkg, version, wait_options, log} = options;
+		const { pkg, version, wait_options, log } = options;
 		try {
-			await wait_for_package(pkg, version, {...wait_options, log});
-			return {ok: true};
+			await wait_for_package(pkg, version, { ...wait_options, log });
+			return { ok: true };
 		} catch (error) {
-			return {ok: false, message: String(error), timeout: true};
+			return { ok: false, message: String(error), timeout: true };
 		}
 	},
 
@@ -244,12 +246,12 @@ export const default_npm_operations: NpmOperations = {
 			if (result.stdout) {
 				const username = result.stdout.trim();
 				if (username) {
-					return {ok: true, username};
+					return { ok: true, username };
 				}
 			}
-			return {ok: false, message: 'Not logged in to npm'};
+			return { ok: false, message: 'Not logged in to npm' };
 		} catch (error) {
-			return {ok: false, message: String(error)};
+			return { ok: false, message: String(error) };
 		}
 	},
 
@@ -257,63 +259,63 @@ export const default_npm_operations: NpmOperations = {
 		try {
 			const result = await spawn_out('npm', ['ping']);
 			if (result.stdout) {
-				return {ok: true};
+				return { ok: true };
 			}
-			return {ok: false, message: 'Failed to ping npm registry'};
+			return { ok: false, message: 'Failed to ping npm registry' };
 		} catch (error) {
-			return {ok: false, message: String(error)};
+			return { ok: false, message: String(error) };
 		}
 	},
 
 	install: async (options) => {
-		const {cwd} = options ?? EMPTY_OBJECT;
+		const { cwd } = options ?? EMPTY_OBJECT;
 		try {
-			const spawned = await spawn_out('npm', ['install'], cwd ? {cwd} : undefined);
+			const spawned = await spawn_out('npm', ['install'], cwd ? { cwd } : undefined);
 			if (spawned.result.ok) {
-				return {ok: true};
+				return { ok: true };
 			} else {
-				return {ok: false, message: 'Install failed', stderr: spawned.stderr || undefined};
+				return { ok: false, message: 'Install failed', stderr: spawned.stderr || undefined };
 			}
 		} catch (error) {
-			return {ok: false, message: String(error)};
+			return { ok: false, message: String(error) };
 		}
-	},
+	}
 };
 
 export const default_preflight_operations: PreflightOperations = {
 	run_preflight_checks: async (options) => {
 		return run_preflight_checks(options);
-	},
+	}
 };
 
 export const default_fs_operations: FsOperations = {
 	readFile: async (options) => {
-		const {path, encoding} = options;
+		const { path, encoding } = options;
 		try {
 			const value = await readFile(path, encoding);
-			return {ok: true, value};
+			return { ok: true, value };
 		} catch (error) {
-			return {ok: false, ...fs_classify_error(error)};
+			return { ok: false, ...fs_classify_error(error) };
 		}
 	},
 
 	writeFile: async (options) => {
-		const {path, content} = options;
+		const { path, content } = options;
 		try {
 			await writeFile(path, content);
-			return {ok: true};
+			return { ok: true };
 		} catch (error) {
-			return {ok: false, ...fs_classify_error(error)};
+			return { ok: false, ...fs_classify_error(error) };
 		}
 	},
 
 	mkdir: async (options) => {
-		const {path, recursive} = options;
+		const { path, recursive } = options;
 		try {
-			await mkdir(path, {recursive});
-			return {ok: true};
+			await mkdir(path, { recursive });
+			return { ok: true };
 		} catch (error) {
-			return {ok: false, ...fs_classify_error(error)};
+			return { ok: false, ...fs_classify_error(error) };
 		}
 	},
 
@@ -324,28 +326,28 @@ export const default_fs_operations: FsOperations = {
 		} catch {
 			return false;
 		}
-	},
+	}
 };
 
 export const default_build_operations: BuildOperations = {
 	build_package: async (options) => {
-		const {repo, log} = options;
+		const { repo, log } = options;
 		try {
 			log?.info(`  Building ${repo.library.name}...`);
-			const spawned = await spawn_out('gro', ['build'], {cwd: repo.repo_dir});
+			const spawned = await spawn_out('gro', ['build'], { cwd: repo.repo_dir });
 			if (spawned.result.ok) {
-				return {ok: true};
+				return { ok: true };
 			} else {
 				return {
 					ok: false,
 					message: 'Build failed',
-					output: spawned.stderr || spawned.stdout || 'Build failed',
+					output: spawned.stderr || spawned.stdout || 'Build failed'
 				};
 			}
 		} catch (error) {
-			return {ok: false, message: String(error)};
+			return { ok: false, message: String(error) };
 		}
-	},
+	}
 };
 
 /**
@@ -358,5 +360,5 @@ export const default_gitops_operations: GitopsOperations = {
 	npm: default_npm_operations,
 	preflight: default_preflight_operations,
 	fs: default_fs_operations,
-	build: default_build_operations,
+	build: default_build_operations
 };

package/src/lib/output_helpers.ts

@@ -1,5 +1,5 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import {writeFile} from 'node:fs/promises';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { writeFile } from 'node:fs/promises';
 
 export type OutputFormat = 'stdout' | 'json' | 'markdown';
 
@@ -31,9 +31,9 @@ export interface OutputFormatters<T> {
 export const format_and_output = async <T>(
 	data: T,
 	formatters: OutputFormatters<T>,
-	options: OutputOptions,
+	options: OutputOptions
 ): Promise<void> => {
-	const {format, outfile, log} = options;
+	const { format, outfile, log } = options;
 
 	// Handle stdout format (special case - uses logger directly)
 	if (format === 'stdout') {

package/src/lib/preflight_checks.ts

@@ -1,21 +1,21 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import type {Result} from '@fuzdev/fuz_util/result.js';
-import {spawn_out} from '@fuzdev/fuz_util/process.js';
-import {styleText as st} from 'node:util';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import type { Result } from '@fuzdev/fuz_util/result.ts';
+import { spawn_out } from '@fuzdev/fuz_util/process.ts';
+import { styleText as st } from 'node:util';
 
-import type {LocalRepo} from './local_repo.js';
+import type { LocalRepo } from './local_repo.ts';
 import type {
 	GitOperations,
 	NpmOperations,
 	BuildOperations,
-	ChangesetOperations,
-} from './operations.js';
+	ChangesetOperations
+} from './operations.ts';
 import {
 	default_git_operations,
 	default_npm_operations,
 	default_build_operations,
-	default_changeset_operations,
-} from './operations_defaults.js';
+	default_changeset_operations
+} from './operations_defaults.ts';
 
 export interface PreflightOptions {
 	skip_changesets?: boolean;
@@ -68,7 +68,7 @@ export const run_preflight_checks = async ({
 	git_ops = default_git_operations,
 	npm_ops = default_npm_operations,
 	build_ops = default_build_operations,
-	changeset_ops = default_changeset_operations,
+	changeset_ops = default_changeset_operations
 }: RunPreflightChecksOptions): Promise<PreflightResult> => {
 	const {
 		skip_changesets = false,
@@ -76,7 +76,7 @@ export const run_preflight_checks = async ({
 		required_branch = 'main',
 		check_remote = true,
 		estimate_time = true,
-		log,
+		log
 	} = preflight_options;
 
 	const warnings: Array<string> = [];
@@ -91,7 +91,7 @@ export const run_preflight_checks = async ({
 	// 1. Check clean workspaces - must be 100% clean before publishing
 	log?.info('  Checking workspace cleanliness...');
 	for (const repo of repos) {
-		const clean_result = await git_ops.check_clean_workspace({cwd: repo.repo_dir});
+		const clean_result = await git_ops.check_clean_workspace({ cwd: repo.repo_dir });
 		if (!clean_result.ok) {
 			errors.push(`${repo.library.name} failed workspace check: ${clean_result.message}`);
 			continue;
@@ -99,14 +99,14 @@ export const run_preflight_checks = async ({
 
 		if (!clean_result.value) {
 			// Get list of changed files for better error message
-			const files_result = await git_ops.list_uncommitted_files({cwd: repo.repo_dir});
+			const files_result = await git_ops.list_uncommitted_files({ cwd: repo.repo_dir });
 			if (files_result.ok) {
 				// No filtering - workspace must be 100% clean
 				const unexpected_files = files_result.value;
 
 				if (unexpected_files.length > 0) {
 					errors.push(
-						`${repo.library.name} has uncommitted changes in: ${unexpected_files.slice(0, 3).join(', ')}${unexpected_files.length > 3 ? ` and ${unexpected_files.length - 3} more` : ''}`,
+						`${repo.library.name} has uncommitted changes in: ${unexpected_files.slice(0, 3).join(', ')}${unexpected_files.length > 3 ? ` and ${unexpected_files.length - 3} more` : ''}`
 					);
 				}
 			} else {
@@ -118,7 +118,7 @@ export const run_preflight_checks = async ({
 	// 2. Check correct branch
 	log?.info(`  Checking branches (expecting ${required_branch})...`);
 	for (const repo of repos) {
-		const branch_result = await git_ops.current_branch_name({cwd: repo.repo_dir});
+		const branch_result = await git_ops.current_branch_name({ cwd: repo.repo_dir });
 		if (!branch_result.ok) {
 			errors.push(`${repo.library.name} failed branch check: ${branch_result.message}`);
 			continue;
@@ -126,7 +126,7 @@ export const run_preflight_checks = async ({
 
 		if (branch_result.value !== required_branch) {
 			errors.push(
-				`${repo.library.name} is on branch '${branch_result.value}', expected '${required_branch}'`,
+				`${repo.library.name} is on branch '${branch_result.value}', expected '${required_branch}'`
 			);
 		}
 	}
@@ -135,7 +135,7 @@ export const run_preflight_checks = async ({
 	if (!skip_changesets) {
 		log?.info('  Checking for changesets...');
 		for (const repo of repos) {
-			const has_result = await changeset_ops.has_changesets({repo});
+			const has_result = await changeset_ops.has_changesets({ repo });
 			if (!has_result.ok) {
 				errors.push(`${repo.library.name} failed changeset check: ${has_result.message}`);
 				continue;
@@ -162,12 +162,12 @@ export const run_preflight_checks = async ({
 		for (let i = 0; i < repos_to_build.length; i++) {
 			const repo = repos_to_build[i]!;
 			log?.info(
-				st('dim', `    [${i + 1}/${repos_to_build.length}] Building ${repo.library.name}...`),
+				st('dim', `    [${i + 1}/${repos_to_build.length}] Building ${repo.library.name}...`)
 			);
-			const build_result = await build_ops.build_package({repo, log});
+			const build_result = await build_ops.build_package({ repo, log });
 			if (!build_result.ok) {
 				errors.push(
-					`${repo.library.name} failed to build: ${build_result.output || build_result.message || 'unknown error'}`,
+					`${repo.library.name} failed to build: ${build_result.output || build_result.message || 'unknown error'}`
 				);
 			} else {
 				log?.info(st('dim', `    ✓ ${repo.library.name} built successfully`));
@@ -217,8 +217,8 @@ export const run_preflight_checks = async ({
 			log?.info(
 				st(
 					'dim',
-					`  Estimated publish time: ~${Math.ceil(estimated_duration / 60)} minutes for ${packages_to_publish} package(s)`,
-				),
+					`  Estimated publish time: ~${Math.ceil(estimated_duration / 60)} minutes for ${packages_to_publish} package(s)`
+				)
 			);
 		}
 	}
@@ -251,19 +251,19 @@ export const run_preflight_checks = async ({
 		repos_with_changesets,
 		repos_without_changesets,
 		estimated_duration,
-		npm_username,
+		npm_username
 	};
 };
 
-const check_git_remote = async (cwd: string): Promise<Result<object, {message: string}>> => {
+const check_git_remote = async (cwd: string): Promise<Result<object, { message: string }>> => {
 	try {
 		// Try to fetch refs from remote without downloading objects
-		const result = await spawn_out('git', ['ls-remote', '--heads', 'origin'], {cwd});
+		const result = await spawn_out('git', ['ls-remote', '--heads', 'origin'], { cwd });
 		if (result.stdout || result.stderr) {
-			return {ok: true};
+			return { ok: true };
 		}
-		return {ok: false, message: 'No response from git remote'};
+		return { ok: false, message: 'No response from git remote' };
 	} catch (error) {
-		return {ok: false, message: String(error)};
+		return { ok: false, message: String(error) };
 	}
 };

package/src/lib/publish_gate.ts

@@ -8,14 +8,12 @@
  * @module
  */
 
-import type {PublishingResult} from './multi_repo_publisher.js';
-import type {PublishingPlan} from './publishing_plan.js';
+import type { PublishingResult } from './multi_repo_publisher.ts';
+import type { PublishingPlan } from './publishing_plan.ts';
 
 /** What the task should do with a generated plan before executing the cascade. */
 export type PublishGate =
-	| {action: 'blocked'; message: string}
-	| {action: 'confirm'}
-	| {action: 'proceed'};
+	{ action: 'blocked'; message: string } | { action: 'confirm' } | { action: 'proceed' };
 
 export interface PublishGateOptions {
 	/** A real publish (`--wetrun`); a dry run never prompts. */
@@ -36,11 +34,11 @@ export interface PublishGateOptions {
  * - `proceed`: a dry run, or a `--no-plan` real publish — no prompt.
  */
 export const decide_publish_gate = (options: PublishGateOptions): PublishGate => {
-	if (!options.wetrun || !options.show_plan) return {action: 'proceed'};
+	if (!options.wetrun || !options.show_plan) return { action: 'proceed' };
 	if (options.plan.errors.length > 0) {
-		return {action: 'blocked', message: 'Cannot proceed with publishing due to errors'};
+		return { action: 'blocked', message: 'Cannot proceed with publishing due to errors' };
 	}
-	return {action: 'confirm'};
+	return { action: 'confirm' };
 };
 
 /**
@@ -49,5 +47,5 @@ export const decide_publish_gate = (options: PublishGateOptions): PublishGate =>
  */
 export const publish_run_failed = (
 	result: Pick<PublishingResult, 'ok'>,
-	fatal_error: Error | null,
+	fatal_error: Error | null
 ): boolean => !result.ok || fatal_error !== null;