@fuzdev/fuz_gitops 0.77.0 → 0.78.1

package/src/lib/publish_steps.ts

@@ -8,17 +8,17 @@
  * @module
  */
 
-import type {BumpType} from './version_utils.js';
-import type {PublishingPlan, VersionChange} from './publishing_plan.js';
-import {UnreachableError} from '@fuzdev/fuz_util/error.js';
+import type { BumpType } from './version_utils.ts';
+import type { PublishingPlan, VersionChange } from './publishing_plan.ts';
+import { UnreachableError } from '@fuzdev/fuz_util/error.ts';
 
 /** How a package's version bump arises in the plan. */
 export type PublishStepVia = 'changeset' | 'auto_changeset' | 'escalation';
 
 /** One ordered side-effect a wetrun would perform. */
 export type PublishStep =
-	| {kind: 'publish'; repo: string; from: string; to: string; bump: BumpType; via: PublishStepVia}
-	| {kind: 'npm_wait'; repo: string; version: string}
+	| { kind: 'publish'; repo: string; from: string; to: string; bump: BumpType; via: PublishStepVia }
+	| { kind: 'npm_wait'; repo: string; version: string }
 	| {
 			kind: 'dependency_update';
 			dependent: string;
@@ -27,8 +27,8 @@ export type PublishStep =
 			dep_type: 'prod' | 'peer';
 			creates_changeset: boolean;
 	  }
-	| {kind: 'dev_dep_update'; repo: string; dependency: string; to: string}
-	| {kind: 'deploy'; repo: string; builds: boolean};
+	| { kind: 'dev_dep_update'; repo: string; dependency: string; to: string }
+	| { kind: 'deploy'; repo: string; builds: boolean };
 
 export interface DerivePublishStepsOptions {
 	/** Include the deploy phase (the publisher only deploys with `--deploy`). */
@@ -51,11 +51,11 @@ const step_via = (change: VersionChange): PublishStepVia =>
  */
 export const derive_publish_steps = (
 	plan: PublishingPlan,
-	options: DerivePublishStepsOptions = {},
+	options: DerivePublishStepsOptions = {}
 ): Array<PublishStep> => {
-	const {deploy = false} = options;
+	const { deploy = false } = options;
 	const changes: Map<string, VersionChange> = new Map(
-		plan.version_changes.map((vc) => [vc.package_name, vc]),
+		plan.version_changes.map((vc) => [vc.package_name, vc])
 	);
 
 	const steps: Array<PublishStep> = [];
@@ -72,9 +72,9 @@ export const derive_publish_steps = (
 			from: change.from,
 			to: change.to,
 			bump: change.bump_type,
-			via: step_via(change),
+			via: step_via(change)
 		});
-		steps.push({kind: 'npm_wait', repo, version: change.to});
+		steps.push({ kind: 'npm_wait', repo, version: change.to });
 		changed.add(repo);
 
 		// Prod/peer dependents are rewritten right after this publishes. A dependent that
@@ -92,7 +92,7 @@ export const derive_publish_steps = (
 				dependency: repo,
 				to: change.to,
 				dep_type: update.type === 'peerDependencies' ? 'peer' : 'prod',
-				creates_changeset: republishes,
+				creates_changeset: republishes
 			});
 			changed.add(update.dependent_package);
 		}
@@ -109,7 +109,7 @@ export const derive_publish_steps = (
 			kind: 'dev_dep_update',
 			repo: update.dependent_package,
 			dependency: update.updated_dependency,
-			to: dep_change.to,
+			to: dep_change.to
 		});
 		changed.add(update.dependent_package);
 	}
