@ryanatkn/gro 0.179.0 → 0.181.0

package/src/lib/build.task.ts

@@ -1,8 +1,9 @@
 import {z} from 'zod';
 import {styleText as st} from 'node:util';
-import {git_check_clean_workspace, git_current_commit_hash} from '@ryanatkn/belt/git.js';
-import {rmSync, existsSync} from 'node:fs';
+import {git_check_clean_workspace, git_current_commit_hash} from '@fuzdev/fuz_util/git.js';
+import {rm} from 'node:fs/promises';
 import {join} from 'node:path';
+import {fs_exists} from '@fuzdev/fuz_util/fs.js';
 
 import {TaskError, type Task} from './task.ts';
 import {Plugins} from './plugin.ts';
@@ -19,6 +20,8 @@ import {paths} from './paths.ts';
 export const Args = z.strictObject({
 	sync: z.boolean().meta({description: 'dual of no-sync'}).default(true),
 	'no-sync': z.boolean().meta({description: 'opt out of gro sync'}).default(false),
+	gen: z.boolean().meta({description: 'dual of no-gen'}).default(true),
+	'no-gen': z.boolean().meta({description: 'opt out of gro gen'}).default(false),
 	install: z.boolean().meta({description: 'dual of no-install'}).default(true),
 	'no-install': z // convenience, same as `gro build -- gro sync --no-install` but the latter takes precedence
 		.boolean()
@@ -49,11 +52,15 @@ export const task: Task<Args> = {
 	Args,
 	run: async (ctx): Promise<void> => {
 		const {args, invoke_task, log, config} = ctx;
-		const {sync, install, force_build} = args;
+		const {sync, gen, install, force_build} = args;
 
 		if (sync || install) {
 			if (!sync) log.warn('sync is false but install is true, so ignoring the sync option');
-			await invoke_task('sync', {install});
+			await invoke_task('sync', {install, gen: false});
+		}
+
+		if (gen) {
+			await invoke_task('gen');
 		}
 
 		// Batch git calls upfront for performance (spawning processes is expensive)
@@ -81,15 +88,13 @@ export const task: Task<Args> = {
 			// Rationale: Uncommitted changes could be reverted, leaving cached outputs from reverted code.
 			// This conservative approach prioritizes safety over convenience during development.
 			const cache_path = join(paths.build, 'build.json');
-			if (existsSync(cache_path)) {
-				rmSync(cache_path, {force: true});
+			if (await fs_exists(cache_path)) {
+				await rm(cache_path, {force: true});
 			}
 
 			// Delete all build output directories
-			build_dirs = discover_build_output_dirs();
-			for (const dir of build_dirs) {
-				rmSync(dir, {recursive: true, force: true});
-			}
+			build_dirs = await discover_build_output_dirs();
+			await Promise.all(build_dirs.map((dir) => rm(dir, {recursive: true, force: true})));
 
 			log.info(st('yellow', 'workspace has uncommitted changes - skipping build cache'));
 			// Skip clean_fs - already manually cleaned cache and all build outputs above
@@ -138,7 +143,7 @@ export const task: Task<Args> = {
 			} else {
 				// Commit is stable - safe to save cache
 				const metadata = await create_build_cache_metadata(config, log, initial_commit, build_dirs);
-				save_build_cache_metadata(metadata, log);
+				await save_build_cache_metadata(metadata, log);
 				log.debug('Build cache metadata saved');
 			}
 		}

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 type {Logger} from '@fuzdev/fuz_util/log.js';
 import {styleText as st} from 'node:util';
-import {git_current_commit_hash} from '@ryanatkn/belt/git.js';
+import {git_current_commit_hash} from '@fuzdev/fuz_util/git.js';
+import {fs_exists} from '@fuzdev/fuz_util/fs.js';
+import {map_concurrent} from '@fuzdev/fuz_util/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/changelog.ts

@@ -1,7 +1,7 @@
 import {readFile, writeFile} from 'node:fs/promises';
 import {z} from 'zod';
-import type {Logger} from '@ryanatkn/belt/log.js';
-import type {FetchValueCache} from '@ryanatkn/belt/fetch.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {FetchValueCache} from '@fuzdev/fuz_util/fetch.js';
 
 import {github_fetch_commit_prs} from './github.ts';
 

package/src/lib/changeset.task.ts

@@ -1,15 +1,15 @@
 import {z} from 'zod';
-import {spawn} from '@ryanatkn/belt/process.js';
+import {spawn} from '@fuzdev/fuz_util/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 '@fuzdev/fuz_util/fs.js';
 import {
 	GitOrigin,
 	git_check_fully_staged_workspace,
 	git_push_to_create,
-} from '@ryanatkn/belt/git.js';
+} from '@fuzdev/fuz_util/git.js';
 
 import {TaskError, type Task} from './task.ts';
 import {find_cli, spawn_cli} from './cli.ts';
@@ -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/check.task.ts

@@ -1,7 +1,7 @@
 import {z} from 'zod';
-import {spawn} from '@ryanatkn/belt/process.js';
+import {spawn} from '@fuzdev/fuz_util/process.js';
 import {styleText as st} from 'node:util';
-import {git_check_clean_workspace} from '@ryanatkn/belt/git.js';
+import {git_check_clean_workspace} from '@fuzdev/fuz_util/git.js';
 
 import {TaskError, type Task} from './task.ts';
 import {sync_package_json} from './package_json.ts';

package/src/lib/child_process_logging.ts

@@ -1,5 +1,5 @@
 import type {ChildProcess} from 'node:child_process';
-import {strip_end} from '@ryanatkn/belt/string.js';
+import {strip_end} from '@fuzdev/fuz_util/string.js';
 
 /**
  * Maps child process output through a transform function.

package/src/lib/clean.task.ts

@@ -1,6 +1,6 @@
-import {spawn} from '@ryanatkn/belt/process.js';
+import {spawn} from '@fuzdev/fuz_util/process.js';
 import {z} from 'zod';
-import {GitOrigin} from '@ryanatkn/belt/git.js';
+import {GitOrigin} from '@fuzdev/fuz_util/git.js';
 
 import type {Task} from './task.ts';
 import {clean_fs} from './clean_fs.ts';

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,15 +1,16 @@
-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';
+} from '@fuzdev/fuz_util/process.js';
 import {join} from 'node:path';
-import {existsSync} from 'node:fs';
+import {fs_exists} from '@fuzdev/fuz_util/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';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {PathId} from '@fuzdev/fuz_util/path.js';
 
 import {NODE_MODULES_DIRNAME} from './constants.ts';
 import {print_command_args} from './args.ts';
@@ -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/commit.task.ts

@@ -1,6 +1,6 @@
-import {spawn} from '@ryanatkn/belt/process.js';
+import {spawn} from '@fuzdev/fuz_util/process.js';
 import {z} from 'zod';
-import {GitOrigin, git_current_branch_name, git_push} from '@ryanatkn/belt/git.js';
+import {GitOrigin, git_current_branch_name, git_push} from '@fuzdev/fuz_util/git.js';
 
 import type {Task} from './task.ts';