@ryanatkn/gro 0.178.0 → 0.180.0

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 {cp, mkdir, rm, writeFile} from 'node:fs/promises';
 import {dirname, join} from 'node:path';
+import {fs_exists} from '@ryanatkn/belt/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
 				}
@@ -100,7 +101,8 @@ export const gro_plugin_sveltekit_app = ({
 					: well_known_source_json === true
 						? source_json
 						: await well_known_source_json(source_json);
-				const serialized_source_json = mapped_source_json && source_json_serialize(mapped_source_json);
+				const serialized_source_json =
+					mapped_source_json && source_json_serialize(mapped_source_json);
 
 				// TODO this strategy means the files aren't available during development --
 				// maybe a Vite middleware is best? what if this plugin added its plugin to your `vite.config.ts`?
@@ -108,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'),
@@ -116,7 +118,10 @@ export const gro_plugin_sveltekit_app = ({
 							)
 						: null,
 					serialized_source_json
-						? create_temporarily(join(assets_path, '.well-known/source.json'), serialized_source_json)
+						? create_temporarily(
+								join(assets_path, '.well-known/source.json'),
+								serialized_source_json,
+							)
 						: null,
 					serialized_source_json && well_known_src_files
 						? copy_temporarily(
@@ -137,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))];
@@ -147,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 () => {
@@ -163,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});
 			}
 		}
 	};
@@ -210,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);
 			}
 		}
 	};
@@ -245,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

@@ -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 {stat} from 'node:fs/promises';
+import {fs_exists, fs_search} from '@ryanatkn/belt/fs.js';
 import {strip_start} from '@ryanatkn/belt/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 {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_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();

package/src/lib/lint.task.ts

