@ryanatkn/gro 0.179.0 → 0.181.0

package/src/lib/gen.ts

@@ -1,11 +1,12 @@
-import type {Logger} from '@ryanatkn/belt/log.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
 import {join, basename, dirname, isAbsolute} from 'node:path';
 import {mkdir, readFile, writeFile} from 'node:fs/promises';
-import type {Result} from '@ryanatkn/belt/result.js';
-import type {Timings} from '@ryanatkn/belt/timings.js';
+import type {Result} from '@fuzdev/fuz_util/result.js';
+import type {Timings} from '@fuzdev/fuz_util/timings.js';
 import {styleText as st} from 'node:util';
-import {existsSync} from 'node:fs';
-import type {PathId} from '@ryanatkn/belt/path.js';
+import type {PathId} from '@fuzdev/fuz_util/path.js';
+import {map_concurrent} from '@fuzdev/fuz_util/async.js';
+import {fs_search} from '@fuzdev/fuz_util/fs.js';
 
 import {print_path} from './paths.ts';
 import type {GroConfig} from './gro_config.ts';
@@ -18,7 +19,6 @@ import {
 	type ResolvedInputFile,
 	type ResolvedInputPath,
 } from './input_path.ts';
-import {search_fs} from './search_fs.ts';
 import type {Filer} from './filer.ts';
 import type {InvokeTask} from './task.ts';
 
@@ -210,23 +210,28 @@ export type AnalyzedGenResult =
 			has_changed: true;
 	  };
 