@@ -117,7 +117,7 @@ export const derive_publish_steps = (
 	// Phase 3: deploy every changed repo (only with --deploy). Each builds fresh.
 	if (deploy) {
 		for (const repo of changed) {
-			steps.push({kind: 'deploy', repo, builds: true});
+			steps.push({ kind: 'deploy', repo, builds: true });
 		}
 	}
 

package/src/lib/publishing_event.ts

@@ -14,7 +14,7 @@
  * @module
  */
 
-import {z} from 'zod';
+import { z } from 'zod';
 
 /**
  * Coarse triage classification for a failed package. Lets consumers branch on
@@ -30,17 +30,17 @@ export const PublishingErrorCode = z.enum([
 	// invariant violation, distinct from an ordinary publish failure (see fail-loud
 	// drift detection in `multi_repo_publisher.ts`)
 	'drift',
-	'other',
+	'other'
 ]);
 export type PublishingErrorCode = z.infer<typeof PublishingErrorCode>;
 
 /** Tallied outcome of a publishing run, derived from its events via `summarize_events`. */
 export const PublishingRunSummary = z.strictObject({
-	total: z.number().meta({description: 'packages in the publishing order (the candidate set)'}),
-	published: z.number().meta({description: 'packages published (or, in a dry run, predicted)'}),
+	total: z.number().meta({ description: 'packages in the publishing order (the candidate set)' }),
+	published: z.number().meta({ description: 'packages published (or, in a dry run, predicted)' }),
 	failed: z.number(),
 	skipped: z.number(),
-	duration: z.number().meta({description: 'wall-clock duration in milliseconds'}),
+	duration: z.number().meta({ description: 'wall-clock duration in milliseconds' })
 });
 export type PublishingRunSummary = z.infer<typeof PublishingRunSummary>;
 
@@ -51,13 +51,15 @@ export type PublishingRunSummary = z.infer<typeof PublishingRunSummary>;
 export const PublishingEvent = z.discriminatedUnion('event', [
 	z.strictObject({
 		event: z.literal('run_started'),
-		wetrun: z.boolean().meta({description: 'false means every package_completed is a prediction'}),
-		total: z.number(),
+		wetrun: z
+			.boolean()
+			.meta({ description: 'false means every package_completed is a prediction' }),
+		total: z.number()
 	}),
 	z.strictObject({
 		event: z.literal('package_skipped'),
 		name: z.string(),
-		reason: z.string(),
+		reason: z.string()
 	}),
 	z.strictObject({
 		event: z.literal('package_completed'),
@@ -67,19 +69,19 @@ export const PublishingEvent = z.discriminatedUnion('event', [
 		// mirrors `BumpType` from `version_utils.ts`; inline so the event schema is self-contained
 		bump_type: z.enum(['major', 'minor', 'patch']),
 		breaking: z.boolean(),
-		commit: z.string().meta({description: "'simulated' in a dry run, otherwise the commit hash"}),
-		tag: z.string(),
+		commit: z.string().meta({ description: "'simulated' in a dry run, otherwise the commit hash" }),
+		tag: z.string()
 	}),
 	z.strictObject({
 		event: z.literal('npm_waited'),
 		name: z.string(),
-		version: z.string().meta({description: 'the version waited on after publishing'}),
+		version: z.string().meta({ description: 'the version waited on after publishing' })
 	}),
 	z.strictObject({
 		event: z.literal('package_failed'),
 		name: z.string(),
 		error: z.string(),
-		code: PublishingErrorCode,
+		code: PublishingErrorCode
 	}),
 	z.strictObject({
 		event: z.literal('dependency_updated'),
@@ -91,25 +93,25 @@ export const PublishingEvent = z.discriminatedUnion('event', [
 		dep_type: z.enum(['prod', 'peer', 'dev']),
 		// true when the update creates an auto-changeset (a publishable dependent republishes);
 		// false for dev-dep updates and update-only leaves (private dependents never publish).
-		creates_changeset: z.boolean(),
+		creates_changeset: z.boolean()
 	}),
 	z.strictObject({
 		event: z.literal('deploy_started'),
-		name: z.string(),
+		name: z.string()
 	}),
 	z.strictObject({
 		event: z.literal('deploy_completed'),
-		name: z.string(),
+		name: z.string()
 	}),
 	z.strictObject({
 		event: z.literal('deploy_failed'),
 		name: z.string(),
-		error: z.string(),
+		error: z.string()
 	}),
 	z.strictObject({
 		event: z.literal('run_finished'),
-		summary: PublishingRunSummary,
-	}),
+		summary: PublishingRunSummary
+	})
 ]);
 export type PublishingEvent = z.infer<typeof PublishingEvent>;
 
@@ -123,7 +125,7 @@ export type PublishingEvent = z.infer<typeof PublishingEvent>;
  */
 export const summarize_events = (
 	events: Array<PublishingEvent>,
-	duration: number,
+	duration: number
 ): PublishingRunSummary => {
 	let total = 0;
 	let published = 0;
@@ -147,5 +149,5 @@ export const summarize_events = (
 				break;
 		}
 	}
-	return {total, published, failed, skipped, duration};
+	return { total, published, failed, skipped, duration };
 };

package/src/lib/publishing_event_handler.ts

@@ -9,7 +9,7 @@
  * @module
  */
 
-import type {PublishingEvent} from './publishing_event.js';
+import type { PublishingEvent } from './publishing_event.ts';
 
 /** A sink for publishing events. */
 export interface PublishingEventHandler {
@@ -23,7 +23,7 @@ export interface CapturingEventHandler extends PublishingEventHandler {
 
 /** Drops every event. The default when no handler is supplied. */
 export const null_handler = (): PublishingEventHandler => ({
-	emit: () => {},
+	emit: () => {}
 });
 
 /** Collects events in memory. Used to build the run report and in tests. */
@@ -33,7 +33,7 @@ export const capture_handler = (): CapturingEventHandler => {
 		events,
 		emit: (event) => {
 			events.push(event);
-		},
+		}
 	};
 };
 
@@ -48,7 +48,7 @@ export const stdout_handler = (): PublishingEventHandler => ({
 		} catch {
 			// best-effort: a logging sink must never fail a run
 		}
-	},
+	}
 });
 
 /** Fans an event out to every handler in order. */