@@ -21,7 +21,7 @@ export const task: Task<Args> = {
 	run: async ({log, args}): Promise<void> => {
 		const {_, eslint_cli} = args;
 
-		const found_eslint_cli = find_cli(eslint_cli);
+		const found_eslint_cli = await find_cli(eslint_cli);
 		if (!found_eslint_cli) {
 			// TODO maybe make this an option?
 			log.info('ESLint is not installed; skipping linting');

package/src/lib/loader.ts

@@ -233,7 +233,7 @@ export const resolve: ResolveHook = async (specifier, context, nextResolve) => {
 		return nextResolve(s, context);
 	}
 
-	const resolved = resolve_specifier(s, dirname(fileURLToPath(parent_url)));
+	const resolved = await resolve_specifier(s, dirname(fileURLToPath(parent_url)));
 
 	return {
 		url: pathToFileURL(resolved.path_id_with_querystring).href,

package/src/lib/modules.ts

@@ -38,8 +38,8 @@ export const load_module = async <TModule extends Record<string, any>>(
 			import_path = url.href;
 		}
 		mod = await import(import_path);
-	} catch (err) {
-		return {ok: false, type: 'failed_import', id, error: err};
+	} catch (error) {
+		return {ok: false, type: 'failed_import', id, error};
 	}
 	if (validate && !validate(mod)) {
 		return {ok: false, type: 'failed_validation', id, mod, validation: validate.name};

package/src/lib/package_json.ts

@@ -1,10 +1,11 @@
 import {z} from 'zod';
 import {join} from 'node:path';
-import {readFileSync, writeFileSync} from 'node:fs';
+import {readFile, writeFile} from 'node:fs/promises';
 import {plural, strip_end} from '@ryanatkn/belt/string.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
 import {styleText as st} from 'node:util';
 import {PackageJson, PackageJsonExports} from '@ryanatkn/belt/package_json.js';
+import {fs_search} from '@ryanatkn/belt/fs.js';
 
 import {paths, gro_paths, IS_THIS_GRO} from './paths.ts';
 import {
@@ -16,7 +17,6 @@ import {
 	JSON_MATCHER,
 	CSS_MATCHER,
 } from './constants.ts';
-import {search_fs} from './search_fs.ts';
 import {has_sveltekit_library} from './sveltekit_helpers.ts';
 import {GITHUB_REPO_MATCHER} from './github.ts';
 
@@ -26,20 +26,20 @@ export type PackageJsonMapper = (
 
 export const EMPTY_PACKAGE_JSON: PackageJson = {name: '', version: ''};
 
-export const load_package_json = (
+export const load_package_json = async (
 	dir = IS_THIS_GRO ? gro_paths.root : paths.root,
 	cache?: Record<string, PackageJson>,
 	parse = true, // TODO pass `false` here in more places, especially anything perf-sensitive like work on startup
 	log?: Logger,
-): PackageJson => {
+): Promise<PackageJson> => {
 	let package_json: PackageJson;
 	if (cache && dir in cache) {
 		return cache[dir]!;
 	}
 	try {
-		package_json = JSON.parse(load_package_json_contents(dir));
-	} catch (err) {
-		log?.error(st('yellow', `Failed to load package.json in ${dir}`), err);
+		package_json = JSON.parse(await load_package_json_contents(dir));
+	} catch (error) {
+		log?.error(st('yellow', `Failed to load package.json in ${dir}`), error);
 		return EMPTY_PACKAGE_JSON;
 	}
 	if (parse) {
@@ -58,7 +58,7 @@ export const sync_package_json = async (
 	dir = paths.root,
 	exports_dir = paths.lib,
 ): Promise<{package_json: PackageJson | null; changed: boolean}> => {
-	const exported_files = search_fs(exports_dir);
+	const exported_files = await fs_search(exports_dir);
 	const exported_paths = exported_files.map((f) => f.path);
 	const updated = await update_package_json(
 		async (package_json) => {
@@ -85,15 +85,14 @@ export const sync_package_json = async (
 	return updated;
 };
 
-export const load_gro_package_json = (): PackageJson => load_package_json(gro_paths.root);
+export const load_gro_package_json = (): Promise<PackageJson> => load_package_json(gro_paths.root);
 
 // TODO probably make this nullable and make callers handle failures
-const load_package_json_contents = (dir: string): string =>
-	readFileSync(join(dir, PACKAGE_JSON_FILENAME), 'utf8');
+const load_package_json_contents = (dir: string): Promise<string> =>
+	readFile(join(dir, PACKAGE_JSON_FILENAME), 'utf8');
 
-export const write_package_json = (serialized_package_json: string): void => {
-	writeFileSync(join(paths.root, PACKAGE_JSON_FILENAME), serialized_package_json);
-};
+export const write_package_json = (serialized_package_json: string): Promise<void> =>
+	writeFile(join(paths.root, PACKAGE_JSON_FILENAME), serialized_package_json);
 
 export const serialize_package_json = (package_json: PackageJson): string =>
 	JSON.stringify(parse_package_json(PackageJson, package_json), null, 2) + '\n';
@@ -106,7 +105,7 @@ export const update_package_json = async (
 	dir = paths.root,
 	write = true,
 ): Promise<{package_json: PackageJson | null; changed: boolean}> => {
-	const original_contents = load_package_json_contents(dir);
+	const original_contents = await load_package_json_contents(dir);
 	const original = JSON.parse(original_contents);
 	const updated = await update(original);
 	if (updated === null) {
@@ -116,7 +115,7 @@ export const update_package_json = async (
 	if (updated_contents === original_contents) {
 		return {package_json: original, changed: false};
 	}
-	if (write) write_package_json(updated_contents);
+	if (write) await write_package_json(updated_contents);
 	return {package_json: updated, changed: true};
 };
 
@@ -225,10 +224,7 @@ const parse_or_throw_formatted_error = <T extends z.ZodType>(
 	return parsed.data;
 };
 
-export const has_dep = (
-	dep_name: string,
-	package_json: PackageJson = load_package_json(),
-): boolean =>
+export const has_dep = (dep_name: string, package_json: PackageJson): boolean =>
 	!!package_json.devDependencies?.[dep_name] ||
 	!!package_json.dependencies?.[dep_name] ||
 	!!package_json.peerDependencies?.[dep_name];

package/src/lib/publish.task.ts

@@ -1,7 +1,7 @@
 import {spawn} from '@ryanatkn/belt/process.js';
 import {z} from 'zod';
 import {styleText as st} from 'node:util';
-import {existsSync} from 'node:fs';
+import {fs_exists} from '@ryanatkn/belt/fs.js';
 import {
 	GitBranch,
 	GitOrigin,
@@ -85,7 +85,7 @@ export const task: Task<Args> = {
 			log.info(st('green', 'dry run!'));
 		}
 
-		const package_json = load_package_json();
+		const package_json = await load_package_json();
 
 		const has_sveltekit_library_result = await has_sveltekit_library(package_json);
 		if (!has_sveltekit_library_result.ok) {
@@ -94,9 +94,9 @@ export const task: Task<Args> = {
 			);
 		}
 
-		const changelog_exists = existsSync(changelog);
+		const changelog_exists = await fs_exists(changelog);
 
-		const found_changeset_cli = find_cli(changeset_cli);
+		const found_changeset_cli = await find_cli(changeset_cli);
 		if (!found_changeset_cli) {
 			throw new TaskError(
 				'changeset command not found, install @changesets/cli locally or globally',
@@ -178,7 +178,7 @@ export const task: Task<Args> = {
 			// The check above ensures gen is updated.
 			await invoke_task('gen');
 
-			const package_json_after_versioning = load_package_json();
+			const package_json_after_versioning = await load_package_json();
 			version = package_json_after_versioning.version!;
 			if (package_json.version === version) {
 				// The version didn't change.
@@ -217,7 +217,7 @@ export const task: Task<Args> = {
 			);
 		}
 
-		if (!changelog_exists && existsSync(changelog)) {
+		if (!changelog_exists && (await fs_exists(changelog))) {
 			await spawn('git', ['add', changelog]);
 		}
 		await spawn('git', ['commit', '-a', '-m', `publish v${version}`]);

package/src/lib/release.task.ts

@@ -13,7 +13,7 @@ export const task: Task<Args> = {
 	summary: 'publish and deploy',
 	Args,
 	run: async ({invoke_task}) => {
-		const package_json = load_package_json();
+		const package_json = await load_package_json();
 
 		const publish = (await has_sveltekit_library(package_json)).ok;
 		if (publish) {

package/src/lib/resolve.task.ts

@@ -15,7 +15,7 @@ export type Args = z.infer<typeof Args>;
 export const task: Task<Args> = {
 	summary: 'diagnostic that logs resolved filesystem info for the given input paths',
 	Args,
-	run: ({args, config, log}): void => {
+	run: async ({args, config, log}): Promise<void> => {
 		const {_, verbose} = args;
 
 		if (verbose) log.info('raw input paths:', _);
@@ -27,7 +27,7 @@ export const task: Task<Args> = {
 		if (verbose) log.info('task root paths:', task_root_dirs);
 
 		const {resolved_input_paths, possible_paths_by_input_path, unmapped_input_paths} =
-			resolve_input_paths(input_paths, task_root_dirs, TASK_FILE_SUFFIXES);
+			await resolve_input_paths(input_paths, task_root_dirs, TASK_FILE_SUFFIXES);
 		if (verbose) log.info('resolved_input_paths:', resolved_input_paths);
 		if (verbose) log.info('possible_paths_by_input_path:', possible_paths_by_input_path);
 		if (verbose) log.info('unmapped_input_paths:', unmapped_input_paths);

package/src/lib/resolve_specifier.ts

@@ -1,5 +1,5 @@
 import {extname, isAbsolute, join, relative} from 'node:path';
-import {existsSync} from 'node:fs';
+import {fs_exists} from '@ryanatkn/belt/fs.js';
 import type {PathId} from '@ryanatkn/belt/path.js';
 
 import {replace_extension} from './paths.ts';
@@ -26,7 +26,10 @@ export interface ResolvedSpecifier {
  * and infer the correct extension following Vite conventions.
  * If no `.js` file is found for the specifier on the filesystem, it assumes `.ts`.
  */
-export const resolve_specifier = (specifier: string, dir: string): ResolvedSpecifier => {
+export const resolve_specifier = async (
+	specifier: string,
+	dir: string,
+): Promise<ResolvedSpecifier> => {
 	const raw = specifier.endsWith('?raw'); // TODO more robust detection? other values?
 	const final_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
 	const absolute_path = isAbsolute(final_specifier) ? final_specifier : join(dir, final_specifier);
@@ -39,7 +42,7 @@ export const resolve_specifier = (specifier: string, dir: string): ResolvedSpeci
 	const is_js = ext === '.js';
 	const is_ts = ext === '.ts';
 
-	if (!is_js && !is_ts && existsSync(absolute_path)) {
+	if (!is_js && !is_ts && (await fs_exists(absolute_path))) {
 		// unrecognized extension and the file exists
 		mapped_path = absolute_path;
 		path_id = absolute_path;
@@ -52,7 +55,8 @@ export const resolve_specifier = (specifier: string, dir: string): ResolvedSpeci
 		// extensionless, or js that points to ts, or just js
 		const js_id = is_js ? absolute_path : absolute_path + '.js';
 		const ts_id = is_js ? replace_extension(absolute_path, '.ts') : absolute_path + '.ts';
-		if (!existsSync(ts_id) && existsSync(js_id)) {
+		const [ts_exists, js_exists] = await Promise.all([fs_exists(ts_id), fs_exists(js_id)]);
+		if (!ts_exists && js_exists) {
 			mapped_path = js_id;
 			path_id = js_id;
 			namespace = 'sveltekit_local_imports_js';

package/src/lib/run.task.ts

@@ -1,6 +1,6 @@
 import {z} from 'zod';
 import {styleText as st} from 'node:util';
-import {existsSync} from 'node:fs';
+import {fs_exists} from '@ryanatkn/belt/fs.js';
 
 import {TaskError, type Task} from './task.ts';
 import {resolve_gro_module_path, spawn_with_loader} from './gro_helpers.ts';
@@ -39,7 +39,7 @@ export const task: Task<Args> = {
 			return;
 		}
 
-		if (!existsSync(path)) {
+		if (!(await fs_exists(path))) {
 			throw new TaskError('Cannot find file to run at path: ' + path);
 		}