@fuzdev/fuz_gitops 0.78.0 → 0.79.0

package/src/lib/dependency_graph.ts

@@ -1,22 +1,23 @@
 /**
  * Dependency graph data structure and algorithms for multi-repo publishing.
  *
- * Provides `DependencyGraph` class with topological sort (via `@fuzdev/fuz_util/sort.ts`)
- * and cycle detection by dependency type.
- * For validation workflow and publishing order computation, see `graph_validation.ts`.
+ * Provides the `DependencyGraph` class, built from local repos, with topological sort
+ * (via `@fuzdev/fuz_util/sort.ts`), cycle detection by dependency type, and
+ * wildcard-range analysis.
+ * For the publishing order and the analysis workflow, see `graph_validation.ts`.
  *
  * @module
  */
 
-import {EMPTY_OBJECT} from '@fuzdev/fuz_util/object.ts';
-import {topological_sort as topological_sort_generic} from '@fuzdev/fuz_util/sort.ts';
+import { EMPTY_OBJECT } from '@fuzdev/fuz_util/object.ts';
+import { topological_sort as topological_sort_generic } from '@fuzdev/fuz_util/sort.ts';
 
-import type {LocalRepo} from './local_repo.ts';
+import type { LocalRepo } from './local_repo.ts';
 
 export const DEPENDENCY_TYPE = {
 	PROD: 'prod',
 	PEER: 'peer',
-	DEV: 'dev',
+	DEV: 'dev'
 } as const;
 
 export type DependencyType = (typeof DEPENDENCY_TYPE)[keyof typeof DEPENDENCY_TYPE];
