@ryanatkn/gro 0.178.0 → 0.180.0

package/src/lib/build_cache.ts

@@ -1,16 +1,10 @@
-import {
-	existsSync,
-	mkdirSync,
-	readdirSync,
-	readFileSync,
-	rmSync,
-	statSync,
-	writeFileSync,
-} from 'node:fs';
+import {mkdir, readdir, readFile, rm, stat, writeFile} from 'node:fs/promises';
 import {join} from 'node:path';
 import type {Logger} from '@ryanatkn/belt/log.js';
 import {styleText as st} from 'node:util';
 import {git_current_commit_hash} from '@ryanatkn/belt/git.js';
+import {fs_exists} from '@ryanatkn/belt/fs.js';
+import {map_concurrent} from '@ryanatkn/belt/async.js';
 import {z} from 'zod';
 
 import {to_hash} from './hash.ts';
@@ -89,15 +83,15 @@ export const compute_build_cache_key = async (
  * Loads build cache metadata from .gro/ directory.
  * Invalid or corrupted cache files are automatically deleted.
  */
-export const load_build_cache_metadata = (): BuildCacheMetadata | null => {
+export const load_build_cache_metadata = async (): Promise<BuildCacheMetadata | null> => {
 	const metadata_path = join(paths.build, BUILD_CACHE_METADATA_FILENAME);
 
-	if (!existsSync(metadata_path)) {
+	if (!(await fs_exists(metadata_path))) {
 		return null;
 	}
 
 	try {
-		const contents = readFileSync(metadata_path, 'utf-8');
+		const contents = await readFile(metadata_path, 'utf-8');
 		const parsed = JSON.parse(contents);
 
 		// Validate structure with Zod
@@ -107,7 +101,7 @@ export const load_build_cache_metadata = (): BuildCacheMetadata | null => {
 		if (metadata.version !== BUILD_CACHE_VERSION) {
 			// Clean up stale cache with old schema version
 			try {
-				rmSync(metadata_path, {force: true});
+				await rm(metadata_path, {force: true});
 			} catch {
 				// Ignore cleanup errors
 			}
@@ -119,7 +113,7 @@ export const load_build_cache_metadata = (): BuildCacheMetadata | null => {
 		// Clean up corrupted/invalid cache file
 		// (catches JSON.parse, Zod validation, and version errors)
 		try {
-			rmSync(metadata_path, {force: true});
+			await rm(metadata_path, {force: true});
 		} catch {
 			// Ignore cleanup errors
 		}
@@ -131,13 +125,16 @@ export const load_build_cache_metadata = (): BuildCacheMetadata | null => {
  * Saves build cache metadata to .gro/ directory.
  * Errors are logged but don't fail the build (cache is optional).
  */
-export const save_build_cache_metadata = (metadata: BuildCacheMetadata, log?: Logger): void => {
+export const save_build_cache_metadata = async (
+	metadata: BuildCacheMetadata,
+	log?: Logger,
+): Promise<void> => {
 	try {
 		// Ensure .gro directory exists
-		mkdirSync(paths.build, {recursive: true});
+		await mkdir(paths.build, {recursive: true});
 
 		const metadata_path = join(paths.build, BUILD_CACHE_METADATA_FILENAME);
-		writeFileSync(metadata_path, JSON.stringify(metadata, null, '\t'), 'utf-8');
+		await writeFile(metadata_path, JSON.stringify(metadata, null, '\t'), 'utf-8');
 	} catch (error) {
 		// Cache writes are optional - log warning but don't fail the build
 		log?.warn(
@@ -154,33 +151,38 @@ export const save_build_cache_metadata = (metadata: BuildCacheMetadata, log?: Lo
  */
 export const validate_build_cache = async (metadata: BuildCacheMetadata): Promise<boolean> => {
 	// Verify all tracked output files exist and have matching size
+	// Sequential checks with early return for performance
 	for (const output of metadata.outputs) {
-		if (!existsSync(output.path)) {
+		// eslint-disable-next-line no-await-in-loop
+		if (!(await fs_exists(output.path))) {
 			return false;
 		}
 
 		// Fast negative check: size mismatch = definitely invalid
 		// This avoids expensive file reads and hashing for files that have clearly changed
-		const stats = statSync(output.path);
+		// eslint-disable-next-line no-await-in-loop
+		const stats = await stat(output.path);
 		if (stats.size !== output.size) {
 			return false;
 		}
 	}
 
 	// Size matches for all files - now verify content with cryptographic hashing
-	// Hash all files in parallel for performance
-	const hash_promises = metadata.outputs.map(async (output) => {
-		try {
-			const contents = readFileSync(output.path);
-			const actual_hash = await to_hash(contents);
-			return actual_hash === output.hash;
-		} catch {
-			// File deleted/inaccessible between checks = cache invalid
-			return false;
-		}
-	});
-
-	const results = await Promise.all(hash_promises);
+	// Hash files with controlled concurrency (could be 10k+ files)
+	const results = await map_concurrent(
+		metadata.outputs,
+		async (output) => {
+			try {
+				const contents = await readFile(output.path);
+				const actual_hash = await to_hash(contents);
+				return actual_hash === output.hash;
+			} catch {
+				// File deleted/inaccessible between checks = cache invalid
+				return false;
+			}
+		},
+		20,
+	);
 	return results.every((valid) => valid);
 };
 
@@ -198,7 +200,7 @@ export const is_build_cache_valid = async (
 	git_commit?: string | null,
 ): Promise<boolean> => {
 	// Load existing metadata
-	const metadata = load_build_cache_metadata();
+	const metadata = await load_build_cache_metadata();
 	if (!metadata) {
 		log.debug('No build cache metadata found');
 		return false;
@@ -250,8 +252,12 @@ export const collect_build_outputs = async (
 	const files_to_hash: Array<FileEntry> = [];
 
 	// Recursively collect files
-	const collect_files = (dir: string, relative_base: string, dir_prefix: string): void => {
-		const entries = readdirSync(dir, {withFileTypes: true});
+	const collect_files = async (
+		dir: string,
+		relative_base: string,
+		dir_prefix: string,
+	): Promise<void> => {
+		const entries = await readdir(dir, {withFileTypes: true});
 
 		for (const entry of entries) {
 			// Skip metadata file itself
@@ -264,7 +270,8 @@ export const collect_build_outputs = async (
 			const cache_key = join(dir_prefix, relative_path);
 
 			if (entry.isDirectory()) {
-				collect_files(full_path, relative_path, dir_prefix);
+				// eslint-disable-next-line no-await-in-loop
+				await collect_files(full_path, relative_path, dir_prefix);
 			} else if (entry.isFile()) {
 				files_to_hash.push({full_path, cache_key});
 			}
@@ -272,19 +279,22 @@ export const collect_build_outputs = async (
 		}
 	};
 
-	// Collect files from all build directories
+	// Collect files from all build directories sequentially
 	for (const build_dir of build_dirs) {
-		if (!existsSync(build_dir)) {
+		// eslint-disable-next-line no-await-in-loop
+		if (!(await fs_exists(build_dir))) {
 			continue; // Skip non-existent directories
 		}
-		collect_files(build_dir, '', build_dir);
+		// eslint-disable-next-line no-await-in-loop
+		await collect_files(build_dir, '', build_dir);
 	}
 
-	// Hash all files in parallel and collect stats
-	const hash_promises = files_to_hash.map(
+	// Hash files with controlled concurrency and collect stats (could be 10k+ files)
+	return map_concurrent(
+		files_to_hash,
 		async ({full_path, cache_key}): Promise<BuildOutputEntry> => {
-			const stats = statSync(full_path);
-			const contents = readFileSync(full_path);
+			const stats = await stat(full_path);
+			const contents = await readFile(full_path);
 			const hash = await to_hash(contents);
 
 			return {
@@ -296,40 +306,46 @@ export const collect_build_outputs = async (
 				mode: stats.mode,
 			};
 		},
+		20,
 	);
-
-	return await Promise.all(hash_promises);
 };
 
 /**
  * Discovers all build output directories in the current working directory.
  * Returns an array of directory names that exist: build/, dist/, dist_*
  */
-export const discover_build_output_dirs = (): Array<string> => {
+export const discover_build_output_dirs = async (): Promise<Array<string>> => {
 	const build_dirs: Array<string> = [];
 
-	// Check for SvelteKit app output (build/)
-	if (existsSync(SVELTEKIT_BUILD_DIRNAME)) {
+	// Check for SvelteKit app output (build/) and library output (dist/) in parallel
+	const [build_exists, dist_exists] = await Promise.all([
+		fs_exists(SVELTEKIT_BUILD_DIRNAME),
+		fs_exists(SVELTEKIT_DIST_DIRNAME),
+	]);
+
+	if (build_exists) {
 		build_dirs.push(SVELTEKIT_BUILD_DIRNAME);
 	}
-
-	// Check for SvelteKit library output (dist/)
-	if (existsSync(SVELTEKIT_DIST_DIRNAME)) {
+	if (dist_exists) {
 		build_dirs.push(SVELTEKIT_DIST_DIRNAME);
 	}
 
 	// Check for server and other plugin outputs (dist_*)
-	const root_entries = readdirSync('.');
-	const dist_dirs = root_entries.filter((p) => {
-		if (!p.startsWith(GRO_DIST_PREFIX)) return false;
-		try {
-			return statSync(p).isDirectory();
-		} catch {
-			// File was deleted/moved during iteration - skip it
-			return false;
-		}
-	});
-	build_dirs.push(...dist_dirs);
+	const root_entries = await readdir('.');
+	const dist_dir_checks = await Promise.all(
+		root_entries
+			.filter((p) => p.startsWith(GRO_DIST_PREFIX))
+			.map(async (p) => {
+				try {
+					const s = await stat(p);
+					return s.isDirectory() ? p : null;
+				} catch {
+					// File was deleted/moved during iteration - skip it
+					return null;
+				}
+			}),
+	);
+	build_dirs.push(...dist_dir_checks.filter((p): p is string => p !== null));
 
 	return build_dirs;
 };
@@ -350,7 +366,7 @@ export const create_build_cache_metadata = async (
 	build_dirs?: Array<string>,
 ): Promise<BuildCacheMetadata> => {
 	const cache_key = await compute_build_cache_key(config, log, git_commit);
-	const dirs = build_dirs ?? discover_build_output_dirs();
+	const dirs = build_dirs ?? (await discover_build_output_dirs());
 	const outputs = await collect_build_outputs(dirs);
 
 	return {

package/src/lib/changeset.task.ts

@@ -2,9 +2,9 @@ import {z} from 'zod';
 import {spawn} from '@ryanatkn/belt/process.js';
 import {styleText as st} from 'node:util';
 import type {WrittenConfig} from '@changesets/types';
-import {readFile, writeFile} from 'node:fs/promises';
+import {readdir, readFile, writeFile} from 'node:fs/promises';
 import {join} from 'node:path';
-import {existsSync, readdirSync} from 'node:fs';
+import {fs_exists} from '@ryanatkn/belt/fs.js';
 import {
 	GitOrigin,
 	git_check_fully_staged_workspace,
@@ -92,14 +92,14 @@ export const task: Task<Args> = {
 
 		const bump: ChangesetBump = minor ? 'minor' : major ? 'major' : 'patch';
 
-		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',
 			);
 		}
 
-		const package_json = load_package_json();
+		const package_json = await load_package_json();
 
 		const has_sveltekit_library_result = await has_sveltekit_library(package_json, svelte_config);
 		if (!has_sveltekit_library_result.ok) {
@@ -110,7 +110,7 @@ export const task: Task<Args> = {
 
 		const path = join(dir, 'config.json');
 
-		const inited = existsSync(path);
+		const inited = await fs_exists(path);
 
 		if (!inited) {
 			await spawn_cli(found_changeset_cli, ['init'], log);
@@ -143,7 +143,7 @@ export const task: Task<Args> = {
 
 		if (message) {
 			// TODO see the helper below, simplify this to CLI flags when support is added to Changesets
-			const changeset_adder = create_changeset_adder(package_json.name, dir, message, bump);
+			const changeset_adder = await create_changeset_adder(package_json.name, dir, message, bump);
 			await spawn_cli(found_changeset_cli, ['add', '--empty'], log);
 			await changeset_adder();
 			if (!(await git_check_fully_staged_workspace())) {
@@ -161,15 +161,15 @@ export const task: Task<Args> = {
  * TODO ideally this wouldn't exist and we'd use CLI flags, but they doesn't exist yet
  * @see https://github.com/changesets/changesets/pull/1121
  */
-const create_changeset_adder = (
+const create_changeset_adder = async (
 	repo_name: string,
 	dir: string,
 	message: string,
 	bump: ChangesetBump,
-) => {
-	const filenames_before = readdirSync(dir);
+): Promise<() => Promise<void>> => {
+	const filenames_before = await readdir(dir);
 	return async () => {
-		const filenames_after = readdirSync(dir);
+		const filenames_after = await readdir(dir);
 		const filenames_added = filenames_after.filter((p) => !filenames_before.includes(p));
 		if (!filenames_added.length) {
 			throw Error('expected to find a new changeset file');

package/src/lib/clean_fs.ts

@@ -1,5 +1,5 @@
-import {rm} from 'node:fs/promises';
-import {readdirSync, type RmOptions} from 'node:fs';
+import {readdir, rm} from 'node:fs/promises';
+import type {RmOptions} from 'node:fs';
 
 import {paths} from './paths.ts';
 import {
@@ -35,8 +35,8 @@ export const clean_fs = async (
 		promises.push(rm(paths.build_dev, rm_options));
 	}
 	if (build || build_dist) {
-		const paths = readdirSync('.').filter((p) => p.startsWith(GRO_DIST_PREFIX));
-		for (const path of paths) {
+		const dir_paths = (await readdir('.')).filter((p) => p.startsWith(GRO_DIST_PREFIX));
+		for (const path of dir_paths) {
 			promises.push(rm(path, rm_options));
 		}
 	}

package/src/lib/cli.ts

@@ -1,12 +1,13 @@
-import {spawnSync, type SpawnOptions} from 'node:child_process';
+import type {SpawnOptions} from 'node:child_process';
 import {
 	spawn,
+	spawn_out,
 	spawn_process,
 	type SpawnResult,
 	type SpawnedProcess,
 } from '@ryanatkn/belt/process.js';
 import {join} from 'node:path';
-import {existsSync} from 'node:fs';
+import {fs_exists} from '@ryanatkn/belt/fs.js';
 import {fileURLToPath, type URL} from 'node:url';
 import type {Logger} from '@ryanatkn/belt/log.js';
 import type {PathId} from '@ryanatkn/belt/path.js';
@@ -24,18 +25,18 @@ export type Cli =
  * Searches the filesystem for the CLI `name`, first local to the cwd and then globally.
  * @returns `null` if not found locally or globally
  */
-export const find_cli = (
+export const find_cli = async (
 	name: string,
 	cwd: string | URL = process.cwd(),
 	options?: SpawnOptions,
-): Cli | null => {
+): Promise<Cli | null> => {
 	const final_cwd = typeof cwd === 'string' ? cwd : fileURLToPath(cwd);
 	const local_id = join(final_cwd, NODE_MODULES_DIRNAME, `.bin/${name}`);
-	if (existsSync(local_id)) {
+	if (await fs_exists(local_id)) {
 		return {name, id: local_id, kind: 'local'};
 	}
-	const {stdout} = spawnSync('which', [name], options);
-	const global_id = stdout.toString().trim();
+	const {stdout} = await spawn_out('which', [name], options);
+	const global_id = stdout?.trim();
 	if (!global_id) return null;
 	return {name, id: global_id, kind: 'global'};
 };
@@ -51,7 +52,7 @@ export const spawn_cli = async (
 	log?: Logger,
 	options?: SpawnOptions,
 ): Promise<SpawnResult | undefined> => {
-	const cli = resolve_cli(name_or_cli, args, options?.cwd, log, options);
+	const cli = await resolve_cli(name_or_cli, args, options?.cwd, log, options);
 	if (!cli) return;
 	return spawn(cli.id, args, options);
 };
@@ -61,27 +62,27 @@ export const spawn_cli = async (
  * If a string is provided for `name_or_cli`, it checks first local to the cwd and then globally.
  * @returns `undefined` if no CLI is found, or the spawn result
  */
-export const spawn_cli_process = (
+export const spawn_cli_process = async (
 	name_or_cli: string | Cli,
 	args: Array<string> = [],
 	log?: Logger,
 	options?: SpawnOptions,
-): SpawnedProcess | undefined => {
-	const cli = resolve_cli(name_or_cli, args, options?.cwd, log, options);
+): Promise<SpawnedProcess | undefined> => {
+	const cli = await resolve_cli(name_or_cli, args, options?.cwd, log, options);
 	if (!cli) return;
 	return spawn_process(cli.id, args, options);
 };
 
-export const resolve_cli = (
+export const resolve_cli = async (
 	name_or_cli: string | Cli,
 	args: Array<string> = [],
 	cwd: string | URL | undefined,
 	log?: Logger,
 	options?: SpawnOptions,
-): Cli | undefined => {
+): Promise<Cli | undefined> => {
 	let final_cli;
 	if (typeof name_or_cli === 'string') {
-		const found = find_cli(name_or_cli, cwd, options);
+		const found = await find_cli(name_or_cli, cwd, options);
 		if (!found) return;
 		final_cli = found;
 	} else {

package/src/lib/deploy.task.ts

@@ -2,9 +2,9 @@ import {spawn} from '@ryanatkn/belt/process.js';
 import {print_error} from '@ryanatkn/belt/print.js';
 import {styleText as st} from 'node:util';
 import {z} from 'zod';
-import {cp, mkdir, rm} from 'node:fs/promises';
+import {cp, mkdir, readdir, rm} from 'node:fs/promises';
 import {join, resolve} from 'node:path';
-import {existsSync, readdirSync} from 'node:fs';
+import {fs_exists, fs_empty_dir} from '@ryanatkn/belt/fs.js';
 import {
 	git_check_clean_workspace,
 	git_checkout,
@@ -21,7 +21,6 @@ import {
 	git_clone_locally,
 	git_current_branch_name,
 } from '@ryanatkn/belt/git.js';
-import {fs_empty_dir} from '@ryanatkn/belt/fs.js';
 
 import {TaskError, type Task} from './task.ts';
 import {print_path} from './paths.ts';
@@ -72,6 +71,19 @@ export const Args = z.strictObject({
 		.default(false),
 	build: z.boolean().meta({description: 'dual of no-build'}).default(true),
 	'no-build': z.boolean().meta({description: 'opt out of building'}).default(false),
+	sync: z.boolean().meta({description: 'dual of no-sync'}).default(true),
+	'no-sync': z.boolean().meta({description: 'opt out of gro sync in build'}).default(false),
+	gen: z.boolean().meta({description: 'dual of no-gen'}).default(true),
+	'no-gen': z.boolean().meta({description: 'opt out of gro gen in build'}).default(false),
+	install: z.boolean().meta({description: 'dual of no-install'}).default(true),
+	'no-install': z
+		.boolean()
+		.meta({description: 'opt out of installing packages before building'})
+		.default(false),
+	force_build: z
+		.boolean()
+		.meta({description: 'force a fresh build, ignoring the cache'})
+		.default(false),
 	pull: z.boolean().meta({description: 'dual of no-pull'}).default(true),
 	'no-pull': z.boolean().meta({description: 'opt out of git pull'}).default(false),
 });
@@ -93,6 +105,10 @@ export const task: Task<Args> = {
 			dangerous,
 			reset,
 			build,
+			sync,
+			gen,
+			install,
+			force_build,
 			pull,
 		} = args;
 
@@ -154,7 +170,7 @@ export const task: Task<Args> = {
 			// First, check if the deploy dir exists, and if so, attempt to sync it.
 			// If anything goes wrong, delete the directory and we'll initialize it
 			// using the same code path as if it didn't exist in the first place.
-			if (existsSync(resolved_deploy_dir)) {
+			if (await fs_exists(resolved_deploy_dir)) {
 				if (target !== (await git_current_branch_name(target_spawn_options))) {
 					// We're in a bad state because the target branch has changed,
 					// so delete the directory and continue as if it wasn't there.
@@ -175,7 +191,7 @@ export const task: Task<Args> = {
 
 			// Second, initialize the deploy dir if needed.
 			// It may not exist, or it may have been deleted after failing to sync above.
-			if (!existsSync(resolved_deploy_dir)) {
+			if (!(await fs_exists(resolved_deploy_dir))) {
 				const local_deploy_branch_exists = await git_local_branch_exists(target);
 				await git_fetch(origin, ('+' + target + ':' + target) as GitBranch); // fetch+merge and allow non-fastforward updates with the +
 				await git_clone_locally(origin, target, dir, resolved_deploy_dir);
@@ -193,7 +209,7 @@ export const task: Task<Args> = {
 			// Remote target branch does not exist, so start from scratch
 
 			// Delete the deploy dir and recreate it
-			if (existsSync(resolved_deploy_dir)) {
+			if (await fs_exists(resolved_deploy_dir)) {
 				await rm(resolved_deploy_dir, {recursive: true});
 				await mkdir(resolved_deploy_dir, {recursive: true});
 			}
@@ -222,14 +238,14 @@ export const task: Task<Args> = {
 		// Build
 		try {
 			if (build) {
-				await invoke_task('build');
+				await invoke_task('build', {sync, gen, install, force_build});
 			}
-		} catch (err) {
+		} catch (error) {
 			log.error(
 				st('red', 'build failed'),
 				'but',
 				st('green', 'no changes were made to git'),
-				print_error(err),
+				print_error(error),
 			);
 			if (dry) {
 				log.info(st('red', 'dry deploy failed'));
@@ -238,13 +254,14 @@ export const task: Task<Args> = {
 		}
 
 		// Verify build output exists
-		if (!existsSync(build_dir)) {
+		if (!(await fs_exists(build_dir))) {
 			throw new TaskError(`Directory to deploy does not exist after building: ${build_dir}`);
 		}
 
 		// Copy the build
+		const build_entries = await readdir(build_dir);
 		await Promise.all(
-			readdirSync(build_dir).map((path) =>
+			build_entries.map((path) =>
 				cp(join(build_dir, path), join(resolved_deploy_dir, path), {recursive: true}),
 			),
 		);
@@ -260,8 +277,8 @@ export const task: Task<Args> = {
 			await spawn('git', ['add', '.', '-f'], target_spawn_options);
 			await spawn('git', ['commit', '-m', 'deployment'], target_spawn_options);
 			await spawn('git', ['push', origin, target, '-f'], target_spawn_options); // force push because we may be resetting the branch, see the checks above to make this safer
-		} catch (err) {
-			log.error(st('red', 'updating git failed:'), print_error(err));
+		} catch (error) {
+			log.error(st('red', 'updating git failed:'), print_error(error));
 			throw new TaskError(`Deploy failed in a bad state: built but not pushed, see error above.`);
 		}
 

package/src/lib/esbuild_plugin_external_worker.ts

@@ -84,7 +84,7 @@ export const esbuild_plugin_external_worker = ({
 		};
 
 		build.onResolve({filter: /\.worker(|\.js|\.ts)$/}, async ({path, resolveDir}) => {
-			const parsed = resolve_specifier(path, resolveDir);
+			const parsed = await resolve_specifier(path, resolveDir);
 			const {specifier, path_id, namespace} = parsed;
 			const build_result = await build_worker(path_id);
 			if (log) print_build_result(log, build_result);

package/src/lib/esbuild_plugin_svelte.ts

@@ -71,8 +71,8 @@ export const esbuild_plugin_svelte = (options: EsbuildPluginSvelteOptions): esbu
 						contents,
 						warnings: warnings.map((w) => convert_svelte_message_to_esbuild(filename, source, w)),
 					};
-				} catch (err) {
-					return {errors: [convert_svelte_message_to_esbuild(path, source, err)]};
+				} catch (error) {
+					return {errors: [convert_svelte_message_to_esbuild(path, source, error)]};
 				}
 			});
 
@@ -90,8 +90,8 @@ export const esbuild_plugin_svelte = (options: EsbuildPluginSvelteOptions): esbu
 						contents,
 						warnings: warnings.map((w) => convert_svelte_message_to_esbuild(filename, source, w)),
 					};
-				} catch (err) {
-					return {errors: [convert_svelte_message_to_esbuild(path, source, err)]};
+				} catch (error) {
+					return {errors: [convert_svelte_message_to_esbuild(path, source, error)]};
 				}
 			});
 		},

package/src/lib/esbuild_plugin_sveltekit_local_imports.ts

@@ -13,10 +13,10 @@ import {EVERYTHING_MATCHER} from './constants.ts';
 export const esbuild_plugin_sveltekit_local_imports = (): esbuild.Plugin => ({
 	name: 'sveltekit_local_imports',
 	setup: (build) => {
-		build.onResolve({filter: /^(\/|\.)/}, (args) => {
+		build.onResolve({filter: /^(\/|\.)/}, async (args) => {
 			const {path, importer} = args;
 			if (!importer) return {path};
-			const {path_id, namespace} = resolve_specifier(path, dirname(importer));
+			const {path_id, namespace} = await resolve_specifier(path, dirname(importer));
 			return {path: path_id, namespace}; // `namespace` may be `undefined`, but esbuild needs the absolute path for json etc
 		});
 		build.onLoad(