@@ -57,7 +57,7 @@ export const multi_handler = (handlers: Array<PublishingEventHandler>): Publishi
 		for (const handler of handlers) {
 			handler.emit(event);
 		}
-	},
+	}
 });
 
 /**
@@ -68,11 +68,11 @@ export const multi_handler = (handlers: Array<PublishingEventHandler>): Publishi
  */
 export const masking_handler = (
 	inner: PublishingEventHandler,
-	mask: (event: PublishingEvent) => PublishingEvent = mask_secrets,
+	mask: (event: PublishingEvent) => PublishingEvent = mask_secrets
 ): PublishingEventHandler => ({
 	emit: (event) => {
 		inner.emit(mask(event));
-	},
+	}
 });
 
 // Minimal redaction rules: npm auth tokens (bare or registry-scoped), `SECRET_*`
@@ -81,7 +81,7 @@ export const masking_handler = (
 const SECRET_RULES: Array<readonly [RegExp, string]> = [
 	[/((?:\/\/[^\s:]+:)?_authToken\s*=\s*)\S+/gi, '$1[redacted]'],
 	[/(SECRET_[A-Z0-9_]+\s*[=:]\s*)\S+/g, '$1[redacted]'],
-	[/(npm_[A-Za-z0-9]{4})[A-Za-z0-9]{12,}/g, '$1[redacted]'],
+	[/(npm_[A-Za-z0-9]{4})[A-Za-z0-9]{12,}/g, '$1[redacted]']
 ];
 
 /** Redacts known secret shapes from a string. */

package/src/lib/publishing_plan.ts

@@ -1,25 +1,25 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import {styleText as st} from 'node:util';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { styleText as st } from 'node:util';
 
-import type {LocalRepo} from './local_repo.js';
-import {validate_dependency_graph} from './graph_validation.js';
+import { repo_is_npm, type LocalRepo } from './local_repo.ts';
+import { validate_dependency_graph } from './graph_validation.ts';
 import {
 	type BumpType,
 	is_breaking_change,
 	compare_bump_types,
-	calculate_next_version,
-} from './version_utils.js';
-import type {ChangesetOperations} from './operations.js';
-import {default_changeset_operations} from './operations_defaults.js';
-import {GITOPS_MAX_ITERATIONS_DEFAULT} from './gitops_constants.js';
-import type {DependencyGraph} from './dependency_graph.ts';
+	calculate_next_version
+} from './version_utils.ts';
+import type { ChangesetOperations } from './operations.ts';
+import { default_changeset_operations } from './operations_defaults.ts';
+import { GITOPS_MAX_ITERATIONS_DEFAULT } from './gitops_constants.ts';
+import type { DependencyGraph } from './dependency_graph.ts';
 import {
 	calculate_dependency_updates,
-	get_required_bump_for_dependencies,
-} from './publishing_plan_helpers.js';
+	get_required_bump_for_dependencies
+} from './publishing_plan_helpers.ts';
 
 // Re-export logging functions