-export const analyze_gen_results = (gen_results: GenResults): Promise<Array<AnalyzedGenResult>> =>
-	Promise.all(
-		gen_results.successes
-			.map((result) => result.files.map((file) => analyze_gen_result(file)))
-			.flat(),
-	);
+export const analyze_gen_results = async (
+	gen_results: GenResults,
+): Promise<Array<AnalyzedGenResult>> => {
+	const files = gen_results.successes.flatMap((result) => result.files);
+	return map_concurrent(files, (file) => analyze_gen_result(file), 10);
+};
 
 export const analyze_gen_result = async (file: GenFile): Promise<AnalyzedGenResult> => {
-	if (!existsSync(file.id)) {
-		return {
-			file,
-			existing_content: null,
-			is_new: true,
-			has_changed: true,
-		};
+	let existing_content: string;
+	try {
+		existing_content = await readFile(file.id, 'utf8');
+	} catch (error) {
+		if (error.code === 'ENOENT') {
+			return {
+				file,
+				existing_content: null,
+				is_new: true,
+				has_changed: true,
+			};
+		}
+		throw error;
 	}
-	const existing_content = await readFile(file.id, 'utf8');
 	return {
 		file,
 		existing_content,
@@ -240,26 +245,25 @@ export const write_gen_results = async (
 	analyzed_gen_results: Array<AnalyzedGenResult>,
 	log: Logger,
 ): Promise<void> => {
-	await Promise.all(
-		gen_results.successes
-			.map((result) =>
-				result.files.map(async (file) => {
-					const analyzed = analyzed_gen_results.find((r) => r.file.id === file.id);
-					if (!analyzed) throw Error('Expected to find analyzed result: ' + file.id);
-					const log_args = [print_path(file.id), 'generated from', print_path(file.origin_id)];
-					if (analyzed.is_new) {
-						log.info('writing new', ...log_args);
-						await mkdir(dirname(file.id), {recursive: true});
-						await writeFile(file.id, file.content);
-					} else if (analyzed.has_changed) {
-						log.info('writing changed', ...log_args);
-						await writeFile(file.id, file.content);
-					} else {
-						log.info('skipping unchanged', ...log_args);
-					}
-				}),
-			)
-			.flat(),
+	const files = gen_results.successes.flatMap((result) => result.files);
+	await map_concurrent(
+		files,
+		async (file) => {
+			const analyzed = analyzed_gen_results.find((r) => r.file.id === file.id);
+			if (!analyzed) throw Error('Expected to find analyzed result: ' + file.id);
+			const log_args = [print_path(file.id), 'generated from', print_path(file.origin_id)];
+			if (analyzed.is_new) {
+				log.info('writing new', ...log_args);
+				await mkdir(dirname(file.id), {recursive: true});
+				await writeFile(file.id, file.content);
+			} else if (analyzed.has_changed) {
+				log.info('writing changed', ...log_args);
+				await writeFile(file.id, file.content);
+			} else {
+				log.info('skipping unchanged', ...log_args);
+			}
+		},
+		10,
 	);
 };
 
@@ -289,17 +293,17 @@ export type FindGenfilesFailure =
 /**
  * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
  */
-export const find_genfiles = (
+export const find_genfiles = async (
 	input_paths: Array<InputPath>,
 	root_dirs: Array<PathId>,
 	config: GroConfig,
 	timings?: Timings,
-): FindGenfilesResult => {
+): Promise<FindGenfilesResult> => {
 	const extensions: Array<string> = [GEN_FILE_PATTERN];
 
 	// Check which extension variation works - if it's a directory, prefer others first!
 	const timing_to_resolve_input_paths = timings?.start('resolve input paths');
-	const {resolved_input_paths, unmapped_input_paths} = resolve_input_paths(
+	const {resolved_input_paths, unmapped_input_paths} = await resolve_input_paths(
 		input_paths,
 		root_dirs,
 		extensions,
@@ -320,15 +324,17 @@ export const find_genfiles = (
 	}
 
 	// Find all of the files for any directories.
-	const timing_to_search_fs = timings?.start('find files');
+	const timing_to_fs_search = timings?.start('find files');
 	const {resolved_input_files, resolved_input_files_by_root_dir, input_directories_with_no_files} =
-		resolve_input_files(resolved_input_paths, (id) =>
-			search_fs(id, {
-				filter: config.search_filters,
-				file_filter: (p) => extensions.some((e) => p.includes(e)),
-			}),
+		await resolve_input_files(
+			resolved_input_paths,
+			async (id) =>
+				await fs_search(id, {
+					filter: config.search_filters,
+					file_filter: (p) => extensions.some((e) => p.includes(e)),
+				}),
 		);
-	timing_to_search_fs?.();
+	timing_to_fs_search?.();
 
 	// Error if any input path has no files. (means we have an empty directory)
 	if (input_directories_with_no_files.length) {

package/src/lib/gen_helpers.ts

@@ -1,7 +1,7 @@
 import {resolve} from 'node:path';
-import type {Logger} from '@ryanatkn/belt/log.js';
-import type {Timings} from '@ryanatkn/belt/timings.js';
-import type {PathId} from '@ryanatkn/belt/path.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {Timings} from '@fuzdev/fuz_util/timings.js';
+import type {PathId} from '@fuzdev/fuz_util/path.js';
 
 import type {GroConfig} from './gro_config.ts';
 import {filter_dependents, type Filer} from './filer.ts';

package/src/lib/github.ts

@@ -2,8 +2,8 @@
 // for now it's just calling a single endpoint so we do it manually
 // and we specify just the types we need
 
-import {FetchValueCache, fetch_value} from '@ryanatkn/belt/fetch.js';
-import type {Logger} from '@ryanatkn/belt/log.js';
+import {FetchValueCache, fetch_value} from '@fuzdev/fuz_util/fetch.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
 import {z} from 'zod';
 
 export const GITHUB_REPO_MATCHER = /.+github.com\/(.+)\/(.+)/;

package/src/lib/gro.config.default.ts

@@ -18,7 +18,7 @@ import {load_package_json} from './package_json.ts';
  * - if `src/lib/server/server.ts`, assumes a Node server - needs config
  */
 const config: CreateGroConfig = async (cfg, svelte_config) => {
-	const package_json = load_package_json(); // TODO gets wastefully loaded by some plugins, maybe put in plugin/task context? how does that interact with `map_package_json`?
+	const package_json = await load_package_json(); // TODO gets wastefully loaded by some plugins, maybe put in plugin/task context? how does that interact with `map_package_json`?
 
 	const [has_server_result, has_sveltekit_library_result, has_sveltekit_app_result] =
 		await Promise.all([

package/src/lib/gro_config.ts

@@ -1,8 +1,8 @@
 import {join, resolve} from 'node:path';
-import {existsSync} from 'node:fs';
-import {identity} from '@ryanatkn/belt/function.js';
-import type {PathFilter, PathId} from '@ryanatkn/belt/path.js';
-import {json_stringify_deterministic} from '@ryanatkn/belt/json.js';
+import {fs_exists} from '@fuzdev/fuz_util/fs.js';
+import {identity} from '@fuzdev/fuz_util/function.js';
+import type {PathFilter, PathId} from '@fuzdev/fuz_util/path.js';
+import {json_stringify_deterministic} from '@fuzdev/fuz_util/json.js';
 
 import {GRO_DIST_DIR, IS_THIS_GRO, paths} from './paths.ts';
 import {
@@ -208,7 +208,7 @@ export const load_gro_config = async (dir = paths.root): Promise<GroConfig> => {
 	);
 
 	const config_path = join(dir, GRO_CONFIG_FILENAME);
-	if (!existsSync(config_path)) {
+	if (!(await fs_exists(config_path))) {
 		// No user config file found, so return the default.
 		return default_config;
 	}

package/src/lib/gro_helpers.ts

@@ -1,7 +1,7 @@
 import {realpathSync, existsSync} from 'node:fs';
 import {join, resolve} from 'node:path';
 import {fileURLToPath} from 'node:url';
-import {spawn, type SpawnResult} from '@ryanatkn/belt/process.js';
+import {spawn, type SpawnResult} from '@fuzdev/fuz_util/process.js';
 
 import {JS_CLI_DEFAULT, NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME} from './constants.ts';
 

package/src/lib/gro_plugin_gen.ts

@@ -1,6 +1,6 @@
-import {EMPTY_OBJECT} from '@ryanatkn/belt/object.js';
-import {throttle} from '@ryanatkn/belt/throttle.js';
-import {UnreachableError} from '@ryanatkn/belt/error.js';
+import {EMPTY_OBJECT} from '@fuzdev/fuz_util/object.js';
+import {throttle} from '@fuzdev/fuz_util/throttle.js';
+import {UnreachableError} from '@fuzdev/fuz_util/error.js';
 
 import type {Plugin} from './plugin.ts';
 import type {Args} from './args.ts';
@@ -48,7 +48,7 @@ export const gro_plugin_gen = ({
 				// Some parts of the build may have already happened,
 				// making us miss `build` events for gen dependencies,
 				// so we run a full `gen` here even if it's usually wasteful.
-				const found = find_genfiles(input_paths, root_dirs, config);
+				const found = await find_genfiles(input_paths, root_dirs, config);
 				if (found.ok && found.value.resolved_input_files.length > 0) {
 					await gen();
 				}

package/src/lib/gro_plugin_server.ts

@@ -1,13 +1,13 @@
-import {spawn_restartable_process, type RestartableProcess} from '@ryanatkn/belt/process.js';
+import {spawn_restartable_process, type RestartableProcess} from '@fuzdev/fuz_util/process.js';
 import * as esbuild from 'esbuild';
 import type {Config as SvelteConfig} from '@sveltejs/kit';
 import {join, resolve} from 'node:path';
-import {identity} from '@ryanatkn/belt/function.js';
-import {strip_before, strip_end} from '@ryanatkn/belt/string.js';
-import type {Result} from '@ryanatkn/belt/result.js';
-import {fs_exists} from '@ryanatkn/belt/fs.js';
-import {throttle} from '@ryanatkn/belt/throttle.js';
-import type {PathId} from '@ryanatkn/belt/path.js';
+import {identity} from '@fuzdev/fuz_util/function.js';
+import {strip_before, strip_end} from '@fuzdev/fuz_util/string.js';
+import type {Result} from '@fuzdev/fuz_util/result.js';
+import {fs_exists} from '@fuzdev/fuz_util/fs.js';
+import {throttle} from '@fuzdev/fuz_util/throttle.js';
+import type {PathId} from '@fuzdev/fuz_util/path.js';
 
 import type {Plugin} from './plugin.ts';
 import {base_path_to_path_id, LIB_DIRNAME, paths} from './paths.ts';
@@ -217,8 +217,8 @@ export const gro_plugin_server = ({
 					let build_result;
 					try {
 						build_result = await build_ctx!.rebuild();
-					} catch (err) {
-						log.error('[gro_plugin_server] build failed', err);
+					} catch (error) {
+						log.error('[gro_plugin_server] build failed', error);
 						return;
 					}
 					const {metafile} = build_result;

package/src/lib/gro_plugin_sveltekit_app.ts

@@ -1,6 +1,7 @@
-import type {SpawnedProcess} from '@ryanatkn/belt/process.js';
-import {cpSync, mkdirSync, rmSync, writeFileSync, existsSync} from 'node:fs';
+import type {SpawnedProcess} from '@fuzdev/fuz_util/process.js';
+import {cp, mkdir, rm, writeFile} from 'node:fs/promises';
 import {dirname, join} from 'node:path';
+import {fs_exists} from '@fuzdev/fuz_util/fs.js';
 
 import type {Plugin} from './plugin.ts';
 import {serialize_args, to_forwarded_args} from './args.ts';
@@ -57,7 +58,7 @@ export const gro_plugin_sveltekit_app = ({
 	return {
 		name: 'gro_plugin_sveltekit_app',
 		setup: async ({dev, watch, log, config}) => {
-			const found_vite_cli = find_cli(vite_cli);
+			const found_vite_cli = await find_cli(vite_cli);
 			if (!found_vite_cli)
 				throw Error(
 					`Failed to find Vite CLI \`${vite_cli}\`, do you need to run \`${config.pm_cli} i\`?`,
@@ -66,7 +67,7 @@ export const gro_plugin_sveltekit_app = ({
 				// `vite dev` in development mode
 				if (watch) {
 					const serialized_args = ['dev', ...serialize_args(to_forwarded_args(vite_cli))];
-					sveltekit_process = spawn_cli_process(found_vite_cli, serialized_args, log);
+					sveltekit_process = await spawn_cli_process(found_vite_cli, serialized_args, log);
 				} else {
 					log.debug(
 						`the SvelteKit app plugin is loaded but will not output anything` +
@@ -77,7 +78,7 @@ export const gro_plugin_sveltekit_app = ({
 				// `vite build` in production mode
 
 				// `.well-known/package.json`
-				const package_json = load_package_json(); // TODO put in plugin context? same with sveltekit config?
+				const package_json = await load_package_json(); // TODO put in plugin context? same with sveltekit config?
 				if (well_known_package_json === undefined) {
 					well_known_package_json = package_json.public; // eslint-disable-line no-param-reassign
 				}
@@ -91,7 +92,7 @@ export const gro_plugin_sveltekit_app = ({
 
 				// `.well-known/source.json` and `.well-known/src/`
 				const final_package_json = mapped_package_json ?? package_json;
-				const source_json = source_json_create(final_package_json, undefined, log);
+				const source_json = await source_json_create(final_package_json, undefined, log);
 				if (well_known_source_json === undefined) {
 					well_known_source_json = final_package_json.public; // eslint-disable-line no-param-reassign
 				}
@@ -109,7 +110,7 @@ export const gro_plugin_sveltekit_app = ({
 				// copy files to `static` before building, in such a way
 				// that's non-destructive to existing files and dirs and easy to clean up
 				const {assets_path} = default_svelte_config;
-				const cleanups: Array<Cleanup> = [
+				const cleanup_promises = [
 					serialized_package_json
 						? create_temporarily(
 								join(assets_path, '.well-known/package.json'),
@@ -141,9 +142,11 @@ export const gro_plugin_sveltekit_app = ({
 					host_target === 'github_pages'
 						? create_temporarily(join(assets_path, '.nojekyll'), '')
 						: null,
-				].filter((v) => v != null);
-				const cleanup = () => {
-					for (const c of cleanups) c();
+				].filter((v): v is Promise<AsyncCleanup> => v != null);
+				const cleanups = await Promise.all(cleanup_promises);
+				const cleanup = async () => {
+					// eslint-disable-next-line no-await-in-loop
+					for (const c of cleanups) await c();
 				};
 				try {
 					const serialized_args = ['build', ...serialize_args(to_forwarded_args(vite_cli))];
@@ -151,11 +154,11 @@ export const gro_plugin_sveltekit_app = ({
 					if (!spawned?.ok) {
 						throw new TaskError(`${vite_cli} build failed with exit code ${spawned?.code}`);
 					}
-				} catch (err) {
-					cleanup();
-					throw err;
+				} catch (error) {
+					await cleanup();
+					throw error;
 				}
-				cleanup();
+				await cleanup();
 			}
 		},
 		teardown: async () => {
@@ -167,41 +170,41 @@ export const gro_plugin_sveltekit_app = ({
 	};
 };
 
-type Cleanup = () => void;
+type AsyncCleanup = () => Promise<void>;
 
 // TODO probably extract these, and create a common helper or merge them
 
-const copy_temporarily = (
+const copy_temporarily = async (
 	source_path: string,
 	dest_dir: string,
 	dest_base_dir = '',
 	filter?: CopyFileFilter,
-): Cleanup => {
+): Promise<AsyncCleanup> => {
 	const path = join(dest_dir, dest_base_dir, source_path);
 	const dir = dirname(path);
 
-	const dir_already_exists = existsSync(dir);
+	const dir_already_exists = await fs_exists(dir);
 	let root_created_dir: string | undefined;
 	if (!dir_already_exists) {
-		root_created_dir = to_root_dir_that_doesnt_exist(dir);
+		root_created_dir = await to_root_dir_that_doesnt_exist(dir);
 		if (!root_created_dir) throw Error();
-		mkdirSync(dir, {recursive: true});
+		await mkdir(dir, {recursive: true});
 	}
 
-	const path_already_exists = existsSync(path);
+	const path_already_exists = await fs_exists(path);
 	if (!path_already_exists) {
-		cpSync(source_path, path, {recursive: true, filter});
+		await cp(source_path, path, {recursive: true, filter});
 	}
 
-	return () => {
+	return async () => {
 		if (!dir_already_exists) {
 			if (!root_created_dir) throw Error();
-			if (existsSync(root_created_dir)) {
-				rmSync(root_created_dir, {recursive: true});
+			if (await fs_exists(root_created_dir)) {
+				await rm(root_created_dir, {recursive: true});
 			}
 		} else if (!path_already_exists) {
-			if (existsSync(path)) {
-				rmSync(path, {recursive: true});
+			if (await fs_exists(path)) {
+				await rm(path, {recursive: true});
 			}
 		}
 	};
@@ -214,31 +217,31 @@ const copy_temporarily = (
  * @param contents
  * @returns cleanup function that deletes the file and any created dirs
  */
-const create_temporarily = (path: string, contents: string): Cleanup => {
+const create_temporarily = async (path: string, contents: string): Promise<AsyncCleanup> => {
 	const dir = dirname(path);
 
-	const dir_already_exists = existsSync(dir);
+	const dir_already_exists = await fs_exists(dir);
 	let root_created_dir: string | undefined;
 	if (!dir_already_exists) {
-		root_created_dir = to_root_dir_that_doesnt_exist(dir);
+		root_created_dir = await to_root_dir_that_doesnt_exist(dir);
 		if (!root_created_dir) throw Error();
-		mkdirSync(dir, {recursive: true});
+		await mkdir(dir, {recursive: true});
 	}
 
-	const path_already_exists = existsSync(path);
+	const path_already_exists = await fs_exists(path);
 	if (!path_already_exists) {
-		writeFileSync(path, contents, 'utf8');
+		await writeFile(path, contents, 'utf8');
 	}
 
-	return () => {
+	return async () => {
 		if (!dir_already_exists) {
 			if (!root_created_dir) throw Error();
-			if (existsSync(root_created_dir)) {
-				rmSync(root_created_dir, {recursive: true});
+			if (await fs_exists(root_created_dir)) {
+				await rm(root_created_dir, {recursive: true});
 			}
 		} else if (!path_already_exists) {
-			if (existsSync(path)) {
-				rmSync(path);
+			if (await fs_exists(path)) {
+				await rm(path);
 			}
 		}
 	};
@@ -249,11 +252,12 @@ const create_temporarily = (path: string, contents: string): Cleanup => {
  * for `/a/b/DOESNT_EXIST/NOR_THIS/ETC` returns `/a/b/DOESNT_EXIST`
  * where `/a/b` does exist on the filesystem and `DOESNT_EXIST` is not one of its subdirectories.
  */
-const to_root_dir_that_doesnt_exist = (dir: string): string | undefined => {
+const to_root_dir_that_doesnt_exist = async (dir: string): Promise<string | undefined> => {
 	let prev: string | undefined;
 	let d = dir;
 	do {
-		if (existsSync(d)) {
+		// eslint-disable-next-line no-await-in-loop
+		if (await fs_exists(d)) {
 			return prev;
 		}
 		prev = d;

package/src/lib/gro_plugin_sveltekit_library.ts

@@ -1,4 +1,4 @@
-import {print_spawn_result, spawn} from '@ryanatkn/belt/process.js';
+import {print_spawn_result, spawn} from '@fuzdev/fuz_util/process.js';
 
 import type {Plugin} from './plugin.ts';
 import {TaskError} from './task.ts';
@@ -23,12 +23,11 @@ export const gro_plugin_sveltekit_library = ({
 	svelte_package_options,
 	svelte_package_cli = SVELTE_PACKAGE_CLI,
 }: GroPluginSveltekitLibraryOptions = {}): Plugin => {
-	const package_json = load_package_json();
-
 	return {
 		name: 'gro_plugin_sveltekit_library',
 		setup: async ({dev, log, config}) => {
 			if (!dev) {
+				const package_json = await load_package_json();
 				await run_svelte_package(
 					package_json,
 					svelte_package_options,
@@ -39,6 +38,7 @@ export const gro_plugin_sveltekit_library = ({
 			}
 		},
 		adapt: async ({log, timings, config}) => {
+			const package_json = await load_package_json();
 			// link the CLI binaries if they exist
 			if (package_json.bin) {
 				const timing_to_link = timings.start(`${config.pm_cli} link`);

package/src/lib/input_path.ts

@@ -1,12 +1,12 @@
 import {dirname, isAbsolute, join, resolve} from 'node:path';
-import {existsSync, statSync} from 'node:fs';
-import {strip_start} from '@ryanatkn/belt/string.js';
+import {stat} from 'node:fs/promises';
+import {fs_exists, fs_search} from '@fuzdev/fuz_util/fs.js';
+import {strip_start} from '@fuzdev/fuz_util/string.js';
 import {z} from 'zod';
-import type {Flavored} from '@ryanatkn/belt/types.js';
-import type {PathInfo, PathId, ResolvedPath} from '@ryanatkn/belt/path.js';
+import type {Flavored} from '@fuzdev/fuz_util/types.js';
+import type {PathInfo, PathId, ResolvedPath} from '@fuzdev/fuz_util/path.js';
 
 import {GRO_PACKAGE_DIR, GRO_DIST_DIR} from './paths.ts';
-import {search_fs} from './search_fs.ts';
 import {TASK_FILE_SUFFIX_JS} from './task.ts';
 
 // TODO Flavored doesn't work when used in schemas, use Zod brand instead? problem is ergonomics
@@ -55,11 +55,11 @@ export interface PossiblePath {
  * Gets a list of possible source ids for each input path with `extensions`,
  * duplicating each under `root_dirs`, without checking the filesystem.
  */
-export const get_possible_paths = (
+export const get_possible_paths = async (
 	input_path: InputPath,
 	root_dirs: Array<PathId>,
 	extensions: Array<string>,
-): Array<PossiblePath> => {
+): Promise<Array<PossiblePath>> => {
 	const possible_paths: Set<PossiblePath> = new Set();
 
 	const add_possible_paths = (path: string, root_dir: PathId) => {
@@ -83,14 +83,9 @@ export const get_possible_paths = (
 	};
 
 	if (isAbsolute(input_path)) {
-		// TODO this is hacky because it's the only place we're using sync fs calls (even if they're faster, it's oddly inconsistent),
-		// we probably should just change this function to check the filesystem and not return non-existing paths
-		add_possible_paths(
-			input_path,
-			existsSync(input_path) && statSync(input_path).isDirectory()
-				? input_path
-				: dirname(input_path),
-		);
+		const exists = await fs_exists(input_path);
+		const is_directory = exists && (await stat(input_path)).isDirectory();
+		add_possible_paths(input_path, is_directory ? input_path : dirname(input_path));
 	} else {
 		for (const root_dir of root_dirs) {
 			add_possible_paths(join(root_dir, input_path), root_dir);
@@ -123,24 +118,27 @@ export interface ResolvedInputPaths {
  * and stopping at the first existing file or falling back to the first existing directory.
  * If none is found for an input path, it's added to `unmapped_input_paths`.
  */
-export const resolve_input_paths = (
+export const resolve_input_paths = async (
 	input_paths: Array<InputPath>,
 	root_dirs: Array<PathId>,
 	extensions: Array<string>,
-): ResolvedInputPaths => {
+): Promise<ResolvedInputPaths> => {
 	const resolved_input_paths: Array<ResolvedInputPath> = [];
 	const possible_paths_by_input_path: Map<InputPath, Array<PossiblePath>> = new Map();
 	const unmapped_input_paths: Array<InputPath> = [];
 	for (const input_path of input_paths) {
 		let found_file: [PathInfo, PossiblePath] | null = null;
 		let found_dirs: Array<[PathInfo, PossiblePath]> | null = null;
-		const possible_paths = get_possible_paths(input_path, root_dirs, extensions);
+		// eslint-disable-next-line no-await-in-loop
+		const possible_paths = await get_possible_paths(input_path, root_dirs, extensions);
 		possible_paths_by_input_path.set(input_path, possible_paths);
 
 		// Find the first existing file path or fallback to the first directory path.
 		for (const possible_path of possible_paths) {
-			if (!existsSync(possible_path.id)) continue;
-			const stats = statSync(possible_path.id);
+			// eslint-disable-next-line no-await-in-loop
+			if (!(await fs_exists(possible_path.id))) continue;
+			// eslint-disable-next-line no-await-in-loop
+			const stats = await stat(possible_path.id);
 			if (stats.isDirectory()) {
 				found_dirs ??= [];
 				found_dirs.push([{id: possible_path.id, is_directory: stats.isDirectory()}, possible_path]);
@@ -186,10 +184,10 @@ export interface ResolvedInputFiles {
  * Finds all of the matching files for the given input paths.
  * De-dupes source ids.
  */
-export const resolve_input_files = (
+export const resolve_input_files = async (
 	resolved_input_paths: Array<ResolvedInputPath>,
-	search: (dir: string) => Array<ResolvedPath> = search_fs,
-): ResolvedInputFiles => {
+	search: (dir: string) => Promise<Array<ResolvedPath>> = fs_search,
+): Promise<ResolvedInputFiles> => {
 	const resolved_input_files: Array<ResolvedInputFile> = [];
 	// Add all input paths initially, and remove each when resolved to a file.
 	const existing_path_ids: Set<PathId> = new Set();
@@ -206,7 +204,8 @@ export const resolve_input_files = (
 		const {input_path, id, is_directory} = resolved_input_path;
 		if (is_directory) {
 			// Handle input paths that resolve to directories.
-			const files = search(id);
+			// eslint-disable-next-line no-await-in-loop
+			const files = await search(id);
 			if (!files.length) continue;
 			const path_ids: Array<PathId> = [];
 			for (const {path, is_directory} of files) {

package/src/lib/invoke.ts

@@ -1,5 +1,5 @@
-import {attach_process_error_handlers} from '@ryanatkn/belt/process.js';
-import {configure_print_colors} from '@ryanatkn/belt/print.js';
+import {attach_process_error_handlers} from '@fuzdev/fuz_util/process.js';
+import {configure_print_colors} from '@fuzdev/fuz_util/print.js';
 
 import {invoke_task} from './invoke_task.ts';
 import {to_task_args} from './args.ts';

package/src/lib/invoke_task.ts

@@ -1,7 +1,7 @@
 import {styleText as st} from 'node:util';
-import {create_stopwatch, Timings} from '@ryanatkn/belt/timings.js';
-import {print_ms, print_timings} from '@ryanatkn/belt/print.js';
-import {Logger} from '@ryanatkn/belt/log.js';
+import {create_stopwatch, Timings} from '@fuzdev/fuz_util/timings.js';
+import {print_ms, print_timings} from '@fuzdev/fuz_util/print.js';
+import {Logger} from '@fuzdev/fuz_util/log.js';
 
 import {to_forwarded_args, type Args} from './args.ts';
 import {run_task} from './run_task.ts';
@@ -68,7 +68,7 @@ export const invoke_task = async (
 
 	// Check if the caller just wants to see the version.
 	if (!task_name && (args?.version || args?.v)) {
-		const gro_package_json = load_gro_package_json();
+		const gro_package_json = await load_gro_package_json();
 		log.info(`${st('gray', 'v')}${st('cyan', gro_package_json.version)}`);
 		await finish();
 		return;
@@ -81,7 +81,7 @@ export const invoke_task = async (
 
 	// Find the task or directory specified by the `input_path`.
 	// Fall back to searching the Gro directory as well.
-	const found = find_tasks([input_path], task_root_dirs, config);
+	const found = await find_tasks([input_path], task_root_dirs, config);
 	if (!found.ok) {
 		log_error_reasons(log, found.reasons);
 		throw new SilentError();