@fuzdev/fuz_gitops 0.76.0 → 0.78.0

package/src/lib/gitops_config.ts

@@ -11,12 +11,12 @@
  * @module
  */
 
-import type {Url} from '@fuzdev/fuz_util/url.js';
+import type {Url} from '@fuzdev/fuz_util/url.ts';
 import {existsSync} from 'node:fs';
-import {strip_end} from '@fuzdev/fuz_util/string.js';
-import type {GitBranch} from '@fuzdev/fuz_util/git.js';
+import {strip_end} from '@fuzdev/fuz_util/string.ts';
+import type {GitBranch} from '@fuzdev/fuz_util/git.ts';
 
-import {DEFAULT_REPOS_DIR} from './paths.js';
+import {DEFAULT_REPOS_DIR} from './paths.ts';
 
 export interface GitopsConfig {
 	repos: Array<GitopsRepoConfig>;
@@ -32,6 +32,13 @@ export interface RawGitopsConfig {
 	repos_dir?: string;
 }
 
+/**
+ * Visibility of a repo on its host, mirroring the host's own model
+ * (e.g. GitHub's `visibility` field). Named to avoid confusion with the npm
+ * `package.json` `private` flag, which is a separate publishing concern.
+ */
+export type GitopsRepoVisibility = 'public' | 'private';
+
 export interface GitopsRepoConfig {
 	/**
 	 * The HTTPS URL to the repo. Does not include a `.git` suffix.
@@ -60,12 +67,34 @@ export interface GitopsRepoConfig {
 	 * The branch name to use when fetching the repo. Defaults to `main`.
 	 */
 	branch: GitBranch;
+
+	/**
+	 * Visibility of the repo on its host. Defaults to `'public'`.
+	 */
+	visibility: GitopsRepoVisibility;
+
+	/**
+	 * Whether the repo runs CI. Defaults to `true` for public repos and `false`
+	 * for private repos, unless set explicitly.
+	 */
+	ci: boolean;
+
+	/**
+	 * Whether the repo is archived (read-only) on its host. Defaults to `false`.
+	 */
+	archived: boolean;
 }
 
 export interface RawGitopsRepoConfig {
 	repo_url: Url;
 	repo_dir?: string | null;
 	branch?: GitBranch;
+	/** Visibility of the repo on its host. Defaults to `'public'`. */
+	visibility?: GitopsRepoVisibility;
+	/** Whether the repo runs CI. Defaults to `true` for public, `false` for private. */
+	ci?: boolean;
+	/** Whether the repo is archived (read-only) on its host. Defaults to `false`. */
+	archived?: boolean;
 }
 
 export const create_empty_gitops_config = (): GitopsConfig => ({
@@ -91,12 +120,23 @@ export const normalize_gitops_config = (raw_config: RawGitopsConfig): GitopsConf
 
 const parse_fuz_repo_config = (r: Url | RawGitopsRepoConfig): GitopsRepoConfig => {
 	if (typeof r === 'string') {
-		return {repo_url: r, repo_dir: null, branch: 'main' as GitBranch}; // TODO @zts use flavored for GitBranch
+		return {
+			repo_url: r,
+			repo_dir: null,
+			branch: 'main' as GitBranch, // TODO @zts use flavored for GitBranch
+			visibility: 'public',
+			ci: true,
+			archived: false,
+		};
 	}
+	const visibility = r.visibility ?? 'public';
 	return {
 		repo_url: strip_end(r.repo_url, '.git'),
 		repo_dir: r.repo_dir ?? null,
 		branch: r.branch ?? ('main' as GitBranch), // TODO @zts use flavored for GitBranch
+		visibility,
+		ci: r.ci ?? visibility === 'public',
+		archived: r.archived ?? false,
 	};
 };
 

package/src/lib/gitops_plan.task.ts

@@ -2,15 +2,15 @@ import type {Task} from '@fuzdev/gro';
 import {z} from 'zod';
 import {styleText as st} from 'node:util';
 
-import {get_gitops_ready} from './gitops_task_helpers.js';
+import {get_gitops_ready} from './gitops_task_helpers.ts';
 import {
 	generate_publishing_plan,
 	log_publishing_plan,
 	type PublishingPlan,
 	type LogPlanOptions,
-} from './publishing_plan.js';
-import {format_and_output, type OutputFormatters} from './output_helpers.js';
-import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.js';
+} from './publishing_plan.ts';
+import {format_and_output, type OutputFormatters} from './output_helpers.ts';
+import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.ts';
 
 /** @nodocs */
 export const Args = z.strictObject({

package/src/lib/gitops_publish.task.ts

@@ -1,21 +1,21 @@
 import type {Task} from '@fuzdev/gro';
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
 import {z} from 'zod';
 import {createInterface} from 'node:readline/promises';
 import {styleText as st} from 'node:util';
 
-import {get_gitops_ready} from './gitops_task_helpers.js';
+import {get_gitops_ready} from './gitops_task_helpers.ts';
 import {
 	execute_publishing_plan,
 	type PublishingOptions,
 	type PublishingResult,
-} from './multi_repo_publisher.js';
-import {stdout_handler} from './publishing_event_handler.js';
-import {generate_publishing_plan, log_publishing_plan} from './publishing_plan.js';
-import {derive_publish_steps, format_publish_steps, type PublishStep} from './publish_steps.js';
-import {decide_publish_gate, publish_run_failed} from './publish_gate.js';
-import {format_and_output, type OutputFormatters} from './output_helpers.js';
-import {GITOPS_CONFIG_PATH_DEFAULT, GITOPS_NPM_WAIT_TIMEOUT_DEFAULT} from './gitops_constants.js';
+} from './multi_repo_publisher.ts';
+import {stdout_handler} from './publishing_event_handler.ts';
+import {generate_publishing_plan, log_publishing_plan} from './publishing_plan.ts';
+import {derive_publish_steps, format_publish_steps, type PublishStep} from './publish_steps.ts';
+import {decide_publish_gate, publish_run_failed} from './publish_gate.ts';
+import {format_and_output, type OutputFormatters} from './output_helpers.ts';
+import {GITOPS_CONFIG_PATH_DEFAULT, GITOPS_NPM_WAIT_TIMEOUT_DEFAULT} from './gitops_constants.ts';
 
 /** @nodocs */
 export const Args = z.strictObject({

package/src/lib/gitops_run.task.ts

@@ -1,13 +1,13 @@
 import {TaskError, type Task} from '@fuzdev/gro';
 import {z} from 'zod';
-import {map_concurrent_settled} from '@fuzdev/fuz_util/async.js';
-import {spawn_out} from '@fuzdev/fuz_util/process.js';
+import {map_concurrent_settled} from '@fuzdev/fuz_util/async.ts';
+import {spawn_out} from '@fuzdev/fuz_util/process.ts';
 import {writeFile} from 'node:fs/promises';
 import {styleText as st} from 'node:util';
 import {resolve} from 'node:path';
 
-import {get_repo_paths} from './repo_ops.js';
-import {GITOPS_CONCURRENCY_DEFAULT, GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.js';
+import {get_repo_paths} from './repo_ops.ts';
+import {GITOPS_CONCURRENCY_DEFAULT, GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.ts';
 
 export const Args = z.strictObject({
 	// Positional rest args (gro convention) so `gro gitops_run "npm test"` works;

package/src/lib/gitops_sync.task.ts

@@ -1,18 +1,18 @@
 import {TaskError, type Task} from '@fuzdev/gro';
 import {z} from 'zod';
 import {readFile, writeFile} from 'node:fs/promises';
-import {format_file} from '@fuzdev/gro/format_file.js';
+import {format_file} from '@fuzdev/gro/format_file.ts';
 import {basename, resolve} from 'node:path';
-import {print_path} from '@fuzdev/gro/paths.js';
-import {load_from_env} from '@fuzdev/gro/env.js';
-import {package_json_load} from '@fuzdev/gro/package_json.js';
+import {print_path} from '@fuzdev/gro/paths.ts';
+import {load_from_env} from '@fuzdev/gro/env.ts';
+import {package_json_load} from '@fuzdev/gro/package_json.ts';
 import {existsSync} from 'node:fs';
 import {compactReplacer} from 'svelte-docinfo';
 
-import {fetch_repo_data} from './fetch_repo_data.js';
-import {create_fs_fetch_value_cache} from './fs_fetch_value_cache.js';
-import {get_gitops_ready} from './gitops_task_helpers.js';
-import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.js';
+import {fetch_repo_data} from './fetch_repo_data.ts';
+import {create_fs_fetch_value_cache} from './fs_fetch_value_cache.ts';
+import {get_gitops_ready} from './gitops_task_helpers.ts';
+import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.ts';
 
 // TODO add flag to ignore or invalidate cache -- no-cache? clean?
 

package/src/lib/gitops_task_helpers.ts

@@ -19,14 +19,14 @@
 import {TaskError} from '@fuzdev/gro';
 import {styleText as st} from 'node:util';
 import {resolve, dirname} from 'node:path';
-import {print_path} from '@fuzdev/gro/paths.js';
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import {print_path} from '@fuzdev/gro/paths.ts';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
 
-import {load_gitops_config, type GitopsConfig} from './gitops_config.js';
-import {local_repos_load, local_repos_ensure, type LocalRepo} from './local_repo.js';
-import {resolve_gitops_config} from './resolved_gitops_config.js';
-import {DEFAULT_REPOS_DIR} from './paths.js';
-import type {GitOperations, NpmOperations} from './operations.js';
+import {load_gitops_config, type GitopsConfig} from './gitops_config.ts';
+import {local_repos_load, local_repos_ensure, type LocalRepo} from './local_repo.ts';
+import {resolve_gitops_config} from './resolved_gitops_config.ts';
+import {DEFAULT_REPOS_DIR} from './paths.ts';
+import type {GitOperations, NpmOperations} from './operations.ts';
 
 export interface GetGitopsReadyOptions {
 	config: string;

package/src/lib/gitops_validate.task.ts

@@ -2,16 +2,17 @@ import type {Task} from '@fuzdev/gro';
 import {z} from 'zod';
 import {styleText as st} from 'node:util';
 
-import {get_gitops_ready} from './gitops_task_helpers.js';
-import {analyze_repos, type DependencyAnalysis} from './graph_validation.js';
+import {get_gitops_ready} from './gitops_task_helpers.ts';
+import {analyze_repos, type DependencyAnalysis} from './graph_validation.ts';
 import {
 	generate_publishing_plan,
 	log_publishing_plan,
 	type PublishingPlan,
-} from './publishing_plan.js';
-import {execute_publishing_plan, type PublishingOptions} from './multi_repo_publisher.js';
-import {log_dependency_analysis} from './log_helpers.js';
-import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.js';
+} from './publishing_plan.ts';
+import {execute_publishing_plan, type PublishingOptions} from './multi_repo_publisher.ts';
+import {log_dependency_analysis} from './log_helpers.ts';
+import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.ts';
+import {reconcile_ci, repo_has_workflows} from './ci_reconcile.ts';
 
 /** @nodocs */
 export const Args = z.strictObject({
@@ -86,7 +87,7 @@ export const task: Task<Args> = {
 
 			results.push({
 				command: 'gitops_analyze',
-				success: true,
+				success: errors === 0,
 				warnings,
 				errors,
 				duration: analyze_duration,
@@ -129,7 +130,7 @@ export const task: Task<Args> = {
 
 			results.push({
 				command: 'gitops_plan',
-				success: true,
+				success: errors === 0,
 				warnings,
 				errors,
 				duration: plan_duration,
@@ -202,6 +203,56 @@ export const task: Task<Args> = {
 			log.error(st('red', `  ✗ gitops_publish (dry run) failed: ${error}`));
 		}
 
+		// 4. Reconcile each repo's declared `ci` against actual workflow files on disk.
+		log.info(st('yellow', 'Running ci_reconcile...'));
+		const ci_start = Date.now();
+		try {
+			const ci_drift = reconcile_ci(
+				local_repos.map((r) => ({
+					repo_url: r.repo_config.repo_url,
+					ci: r.repo_config.ci,
+					has_workflows: repo_has_workflows(r.repo_dir),
+					// TODO: `local_repos` only ever holds checked-out repos — a missing repo
+					// throws in `local_repos_ensure` before we reach here — so `checkable` is
+					// always `true` today. The gate exists for a future caller that loads a
+					// partial set; until then the skip path is inert and untested.
+					checkable: true,
+					archived: r.repo_config.archived,
+				})),
+			);
+			const ci_duration = Date.now() - ci_start;
+			const drift_details = ci_drift.map((d) =>
+				d.kind === 'missing_ci'
+					? `${d.repo_url}: ci=true but no workflow files`
+					: `${d.repo_url}: ci=false but workflow files present`,
+			);
+			results.push({
+				command: 'ci_reconcile',
+				success: ci_drift.length === 0,
+				warnings: 0,
+				errors: ci_drift.length,
+				duration: ci_duration,
+			});
+			if (ci_drift.length === 0) {
+				log.info(st('green', `  ✓ ci_reconcile completed in ${ci_duration}ms`));
+			} else {
+				log.error(st('red', `  ❌ ci_reconcile found ${ci_drift.length} drift(s)`));
+				for (const detail of drift_details) {
+					log.error(st('red', `    - ${detail}`));
+				}
+			}
+		} catch (error) {
+			const ci_duration = Date.now() - ci_start;
+			results.push({
+				command: 'ci_reconcile',
+				success: false,
+				warnings: 0,
+				errors: 1,
+				duration: ci_duration,
+			});
+			log.error(st('red', `  ✗ ci_reconcile failed: ${error}`));
+		}
+
 		// Summary
 		const total_duration = Date.now() - start_time;
 		const all_success = results.every((r) => r.success);
@@ -247,10 +298,11 @@ export const task: Task<Args> = {
 					st('yellow', `⚠️  Note: ${total_warnings} warning(s) found - review output above.`),
 				);
 			}
-		} else if (all_success && total_errors > 0) {
-			log.warn(st('yellow', '⚠️  Validation completed but found errors - review output above.'));
 		} else {
-			log.error(st('red', '❌ Validation failed - one or more commands did not complete.'));
+			// Hard-fail on any error or failed command. These run manually (and
+			// increasingly via agents), so a clear problem should stop the pipeline
+			// rather than scroll past in the summary. Warnings stay non-fatal.
+			log.error(st('red', '❌ Validation failed - review the errors above.'));
 			throw new Error('Validation failed');
 		}
 	},

package/src/lib/graph_validation.ts

@@ -13,12 +13,12 @@
  * @module
  */
 
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
 import {TaskError} from '@fuzdev/gro';
 import {styleText as st} from 'node:util';
 
-import {DependencyGraph, DependencyGraphBuilder} from './dependency_graph.js';
-import type {LocalRepo} from './local_repo.js';
+import {DependencyGraph, DependencyGraphBuilder} from './dependency_graph.ts';
+import {repo_is_npm, type LocalRepo} from './local_repo.ts';
 
 export interface GraphValidationResult {
 	graph: DependencyGraph;
@@ -127,7 +127,8 @@ export interface RepoAnalysis {
  * (no `log`) to avoid emitting a redundant "Analyzing dependencies" line.
  */
 export const analyze_repos = (repos: Array<LocalRepo>): RepoAnalysis => {
-	const {graph, publishing_order: order} = validate_dependency_graph(repos, {
+	// Only npm packages form the dependency graph; non-npm repos (e.g. cargo) are excluded.
+	const {graph, publishing_order: order} = validate_dependency_graph(repos.filter(repo_is_npm), {
 		throw_on_prod_cycles: false, // report, don't throw
 		log_cycles: false, // callers format their own cycle output
 		log_order: false,

package/src/lib/local_repo.ts

@@ -1,26 +1,36 @@
-import {strip_end} from '@fuzdev/fuz_util/string.js';
-import type {LibraryJson} from '@fuzdev/fuz_util/library_json.js';
-import type {PackageJson} from '@fuzdev/fuz_util/package_json.js';
-import {Library} from '@fuzdev/fuz_ui/library.svelte.js';
+import {strip_end} from '@fuzdev/fuz_util/string.ts';
+import {to_error_message} from '@fuzdev/fuz_util/error.ts';
+import {library_json_from_modules, type LibraryJson} from '@fuzdev/fuz_util/library_json.ts';
+import type {PackageJson} from '@fuzdev/fuz_util/package_json.ts';
+import {Library} from '@fuzdev/fuz_ui/library.svelte.ts';
 import {existsSync} from 'node:fs';
 import {join} from 'node:path';
 import {TaskError} from '@fuzdev/gro';
-import {library_load_from_repo} from '@fuzdev/gro/library_load.js';
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import {spawn_out} from '@fuzdev/fuz_util/process.js';
-import {map_concurrent_settled} from '@fuzdev/fuz_util/async.js';
-import type {GitOperations, NpmOperations} from './operations.js';
-import {default_git_operations, default_npm_operations} from './operations_defaults.js';
-
-import type {GitopsConfig, GitopsRepoConfig} from './gitops_config.js';
-import type {ResolvedGitopsConfig} from './resolved_gitops_config.js';
-import {GITOPS_CONCURRENCY_DEFAULT} from './gitops_constants.js';
+import {library_load_from_repo} from '@fuzdev/gro/library_load.ts';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
+import {spawn_out} from '@fuzdev/fuz_util/process.ts';
+import {map_concurrent_settled} from '@fuzdev/fuz_util/async.ts';
+import type {GitOperations, NpmOperations} from './operations.ts';
+import {default_git_operations, default_npm_operations} from './operations_defaults.ts';
+
+import type {GitopsConfig, GitopsRepoConfig} from './gitops_config.ts';
+import type {ResolvedGitopsConfig} from './resolved_gitops_config.ts';
+import {GITOPS_CONCURRENCY_DEFAULT} from './gitops_constants.ts';
+import {cargo_toml_load} from './cargo_toml.ts';
 
 /**
  * Fully loaded local repo with `Library` and extracted dependency data.
  * Does not extend `LocalRepoPath` - `Library` is source of truth for name/repo_url/etc.
  */
 export interface LocalRepo {
+	/**
+	 * Which packaging ecosystem the repo belongs to. `npm` repos (with a
+	 * `package.json`) take part in the changeset publishing cascade; `cargo` repos
+	 * (a Rust `Cargo.toml`, no `package.json`) are dashboard-only — fetched and
+	 * rendered like any repo but excluded from publishing/analysis. See
+	 * `repo_is_npm`.
+	 */
+	kind: 'npm' | 'cargo';
 	library: Library;
 	/** The repo's full `package.json` (with `dependencies`/`devDependencies`). */
 	package_json: PackageJson;
@@ -210,13 +220,21 @@ export const local_repo_load = async ({
 		}
 	}
 
+	// A repo with no `package.json` but a Rust `Cargo.toml` isn't an npm package and can't be
+	// analyzed as a library. Load it as a dashboard-only `cargo` repo (CI, PRs, identity) that
+	// publishing/analysis skips. Anything else falls through to the npm loader below, whose
+	// error covers a genuinely missing or unreadable manifest.
+	if (!existsSync(join(repo_dir, 'package.json')) && existsSync(join(repo_dir, 'Cargo.toml'))) {
+		return local_repo_load_cargo({local_repo_path});
+	}
+
 	// Load library metadata via svelte-docinfo analysis (cached under `.gro/library.json`).
 	let library_json: LibraryJson;
 	let package_json: PackageJson;
 	try {
 		({library_json, package_json} = await library_load_from_repo(repo_dir, {log: _log}));
 	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
+		const message = to_error_message(err);
 		_log?.warn(
 			`Failed to load library metadata for repo "${repo_name}" in ${repo_dir}: ${message}`,
 		);
@@ -227,6 +245,7 @@ export const local_repo_load = async ({
 	const library = new Library(library_json);
 
 	const local_repo: LocalRepo = {
+		kind: 'npm',
 		library,
 		package_json,
 		repo_dir,
@@ -248,6 +267,53 @@ export const local_repo_load = async ({
 	return local_repo;
 };
 
+/**
+ * Whether a repo is an npm package and so participates in publishing and
+ * dependency analysis. Non-npm repos (e.g. Rust `cargo` repos) are still synced
+ * and rendered on the dashboard, but excluded from the changeset cascade.
+ */
+export const repo_is_npm = (repo: LocalRepo): boolean => repo.kind === 'npm';
+
+/**
+ * Loads a non-npm Rust repo as a dashboard-only `LocalRepo`. It has no
+ * `package.json`, so there's no `svelte-docinfo` analysis and no npm dependency
+ * graph — a lightweight `Library` is synthesized from the repo's `Cargo.toml`
+ * (best-effort name/version/description) and its configured repo URL, which is
+ * what the dashboard renders (CI status, PRs, identity). Marked `private` so it
+ * never reads as an npm publish target, and tagged `cargo` so the publishing and
+ * analysis paths skip it (see `repo_is_npm`).
+ */
+const local_repo_load_cargo = async ({
+	local_repo_path,
+}: {
+	local_repo_path: LocalRepoPath;
+}): Promise<LocalRepo> => {
+	const {repo_config, repo_dir, repo_name, repo_url, repo_git_ssh_url} = local_repo_path;
+
+	const cargo = await cargo_toml_load(repo_dir);
+
+	// A Cargo workspace root has no `name`, so fall back to the repo name parsed from
+	// the URL; the config's `repo_url` is the authoritative `repository`.
+	const package_json: PackageJson = {
+		name: cargo?.name ?? repo_name,
+		version: cargo?.version ?? '0.0.0',
+		repository: cargo?.repository ?? repo_url,
+		private: true,
+		...(cargo?.description ? {description: cargo.description} : null),
+	};
+
+	const library = new Library(library_json_from_modules(package_json, []));
+
+	return {
+		kind: 'cargo',
+		library,
+		package_json,
+		repo_dir,
+		repo_git_ssh_url,
+		repo_config,
+	};
+};
+
 export const local_repos_ensure = async ({
 	resolved_config,
 	repos_dir,

package/src/lib/log_helpers.ts

@@ -1,7 +1,7 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
 import {styleText as st} from 'node:util';
 
-import type {DependencyGraphBuilder} from './dependency_graph.js';
+import type {DependencyGraphBuilder} from './dependency_graph.ts';
 
 /**
  * Formats wildcard dependencies as styled strings.

package/src/lib/multi_repo_publisher.ts

@@ -1,30 +1,30 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
 import {TaskError} from '@fuzdev/gro';
 import {join} from 'node:path';
 import {styleText as st} from 'node:util';
 
-import type {LocalRepo} from './local_repo.js';
-import {update_package_json, type VersionStrategy} from './dependency_updater.js';
+import {repo_is_npm, type LocalRepo} from './local_repo.ts';
+import {update_package_json, type VersionStrategy} from './dependency_updater.ts';
 import {
 	generate_publishing_plan,
 	type VersionChange,
 	type DependencyUpdate,
 	type PublishingPlan,
-} from './publishing_plan.js';
-import type {PreflightOptions} from './preflight_checks.js';
-import type {GitopsOperations} from './operations.js';
-import {default_gitops_operations} from './operations_defaults.js';
-import {GITOPS_NPM_WAIT_TIMEOUT_DEFAULT} from './gitops_constants.js';
+} from './publishing_plan.ts';
+import type {PreflightOptions} from './preflight_checks.ts';
+import type {GitopsOperations} from './operations.ts';
+import {default_gitops_operations} from './operations_defaults.ts';
+import {GITOPS_NPM_WAIT_TIMEOUT_DEFAULT} from './gitops_constants.ts';
 import {
 	type PublishingEvent,
 	type PublishingRunSummary,
 	summarize_events,
-} from './publishing_event.js';
+} from './publishing_event.ts';
 import {
 	type PublishingEventHandler,
 	capture_handler,
 	multi_handler,
-} from './publishing_event_handler.js';
+} from './publishing_event_handler.ts';
 
 export interface PublishingOptions {
 	wetrun: boolean;
@@ -83,13 +83,17 @@ export const publish_repos = async (
  * `ok: false`. This is the single error gate — `--no-plan` can't bypass it.
  */
 export const execute_publishing_plan = async (
-	repos: Array<LocalRepo>,
+	all_repos: Array<LocalRepo>,
 	plan: PublishingPlan,
 	options: PublishingOptions,
 ): Promise<PublishingResult> => {
 	const start_time = Date.now();
 	const {wetrun, log, ops = default_gitops_operations} = options;
 
+	// Only npm repos publish; drop any non-npm repos (e.g. cargo) so preflight and the
+	// executor's name lookup never touch them. The plan already excludes them too.
+	const repos = all_repos.filter(repo_is_npm);
+
 	// Fail loud on an incomplete plan. Executing one with errors would silently skip the
 	// affected packages. A wetrun aborts before touching npm or git; a dry run proceeds
 	// (no side effects) but the result is not ok (see the summary below).

package/src/lib/npm_registry.ts

@@ -1,6 +1,6 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import {spawn_out} from '@fuzdev/fuz_util/process.js';
-import {wait} from '@fuzdev/fuz_util/async.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
+import {spawn_out} from '@fuzdev/fuz_util/process.ts';
+import {wait} from '@fuzdev/fuz_util/async.ts';
 import {styleText as st} from 'node:util';
 
 export interface WaitOptions {

package/src/lib/operations.ts

@@ -34,14 +34,14 @@
  * @module
  */
 
-import type {Result} from '@fuzdev/fuz_util/result.js';
-import type {FsError} from '@fuzdev/fuz_util/fs.js';
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import type {LocalRepo} from './local_repo.js';
-import type {ChangesetInfo} from './changeset_reader.js';
-import type {BumpType} from './version_utils.js';
-import type {PreflightOptions, PreflightResult} from './preflight_checks.js';
-import type {WaitOptions} from './npm_registry.js';
+import type {Result} from '@fuzdev/fuz_util/result.ts';
+import type {FsError} from '@fuzdev/fuz_util/fs.ts';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
+import type {LocalRepo} from './local_repo.ts';
+import type {ChangesetInfo} from './changeset_reader.ts';
+import type {BumpType} from './version_utils.ts';
+import type {PreflightOptions, PreflightResult} from './preflight_checks.ts';
+import type {WaitOptions} from './npm_registry.ts';
 
 /**
  * Changeset operations for reading and predicting versions from `.changeset/*.md` files.
@@ -293,7 +293,7 @@ export interface PreflightOperations {
  *
  * Errors are typed via `FsError` (`not_found | permission_denied |
  * already_exists | io_error`) so callers can branch on `kind` instead of
- * regex-matching `message`. See `@fuzdev/fuz_util/fs.js`.
+ * regex-matching `message`. See `@fuzdev/fuz_util/fs.ts`.
  */
 export interface FsOperations {
 	/**

package/src/lib/operations_defaults.ts

@@ -7,15 +7,15 @@
  * @module
  */
 
-import {spawn_out} from '@fuzdev/fuz_util/process.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.js';
-import {fs_classify_error} from '@fuzdev/fuz_util/fs.js';
-import {EMPTY_OBJECT} from '@fuzdev/fuz_util/object.js';
+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.js';
-import {wait_for_package} from './npm_registry.js';
-import {run_preflight_checks} from './preflight_checks.js';
+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,
@@ -32,7 +32,7 @@ import {
 	git_current_commit_hash_required,
 	git_check_clean_workspace_as_boolean,
 	git_has_remote,
-} from './git_operations.js';
+} from './git_operations.ts';
 import type {
 	ChangesetOperations,
 	GitOperations,
@@ -42,7 +42,7 @@ import type {
 	FsOperations,
 	BuildOperations,
 	GitopsOperations,
-} from './operations.js';
+} from './operations.ts';
 
 /** Wrap an async function that returns a value */
 const wrap_with_value = async <T>(

package/src/lib/output_helpers.ts

@@ -1,4 +1,4 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {Logger} from '@fuzdev/fuz_util/log.ts';
 import {writeFile} from 'node:fs/promises';
 
 export type OutputFormat = 'stdout' | 'json' | 'markdown';