@@ -24,68 +25,68 @@ export type DependencyType = (typeof DEPENDENCY_TYPE)[keyof typeof DEPENDENCY_TY
 export interface DependencySpec {
 	type: DependencyType;
 	version: string;
-	resolved?: string;
 }
 
 export interface DependencyGraphJson {
 	nodes: Array<{
 		name: string;
 		version: string;
-		dependencies: Array<{name: string; spec: DependencySpec}>;
+		dependencies: Array<{ name: string; spec: DependencySpec }>;
 		dependents: Array<string>;
-		publishable: boolean;
 	}>;
-	edges: Array<{from: string; to: string}>;
+	edges: Array<{ from: string; to: string }>;
 }
 
 export interface DependencyNode {
 	name: string;
 	version: string;
-	repo?: LocalRepo;
 	dependencies: Map<string, DependencySpec>;
 	dependents: Set<string>;
-	publishable: boolean;
 }
 
-export class DependencyGraph {
-	nodes: Map<string, DependencyNode>;
-	edges: Map<string, Set<string>>; // pkg -> dependents
+/** Cycles and wildcard dependencies found by `DependencyGraph.analyze`. */
+export interface DependencyAnalysis {
+	production_cycles: Array<Array<string>>;
+	dev_cycles: Array<Array<string>>;
+	wildcard_deps: Array<{ pkg: string; dep: string; version: string }>;
+}
 
-	constructor() {
-		this.nodes = new Map();
-		this.edges = new Map();
-	}
+export class DependencyGraph {
+	nodes: Map<string, DependencyNode> = new Map();
+	edges: Map<string, Set<string>> = new Map(); // pkg -> dependents
 
-	public init_from_repos(repos: Array<LocalRepo>): void {
-		// First pass: create nodes
+	/**
+	 * Builds the graph from local repos.
+	 *
+	 * Two passes: first creates nodes, then builds edges (dependents).
+	 * Prioritizes prod/peer deps over dev deps when the same package appears in
+	 * multiple dependency types (the stronger constraint wins).
+	 */
+	constructor(repos: Array<LocalRepo>) {
+		// first pass: create nodes
 		for (const repo of repos) {
-			const {library, package_json} = repo;
+			const { library, package_json } = repo;
 			const node: DependencyNode = {
 				name: library.name,
 				version: package_json.version || '0.0.0',
-				repo,
 				dependencies: new Map(),
-				dependents: new Set(),
-				publishable: !package_json.private,
+				dependents: new Set()
 			};
 
-			// Extract dependencies
 			const deps = package_json.dependencies || (EMPTY_OBJECT as Record<string, string>);
 			const dev_deps = package_json.devDependencies || (EMPTY_OBJECT as Record<string, string>);
 			const peer_deps = package_json.peerDependencies || (EMPTY_OBJECT as Record<string, string>);
 
-			// Add dependencies, prioritizing prod/peer over dev
-			// (if a package appears in multiple dep types, use the stronger constraint)
 			for (const [name, version] of Object.entries(deps)) {
-				node.dependencies.set(name, {type: DEPENDENCY_TYPE.PROD, version});
+				node.dependencies.set(name, { type: DEPENDENCY_TYPE.PROD, version });
 			}
 			for (const [name, version] of Object.entries(peer_deps)) {
-				node.dependencies.set(name, {type: DEPENDENCY_TYPE.PEER, version});
+				node.dependencies.set(name, { type: DEPENDENCY_TYPE.PEER, version });
 			}
 			for (const [name, version] of Object.entries(dev_deps)) {
-				// Only add dev deps if not already present as prod/peer
+				// only add dev deps if not already present as prod/peer
 				if (!node.dependencies.has(name)) {
-					node.dependencies.set(name, {type: DEPENDENCY_TYPE.DEV, version});
+					node.dependencies.set(name, { type: DEPENDENCY_TYPE.DEV, version });
 				}
 			}
 
@@ -93,12 +94,11 @@ export class DependencyGraph {
 			this.edges.set(library.name, new Set());
 		}
 
-		// Second pass: build edges (dependents)
+		// second pass: build edges (dependents) for internal dependencies
 		for (const node of this.nodes.values()) {
 			for (const [dep_name] of node.dependencies) {
-				if (this.nodes.has(dep_name)) {
-					// Internal dependency
-					const dep_node = this.nodes.get(dep_name)!;
+				const dep_node = this.nodes.get(dep_name);
+				if (dep_node) {
 					dep_node.dependents.add(node.name);
 					this.edges.get(dep_name)!.add(node.name);
 				}
@@ -110,15 +110,6 @@ export class DependencyGraph {
 		return this.nodes.get(name);
 	}
 
-	get_dependents(name: string): Set<string> {
-		return this.edges.get(name) || new Set();
-	}
-
-	get_dependencies(name: string): Map<string, DependencySpec> {
-		const node = this.nodes.get(name);
-		return node ? node.dependencies : new Map();
-	}
-
 	/**
 	 * Computes topological sort order for dependency graph.
 	 *
@@ -138,7 +129,7 @@ export class DependencyGraph {
 					if (exclude_dev && spec.type === DEPENDENCY_TYPE.DEV) return false;
 					return this.nodes.has(dep_name);
 				})
-				.map(([dep_name]) => dep_name),
+				.map(([dep_name]) => dep_name)
 		}));
 		const result = topological_sort_generic(items, 'package');
 		if (!result.ok) {
@@ -164,7 +155,24 @@ export class DependencyGraph {
 	} {
 		const production_cycles = this.#find_cycles((spec) => spec.type !== DEPENDENCY_TYPE.DEV);
 		const dev_cycles = this.#find_cycles((spec) => spec.type === DEPENDENCY_TYPE.DEV);
-		return {production_cycles, dev_cycles};
+		return { production_cycles, dev_cycles };
+	}
+
+	/**
+	 * Reports cycles by type and wildcard (`*`) dependency ranges.
+	 * Tolerates cycles: it reports them rather than throwing.
+	 */
+	analyze(): DependencyAnalysis {
+		const { production_cycles, dev_cycles } = this.detect_cycles_by_type();
+		const wildcard_deps: DependencyAnalysis['wildcard_deps'] = [];
+		for (const node of this.nodes.values()) {
+			for (const [dep_name, spec] of node.dependencies) {
+				if (spec.version === '*') {
+					wildcard_deps.push({ pkg: node.name, dep: dep_name, version: spec.version });
+				}
+			}
+		}
+		return { production_cycles, dev_cycles, wildcard_deps };
 	}
 
 	/** DFS cycle detection following only edges that match the filter. */
@@ -217,78 +225,18 @@ export class DependencyGraph {
 			version: node.version,
 			dependencies: Array.from(node.dependencies.entries()).map(([name, spec]) => ({
 				name,
-				spec,
+				spec
 			})),
-			dependents: Array.from(node.dependents),
-			publishable: node.publishable,
+			dependents: Array.from(node.dependents)
 		}));
 
-		const edges: Array<{from: string; to: string}> = [];
+		const edges: Array<{ from: string; to: string }> = [];
 		for (const [from, tos] of this.edges) {
 			for (const to of tos) {
-				edges.push({from, to});
-			}
-		}
-
-		return {nodes, edges};
-	}
-}
-
-/**
- * Builder for creating and analyzing dependency graphs.
- */
-export class DependencyGraphBuilder {
-	/**
-	 * Constructs dependency graph from local repos.
-	 *
-	 * Two-pass algorithm: first creates nodes, then builds edges (dependents).
-	 * Prioritizes prod/peer deps over dev deps when same package appears in
-	 * multiple dependency types (stronger constraint wins).
-	 *
-	 * @returns fully initialized dependency graph with all nodes and edges
-	 */
-	build_from_repos(repos: Array<LocalRepo>): DependencyGraph {
-		const graph = new DependencyGraph();
-		graph.init_from_repos(repos);
-		return graph;
-	}
-
-	/**
-	 * Computes publishing order using topological sort with dev deps excluded.
-	 *
-	 * Excludes dev dependencies to break circular dev dependency cycles while
-	 * preserving production/peer dependency ordering. This allows patterns like
-	 * shared test utilities that depend on each other for development.
-	 *
-	 * @returns package names in safe publishing order (dependencies before dependents)
-	 * @throws {Error} if production/peer cycles detected (cannot be resolved by exclusion)
-	 */
-	compute_publishing_order(graph: DependencyGraph): Array<string> {
-		return graph.topological_sort(true); // Exclude dev dependencies
-	}
-
-	analyze(graph: DependencyGraph): {
-		production_cycles: Array<Array<string>>;
-		dev_cycles: Array<Array<string>>;
-		wildcard_deps: Array<{pkg: string; dep: string; version: string}>;
-		missing_peers: Array<{pkg: string; dep: string}>;
-	} {
-		const {production_cycles, dev_cycles} = graph.detect_cycles_by_type();
-		const wildcard_deps: Array<{pkg: string; dep: string; version: string}> = [];
-		const missing_peers: Array<{pkg: string; dep: string}> = [];
-
-		for (const node of graph.nodes.values()) {
-			for (const [dep_name, spec] of node.dependencies) {
-				if (spec.version === '*') {
-					wildcard_deps.push({pkg: node.name, dep: dep_name, version: spec.version});
-				}
-				if (spec.type === DEPENDENCY_TYPE.PEER && !graph.nodes.has(dep_name)) {
-					// External peer dependency
-					missing_peers.push({pkg: node.name, dep: dep_name});
-				}
+				edges.push({ from, to });
 			}
 		}
 
-		return {production_cycles, dev_cycles, wildcard_deps, missing_peers};
+		return { nodes, edges };
 	}
 }

package/src/lib/dependency_updater.ts

@@ -1,15 +1,15 @@
-import type {Logger} from '@fuzdev/fuz_util/log.ts';
-import {join} from 'node:path';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { join } from 'node:path';
 
-import type {LocalRepo} from './local_repo.ts';
-import type {PublishedVersion} from './multi_repo_publisher.ts';
+import type { LocalRepo } from './local_repo.ts';
+import type { PublishedVersion } from './multi_repo_publisher.ts';
 import {
 	create_changeset_for_dependency_updates,
-	create_dependency_updates,
+	create_dependency_updates
 } from './changeset_generator.ts';
-import {needs_update, get_update_prefix} from './version_utils.ts';
-import type {GitOperations, FsOperations} from './operations.ts';
-import {default_git_operations, default_fs_operations} from './operations_defaults.ts';
+import { needs_update, get_update_prefix } from './version_utils.ts';
+import type { GitOperations, FsOperations } from './operations.ts';
+import { default_git_operations, default_fs_operations } from './operations_defaults.ts';
 
 export type VersionStrategy = 'exact' | 'caret' | 'tilde' | 'gte';
 
@@ -30,7 +30,7 @@ export interface UpdatePackageJsonOptions {
  * 3. Creates auto-changeset if `published_versions` provided (for transitive updates)
  * 4. Commits both `package.json` and changeset with standard message
  *
- * Uses version strategy to determine prefix (exact, caret, tilde) while preserving
+ * Uses version strategy to determine prefix (exact, caret, tilde, gte) while preserving
  * existing prefixes when possible.
  *
  * @throws {Error} if file operations or git operations fail
@@ -38,21 +38,21 @@ export interface UpdatePackageJsonOptions {
 export const update_package_json = async (
 	repo: LocalRepo,
 	updates: Map<string, string>,
-	options: UpdatePackageJsonOptions = {},
+	options: UpdatePackageJsonOptions = {}
 ): Promise<void> => {
 	const {
 		strategy = 'caret',
 		published_versions,
 		log,
 		git_ops = default_git_operations,
-		fs_ops = default_fs_operations,
+		fs_ops = default_fs_operations
 	} = options;
 	if (updates.size === 0) return;
 
 	const package_json_path = join(repo.repo_dir, 'package.json');
 
 	// Read current package.json
-	const content_result = await fs_ops.readFile({path: package_json_path, encoding: 'utf8'});
+	const content_result = await fs_ops.readFile({ path: package_json_path, encoding: 'utf8' });
 	if (!content_result.ok) {
 		throw new Error(`Failed to read package.json: ${content_result.message}`);
 	}
@@ -105,12 +105,14 @@ export const update_package_json = async (
 	// Write updated package.json
 	const write_result = await fs_ops.writeFile({
 		path: package_json_path,
-		content: JSON.stringify(package_json, null, '\t') + '\n',
+		content: JSON.stringify(package_json, null, '\t') + '\n'
 	});
 	if (!write_result.ok) {
 		throw new Error(`Failed to write package.json: ${write_result.message}`);
 	}
 
+	const staged: Array<string> = [];
+
 	// Create changeset if we have published version info
 	if (published_versions && published_versions.size > 0) {
 		// Build dependency updates info for changeset
@@ -145,26 +147,30 @@ export const update_package_json = async (
 			const changeset_path = await create_changeset_for_dependency_updates(
 				repo,
 				dependency_updates,
-				{log, fs_ops},
+				{ log, fs_ops }
 			);
 
 			// Add changeset to git
-			const add_result = await git_ops.add({files: changeset_path, cwd: repo.repo_dir});
+			const add_result = await git_ops.add({ files: changeset_path, cwd: repo.repo_dir });
 			if (!add_result.ok) {
 				throw new Error(`Failed to stage changeset: ${add_result.message}`);
 			}
+			staged.push(changeset_path);
 		}
 	}
 
 	// Commit the changes (including both package.json and changeset)
-	const add_pkg_result = await git_ops.add({files: 'package.json', cwd: repo.repo_dir});
+	const add_pkg_result = await git_ops.add({ files: 'package.json', cwd: repo.repo_dir });
 	if (!add_pkg_result.ok) {
 		throw new Error(`Failed to stage package.json: ${add_pkg_result.message}`);
 	}
+	staged.push('package.json');
 
+	// commit only what this staged, so nothing else in the index rides along
 	const commit_result = await git_ops.commit({
 		message: `update dependencies after publishing`,
-		cwd: repo.repo_dir,
+		files: staged,
+		cwd: repo.repo_dir
 	});
 	if (!commit_result.ok) {
 		throw new Error(`Failed to commit: ${commit_result.message}`);
@@ -181,16 +187,16 @@ export interface UpdateAllReposOptions {
 export const update_all_repos = async (
 	repos: Array<LocalRepo>,
 	published: Map<string, string>,
-	options: UpdateAllReposOptions = {},
-): Promise<{updated: number; failed: Array<{repo: string; error: Error}>}> => {
+	options: UpdateAllReposOptions = {}
+): Promise<{ updated: number; failed: Array<{ repo: string; error: Error }> }> => {
 	const {
 		strategy = 'caret',
 		log,
 		git_ops = default_git_operations,
-		fs_ops = default_fs_operations,
+		fs_ops = default_fs_operations
 	} = options;
 	let updated_count = 0;
-	const failed: Array<{repo: string; error: Error}> = [];
+	const failed: Array<{ repo: string; error: Error }> = [];
 
 	for (const repo of repos) {
 		const updates: Map<string, string> = new Map();
@@ -226,29 +232,29 @@ export const update_all_repos = async (
 		if (updates.size === 0) continue;
 
 		try {
-			await update_package_json(repo, updates, {strategy, log, git_ops, fs_ops});
+			await update_package_json(repo, updates, { strategy, log, git_ops, fs_ops });
 			updated_count++;
 			log?.info(`    Updated ${updates.size} dependencies in ${repo.library.name}`);
 		} catch (error) {
 			const err = error instanceof Error ? error : new Error(String(error));
-			failed.push({repo: repo.library.name, error: err});
+			failed.push({ repo: repo.library.name, error: err });
 			log?.error(`    Failed to update ${repo.library.name}: ${err.message}`);
 		}
 	}
 
-	return {updated: updated_count, failed};
+	return { updated: updated_count, failed };
 };
 
 export const find_updates_needed = (
 	repo: LocalRepo,
-	published: Map<string, string>,
+	published: Map<string, string>
 ): Map<
 	string,
-	{current: string; new: string; type: 'dependencies' | 'devDependencies' | 'peerDependencies'}
+	{ current: string; new: string; type: 'dependencies' | 'devDependencies' | 'peerDependencies' }
 > => {
 	const updates: Map<
 		string,
-		{current: string; new: string; type: 'dependencies' | 'devDependencies' | 'peerDependencies'}
+		{ current: string; new: string; type: 'dependencies' | 'devDependencies' | 'peerDependencies' }
 	> = new Map();
 
 	// Check dependencies
@@ -259,7 +265,7 @@ export const find_updates_needed = (
 				updates.set(dep_name, {
 					current: current_version,
 					new: new_version,
-					type: 'dependencies',
+					type: 'dependencies'
 				});
 			}
 		}
@@ -273,7 +279,7 @@ export const find_updates_needed = (
 				updates.set(dep_name, {
 					current: current_version,
 					new: new_version,
-					type: 'devDependencies',
+					type: 'devDependencies'
 				});
 			}
 		}
@@ -287,7 +293,7 @@ export const find_updates_needed = (
 				updates.set(dep_name, {
 					current: current_version,
 					new: new_version,
-					type: 'peerDependencies',
+					type: 'peerDependencies'
 				});
 			}
 		}

package/src/lib/fetch_repo_data.ts

@@ -1,46 +1,81 @@
-import type {Logger} from '@fuzdev/fuz_util/log.ts';
-import {wait} from '@fuzdev/fuz_util/async.ts';
-import type {FetchValueCache} from '@fuzdev/fuz_util/fetch.ts';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { wait } from '@fuzdev/fuz_util/async.ts';
+import type { FetchValueCache } from '@fuzdev/fuz_util/fetch.ts';
 
-import {fetch_github_check_runs, fetch_github_pull_requests} from './github.ts';
-import type {RepoJson} from './repo.svelte.ts';
-import type {LocalRepo} from './local_repo.ts';
+import {
+	fetch_github_check_runs,
+	fetch_github_pull_requests,
+	type GithubCheckRunsItem
+} from './github.ts';
+import type { RepoJson } from './repo.svelte.ts';
+import type { LocalRepo } from './local_repo.ts';
+
+/**
+ * Options for `fetch_repo_data`.
+ */
+export interface FetchRepoDataOptions {
+	/** The repos to fetch GitHub metadata for, in order. */
+	local_repos: Array<LocalRepo>;
+	/** GitHub API token, sent with each request. */
+	token?: string;
+	/** Response memoization, from `fuz_util`'s `fetch.ts`. */
+	cache?: FetchValueCache;
+	log?: Logger;
+	/** Milliseconds to wait before each API request. Defaults to `33`. */
+	delay?: number;
+	/** Sent as the `x-github-api-version` header when set. */
+	github_api_version?: string;
+	/** The `fetch` the API requests go through. Defaults to `globalThis.fetch`. */
+	fetch?: typeof globalThis.fetch;
+}
 
 /**
  * Fetches GitHub metadata (CI status, PRs) for all repos.
  *
- * Fetches sequentially with delay between requests to respect GitHub API rate limits.
- * Uses `await_in_loop` intentionally to avoid parallel requests overwhelming the API.
+ * Fetches sequentially with a delay before each request to respect GitHub API
+ * rate limits. Uses `await_in_loop` intentionally to avoid parallel requests
+ * overwhelming the API. CI status is read for the branch each repo's registry
+ * entry follows (`main` when it names none), and that branch is written to
+ * `RepoJson.branch`.
  *
- * Error handling: Logs fetch failures but continues processing remaining repos.
- * Repos with failed fetches will have `null` for `check_runs` or `pull_requests`.
+ * A repo whose registry entry declares no CI (`ci: false`) isn't asked for
+ * check runs, and one with none on its branch isn't a failure: both leave
+ * `check_runs` `null` without logging. A failed fetch is logged as an error
+ * and leaves `null` for that repo's `check_runs` or `pull_requests`, and the
+ * remaining repos still fetch — except a 401 response or a repo URL without a
+ * GitHub owner, which throw.
  *
- * @param delay - milliseconds between API requests (default: 33ms)
- * @param cache - optional cache from `fuz_util`'s `fetch.js` for response memoization
- * @returns array of `Repo` objects with GitHub metadata attached
+ * @param options - the repos, credentials, cache, and pacing
+ * @returns a `RepoJson` for each repo, in the order given
+ * @throws {Error} on a 401 response (check `SECRET_GITHUB_API_TOKEN`) or a
+ *   repo whose URL has no GitHub owner
  */
-export const fetch_repo_data = async (
-	resolved_repos: Array<LocalRepo>,
-	token?: string,
-	cache?: FetchValueCache,
-	log?: Logger,
-	delay = 33,
-	github_api_version?: string,
-): Promise<Array<RepoJson>> => {
+export const fetch_repo_data = async (options: FetchRepoDataOptions): Promise<Array<RepoJson>> => {
+	const { local_repos, token, cache, log, delay = 33, github_api_version, fetch } = options;
 	const repos: Array<RepoJson> = [];
-	for (const {library, package_json, repo_config} of resolved_repos) {
+	for (const { library, package_json, entry } of local_repos) {
 		const repo_url = library.repo_url;
+		const branch = entry.branch ?? 'main';
 
-		// CI status
-		await wait(delay);
-		const check_runs = await fetch_github_check_runs(library, {
-			cache,
-			log,
-			token,
-			api_version: github_api_version,
-			ref: repo_config.branch,
-		});
-		if (!check_runs) log?.error('failed to fetch CI status: ' + repo_url);
+		// CI status, for repos the registry says run CI
+		let check_runs: GithubCheckRunsItem | null = null;
+		if (entry.ci) {
+			await wait(delay);
+			const fetched = await fetch_github_check_runs(library, {
+				cache,
+				log,
+				token,
+				api_version: github_api_version,
+				ref: branch,
+				fetch
+			});
+			if (fetched.ok) {
+				check_runs = fetched.value;
+				if (!check_runs) log?.debug(`no check runs on \`${branch}\`: ${repo_url}`);
+			} else {
+				log?.error(`failed to fetch CI status (${fetched.status}): ${repo_url}`);
+			}
+		}
 
 		// pull requests
 		await wait(delay);
@@ -49,14 +84,16 @@ export const fetch_repo_data = async (
 			log,
 			token,
 			api_version: github_api_version,
+			fetch
 		});
-		if (!pull_requests) log?.error('failed to fetch issues: ' + repo_url);
+		if (!pull_requests) log?.error('failed to fetch pull requests: ' + repo_url);
 
 		repos.push({
 			library_json: library.library_json,
 			package_json,
+			branch,
 			check_runs,
-			pull_requests,
+			pull_requests
 		});
 	}
 	return repos;

package/src/lib/fs_fetch_value_cache.ts

@@ -1,9 +1,13 @@
-import {mkdir, readFile, rm, writeFile} from 'node:fs/promises';
-import {dirname, join} from 'node:path';
-import {paths} from '@fuzdev/gro/paths.ts';
-import {format_file} from '@fuzdev/gro/format_file.ts';
-import {deserialize_cache, serialize_cache, type FetchValueCache} from '@fuzdev/fuz_util/fetch.ts';
-import {existsSync} from 'node:fs';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { paths } from '@fuzdev/gro/paths.ts';
+import { format_file } from '@fuzdev/gro/format_file.ts';
+import {
+	deserialize_cache,
+	serialize_cache,
+	type FetchValueCache
+} from '@fuzdev/fuz_util/fetch.ts';
+import { existsSync } from 'node:fs';
 
 // TODO upstream to Gro probably, and rename/redesign?
 
@@ -23,7 +27,7 @@ export interface FetchCache {
  * cache is cleared (delete file) and starts fresh. This handles format changes.
  *
  * Uses `structuredClone` to track changes - only writes to disk if data modified.
- * Formatted with Prettier before writing for version control friendliness.
+ * Formatted with gro's `format_file` before writing for version control friendliness.
  *
  * @param name - cache filename (without .json extension)
  * @param dir - cache directory (defaults to `.gro/build/fetch/`)
@@ -31,7 +35,7 @@ export interface FetchCache {
  */
 export const create_fs_fetch_value_cache = async (
 	name: string,
-	dir = join(paths.build, 'fetch'),
+	dir = join(paths.build, 'fetch')
 ): Promise<FetchCache> => {
 	const data_path = join(dir, name + '.json');
 	let data: FetchValueCache;
@@ -54,10 +58,10 @@ export const create_fs_fetch_value_cache = async (
 			if (deep_equal_maps(initial, data)) {
 				return false; // no changes to save
 			}
-			await mkdir(dirname(data_path), {recursive: true});
-			await writeFile(data_path, await format_file(serialize_cache(data), {filepath: data_path}));
+			await mkdir(dirname(data_path), { recursive: true });
+			await writeFile(data_path, format_file(serialize_cache(data), { lang: 'json' }));
 			return true;
-		},
+		}
 	};
 };