-export {log_publishing_plan, type LogPlanOptions} from './publishing_plan_logging.js';
+export { log_publishing_plan, type LogPlanOptions } from './publishing_plan_logging.ts';
 
 export interface VersionChange {
 	package_name: string;
@@ -45,7 +45,7 @@ export interface DependencyUpdate {
 // Verbose data types for diagnostic output
 export interface VerboseChangesetDetail {
 	package_name: string;
-	files: Array<{filename: string; bump_type: BumpType; summary: string}>;
+	files: Array<{ filename: string; bump_type: BumpType; summary: string }>;
 }
 
 export interface VerboseIterationPackage {
@@ -67,14 +67,14 @@ export interface VerboseIteration {
 
 export interface VerbosePropagationChain {
 	source: string;
-	chain: Array<{pkg: string; dep_type: 'prod' | 'peer'; action: string}>;
+	chain: Array<{ pkg: string; dep_type: 'prod' | 'peer'; action: string }>;
 }
 
 export interface VerboseGraphSummary {
 	package_count: number;
 	internal_dep_count: number;
-	prod_peer_edges: Array<{from: string; to: string; type: 'prod' | 'peer'}>;
-	dev_edges: Array<{from: string; to: string}>;
+	prod_peer_edges: Array<{ from: string; to: string; type: 'prod' | 'peer' }>;
+	dev_edges: Array<{ from: string; to: string }>;
 	prod_cycle_count: number;
 	dev_cycle_count: number;
 }
@@ -110,16 +110,28 @@ export interface GeneratePlanOptions {
  * Uses fixed-point iteration to resolve transitive cascades.
  */
 export const generate_publishing_plan = async (
-	repos: Array<LocalRepo>,
-	options: GeneratePlanOptions = {},
+	all_repos: Array<LocalRepo>,
+	options: GeneratePlanOptions = {}
 ): Promise<PublishingPlan> => {
-	const {log, ops = default_changeset_operations, verbose} = options;
+	const { log, ops = default_changeset_operations, verbose } = options;
 	log?.info(st('cyan', 'Generating publishing plan...'));
 
 	const warnings: Array<string> = [];
 	const info: Array<string> = []; // Informational status (not warnings)
 	const errors: Array<string> = [];
 
+	// Publishing concerns only npm packages. Non-npm repos (e.g. Rust cargo repos) are
+	// loaded for the dashboard but have no npm identity in the changeset cascade — drop them
+	// before building the graph so they never appear in the plan or publishing order.
+	const non_npm_repos = all_repos.filter((r) => !repo_is_npm(r));
+	if (non_npm_repos.length > 0) {
+		info.push(
+			`Excluded ${non_npm_repos.length} non-npm repo(s) from publishing: ` +
+				non_npm_repos.map((r) => r.library.name).join(', ')
+		);
+	}
+	const repos = all_repos.filter(repo_is_npm);
+
 	// Verbose data collection
 	const verbose_changeset_details: Array<VerboseChangesetDetail> = [];
 	const verbose_iterations: Array<VerboseIteration> = [];
@@ -134,7 +146,7 @@ export const generate_publishing_plan = async (
 		const validation = validate_dependency_graph(repos, {
 			throw_on_prod_cycles: false, // Collect errors instead of throwing
 			log_cycles: false, // We'll handle our own error collection
-			log_order: false, // Plan generation doesn't need to log order
+			log_order: false // Plan generation doesn't need to log order
 		});
 		publishing_order = validation.publishing_order;
 		production_cycles = validation.production_cycles;
@@ -154,7 +166,7 @@ export const generate_publishing_plan = async (
 			breaking_cascades: new Map(),
 			warnings,
 			info,
-			errors,
+			errors
 		};
 	}
 
@@ -168,7 +180,7 @@ export const generate_publishing_plan = async (
 	// Dev cycles are shown in gitops_analyze, not repeated here
 	if (dev_cycles.length > 0) {
 		info.push(
-			`${dev_cycles.length} dev dependency cycle(s) detected (normal, shown in gitops_analyze)`,
+			`${dev_cycles.length} dev dependency cycle(s) detected (normal, shown in gitops_analyze)`
 		);
 	}
 
@@ -186,7 +198,7 @@ export const generate_publishing_plan = async (
 		// the topological order. Flag a private package that carries a changeset, since that
 		// changeset can't be published.
 		if (repo.package_json.private) {
-			const private_has_changesets = await ops.has_changesets({repo});
+			const private_has_changesets = await ops.has_changesets({ repo });
 			if (private_has_changesets.ok && private_has_changesets.value) {
 				warnings.push(`${pkg_name} is private — its changeset(s) will not be published`);
 			}
@@ -194,7 +206,7 @@ export const generate_publishing_plan = async (
 		}
 
 		// Check for changesets
-		const has_result = await ops.has_changesets({repo});
+		const has_result = await ops.has_changesets({ repo });
 
 		if (!has_result.ok) {
 			errors.push(`Failed to check changesets for ${pkg_name}: ${has_result.message}`);
@@ -203,7 +215,7 @@ export const generate_publishing_plan = async (
 
 		if (has_result.value) {
 			// Predict version from changesets
-			const prediction = await ops.predict_next_version({repo, log});
+			const prediction = await ops.predict_next_version({ repo, log });
 
 			if (!prediction) {
 				// No changesets found - this shouldn't happen since has_changesets returned true
@@ -217,7 +229,7 @@ export const generate_publishing_plan = async (
 
 			// Capture changeset details for verbose output
 			if (verbose) {
-				const changesets_result = await ops.read_changesets({repo, log});
+				const changesets_result = await ops.read_changesets({ repo, log });
 				if (changesets_result.ok) {
 					const files = changesets_result.value
 						.filter((cs) => cs.packages.some((p) => p.name === pkg_name))
@@ -226,11 +238,11 @@ export const generate_publishing_plan = async (
 							return {
 								filename: cs.filename,
 								bump_type: pkg_entry?.bump_type || prediction.bump_type,
-								summary: cs.summary,
+								summary: cs.summary
 							};
 						});
 					if (files.length > 0) {
-						verbose_changeset_details.push({package_name: pkg_name, files});
+						verbose_changeset_details.push({ package_name: pkg_name, files });
 					}
 				}
 			}
@@ -251,7 +263,7 @@ export const generate_publishing_plan = async (
 					to: prediction.version,
 					bump_type: prediction.bump_type,
 					breaking: is_breaking,
-					has_changesets: true,
+					has_changesets: true
 				});
 			}
 		}
@@ -272,10 +284,10 @@ export const generate_publishing_plan = async (
 
 		// Recalculate dependency updates based on current predicted versions
 		// (breaking_cascades not needed during iteration, only calculated at the end)
-		const {dependency_updates} = calculate_dependency_updates(
+		const { dependency_updates } = calculate_dependency_updates(
 			repos,
 			predicted_versions,
-			breaking_packages,
+			breaking_packages
 		);
 
 		// Process packages to check for bump escalation and auto-generated changesets
@@ -290,7 +302,7 @@ export const generate_publishing_plan = async (
 			const required_bump = get_required_bump_for_dependencies(
 				repo,
 				dependency_updates,
-				breaking_packages,
+				breaking_packages
 			);
 
 			// Find triggering dependency for verbose output
@@ -300,7 +312,7 @@ export const generate_publishing_plan = async (
 					(u) =>
 						u.dependent_package === pkg_name &&
 						(u.type === 'dependencies' || u.type === 'peerDependencies') &&
-						breaking_packages.has(u.updated_dependency),
+						breaking_packages.has(u.updated_dependency)
 				);
 				if (relevant_updates.length > 0) {
 					triggering_dep = `${relevant_updates[0]!.updated_dependency} BREAKING`;
@@ -325,7 +337,7 @@ export const generate_publishing_plan = async (
 						// Capture verbose data before updating
 						if (verbose) {
 							const changeset_detail = verbose_changeset_details.find(
-								(d) => d.package_name === pkg_name,
+								(d) => d.package_name === pkg_name
 							);
 							verbose_iteration_packages.push({
 								name: pkg_name,
@@ -335,7 +347,7 @@ export const generate_publishing_plan = async (
 								triggering_dep,
 								action: 'escalation',
 								version_to: new_version,
-								is_breaking: is_breaking_change(old_version, required_bump),
+								is_breaking: is_breaking_change(old_version, required_bump)
 							});
 						}
 
@@ -376,7 +388,7 @@ export const generate_publishing_plan = async (
 							triggering_dep,
 							action: 'auto_changeset',
 							version_to: new_version,
-							is_breaking,
+							is_breaking
 						});
 					}
 
@@ -391,7 +403,7 @@ export const generate_publishing_plan = async (
 						bump_type: required_bump,
 						breaking: is_breaking,
 						has_changesets: false,
-						will_generate_changeset: true,
+						will_generate_changeset: true
 					});
 
 					// Update predicted versions
@@ -405,7 +417,7 @@ export const generate_publishing_plan = async (
 			verbose_iterations.push({
 				iteration,
 				packages: verbose_iteration_packages,
-				new_changes: verbose_new_changes,
+				new_changes: verbose_new_changes
 			});
 		}
 	}
@@ -416,10 +428,10 @@ export const generate_publishing_plan = async (
 		const pending_packages: Array<string> = [];
 
 		// Recalculate one more time to see what's pending
-		const {dependency_updates: pending_updates} = calculate_dependency_updates(
+		const { dependency_updates: pending_updates } = calculate_dependency_updates(
 			repos,
 			predicted_versions,
-			breaking_packages,
+			breaking_packages
 		);
 
 		for (const repo of repos) {
@@ -428,7 +440,7 @@ export const generate_publishing_plan = async (
 			const required_bump = get_required_bump_for_dependencies(
 				repo,
 				pending_updates,
-				breaking_packages,
+				breaking_packages
 			);
 
 			// Check if this package would need processing
@@ -450,22 +462,22 @@ export const generate_publishing_plan = async (
 		warnings.push(
 			`Reached maximum iterations (${GITOPS_MAX_ITERATIONS_DEFAULT}) without full convergence - ` +
 				`${pending_count} package(s) may still need processing: ${pending_packages.join(', ')}. ` +
-				`Estimated ${estimated_iterations} more iteration(s) needed.`,
+				`Estimated ${estimated_iterations} more iteration(s) needed.`
 		);
 	}
 
 	// Final dependency updates calculation after convergence
-	const {dependency_updates, breaking_cascades} = calculate_dependency_updates(
+	const { dependency_updates, breaking_cascades } = calculate_dependency_updates(
 		repos,
 		predicted_versions,
-		breaking_packages,
+		breaking_packages
 	);
 
 	// Identify packages with no changes
 	for (const repo of repos) {
 		const has_version_change = version_changes.some((vc) => vc.package_name === repo.library.name);
 		if (!has_version_change) {
-			const has_result = await ops.has_changesets({repo});
+			const has_result = await ops.has_changesets({ repo });
 			if (has_result.ok && !has_result.value) {
 				info.push(repo.library.name);
 			}
@@ -478,11 +490,11 @@ export const generate_publishing_plan = async (
 		// Build propagation chains from breaking_cascades
 		const propagation_chains: Array<VerbosePropagationChain> = [];
 		for (const [source, affected] of breaking_cascades) {
-			const chain: Array<{pkg: string; dep_type: 'prod' | 'peer'; action: string}> = [];
+			const chain: Array<{ pkg: string; dep_type: 'prod' | 'peer'; action: string }> = [];
 			for (const pkg of affected) {
 				// Determine dep type and action
 				const update = dependency_updates.find(
-					(u) => u.dependent_package === pkg && u.updated_dependency === source,
+					(u) => u.dependent_package === pkg && u.updated_dependency === source
 				);
 				const dep_type: 'prod' | 'peer' = update?.type === 'peerDependencies' ? 'peer' : 'prod';
 				const version_change = version_changes.find((vc) => vc.package_name === pkg);
@@ -492,16 +504,16 @@ export const generate_publishing_plan = async (
 				} else if (version_change?.needs_bump_escalation) {
 					action = 'bump escalation';
 				}
-				chain.push({pkg, dep_type, action});
+				chain.push({ pkg, dep_type, action });
 			}
 			if (chain.length > 0) {
-				propagation_chains.push({source, chain});
+				propagation_chains.push({ source, chain });
 			}
 		}
 
 		// Build graph summary
-		const prod_peer_edges: Array<{from: string; to: string; type: 'prod' | 'peer'}> = [];
-		const dev_edges: Array<{from: string; to: string}> = [];
+		const prod_peer_edges: Array<{ from: string; to: string; type: 'prod' | 'peer' }> = [];
+		const dev_edges: Array<{ from: string; to: string }> = [];
 		let internal_dep_count = 0;
 
 		for (const [pkg_name, node] of graph.nodes) {
@@ -510,12 +522,12 @@ export const generate_publishing_plan = async (
 				if (graph.nodes.has(dep_name)) {
 					internal_dep_count++;
 					if (spec.type === 'dev') {
-						dev_edges.push({from: pkg_name, to: dep_name});
+						dev_edges.push({ from: pkg_name, to: dep_name });
 					} else {
 						prod_peer_edges.push({
 							from: pkg_name,
 							to: dep_name,
-							type: spec.type === 'peer' ? 'peer' : 'prod',
+							type: spec.type === 'peer' ? 'peer' : 'prod'
 						});
 					}
 				}
@@ -532,9 +544,9 @@ export const generate_publishing_plan = async (
 				prod_peer_edges,
 				dev_edges,
 				prod_cycle_count: production_cycles.length,
-				dev_cycle_count: dev_cycles.length,
+				dev_cycle_count: dev_cycles.length
 			},
-			total_iterations: iteration,
+			total_iterations: iteration
 		};
 	}
 
@@ -546,6 +558,6 @@ export const generate_publishing_plan = async (
 		warnings,
 		info,
 		errors,
-		verbose_data,
+		verbose_data
 	};
 };