@ryanatkn/gro 0.176.0 → 0.177.1

package/src/lib/gen.ts

@@ -5,73 +5,73 @@ import type {Result} from '@ryanatkn/belt/result.js';
 import type {Timings} from '@ryanatkn/belt/timings.js';
 import {styleText as st} from 'node:util';
 import {existsSync} from 'node:fs';
-import type {Path_Id} from '@ryanatkn/belt/path.js';
+import type {PathId} from '@ryanatkn/belt/path.js';
 
 import {print_path} from './paths.ts';
-import type {Gro_Config} from './gro_config.ts';
-import type {Parsed_Svelte_Config} from './svelte_config.ts';
-import {load_modules, type Load_Modules_Failure, type Module_Meta} from './modules.ts';
+import type {GroConfig} from './gro_config.ts';
+import type {ParsedSvelteConfig} from './svelte_config.ts';
+import {load_modules, type LoadModulesFailure, type ModuleMeta} from './modules.ts';
 import {
-	Input_Path,
+	InputPath,
 	resolve_input_files,
 	resolve_input_paths,
-	type Resolved_Input_File,
-	type Resolved_Input_Path,
+	type ResolvedInputFile,
+	type ResolvedInputPath,
 } from './input_path.ts';
 import {search_fs} from './search_fs.ts';
 import type {Filer} from './filer.ts';
-import type {Invoke_Task} from './task.ts';
+import type {InvokeTask} from './task.ts';
 
 export const GEN_FILE_PATTERN_TEXT = 'gen';
 export const GEN_FILE_PATTERN = '.' + GEN_FILE_PATTERN_TEXT + '.';
 
 export const is_gen_path = (path: string): boolean => path.includes(GEN_FILE_PATTERN);
 
-export interface Gen_Result {
-	origin_id: Path_Id;
-	files: Array<Gen_File>;
+export interface GenResult {
+	origin_id: PathId;
+	files: Array<GenFile>;
 }
-export interface Gen_File {
-	id: Path_Id;
+export interface GenFile {
+	id: PathId;
 	content: string;
-	origin_id: Path_Id;
+	origin_id: PathId;
 	format: boolean;
 }
 
-export type Gen_Dependencies = 'all' | Gen_Dependencies_Config | Gen_Dependencies_Resolver;
+export type GenDependencies = 'all' | GenDependenciesConfig | GenDependenciesResolver;
 
-export interface Gen_Dependencies_Config {
+export interface GenDependenciesConfig {
 	patterns?: Array<RegExp>;
-	files?: Array<Path_Id>;
+	files?: Array<PathId>;
 }
 
-export type Gen_Dependencies_Resolver = (
-	ctx: Gen_Context,
-) => Gen_Dependencies_Config | 'all' | null | Promise<Gen_Dependencies_Config | 'all' | null>;
+export type GenDependenciesResolver = (
+	ctx: GenContext,
+) => GenDependenciesConfig | 'all' | null | Promise<GenDependenciesConfig | 'all' | null>;
 
-export type Gen = Gen_Function | Gen_Config;
+export type Gen = GenFunction | GenConfig;
 
-export type Gen_Function = (ctx: Gen_Context) => Raw_Gen_Result | Promise<Raw_Gen_Result>;
+export type GenFunction = (ctx: GenContext) => RawGenResult | Promise<RawGenResult>;
 
-// TODO add a Gen_Config_Raw variant and change `normalize_gen_config` to `gen_cook_config`
-export interface Gen_Config {
-	generate: Gen_Function;
-	dependencies?: Gen_Dependencies;
+// TODO add a GenConfigRaw variant and change `normalize_gen_config` to `gen_cook_config`
+export interface GenConfig {
+	generate: GenFunction;
+	dependencies?: GenDependencies;
 	// TODO think about what could be added
 	// cache?: boolean;
 }
 
-export interface Gen_Context {
-	config: Gro_Config;
-	svelte_config: Parsed_Svelte_Config;
+export interface GenContext {
+	config: GroConfig;
+	svelte_config: ParsedSvelteConfig;
 	filer: Filer;
 	log: Logger;
 	timings: Timings;
-	invoke_task: Invoke_Task;
+	invoke_task: InvokeTask;
 	/**
 	 * Same as `import.meta.url` but in path form.
 	 */
-	origin_id: Path_Id;
+	origin_id: PathId;
 	/**
 	 * The `origin_id` relative to the root dir.
 	 */
@@ -81,12 +81,12 @@ export interface Gen_Context {
 	 * Only available when resolving dependencies dynamically.
 	 * `undefined` during actual generation.
 	 */
-	changed_file_id: Path_Id | undefined;
+	changed_file_id: PathId | undefined;
 }
 
 // TODO consider other return data - metadata? effects? non-file build artifacts?
-export type Raw_Gen_Result = string | Raw_Gen_File | null | Array<Raw_Gen_Result>;
-export interface Raw_Gen_File {
+export type RawGenResult = string | RawGenFile | null | Array<RawGenResult>;
+export interface RawGenFile {
 	content: string;
 	// Defaults to file name without the `.gen`, and can be a relative path.
 	// TODO maybe support a transform pattern or callback fn? like '[stem].thing.[ext]'
@@ -94,37 +94,37 @@ export interface Raw_Gen_File {
 	format?: boolean; // defaults to `true`
 }
 
-export interface Gen_Results {
-	results: Array<Genfile_Module_Result>;
-	successes: Array<Genfile_Module_Result_Success>;
-	failures: Array<Genfile_Module_Result_Failure>;
+export interface GenResults {
+	results: Array<GenfileModuleResult>;
+	successes: Array<GenfileModuleResultSuccess>;
+	failures: Array<GenfileModuleResultFailure>;
 	input_count: number;
 	output_count: number;
 	elapsed: number;
 }
-export type Genfile_Module_Result = Genfile_Module_Result_Success | Genfile_Module_Result_Failure;
-export interface Genfile_Module_Result_Success {
+export type GenfileModuleResult = GenfileModuleResultSuccess | GenfileModuleResultFailure;
+export interface GenfileModuleResultSuccess {
 	ok: true;
-	id: Path_Id;
-	files: Array<Gen_File>;
+	id: PathId;
+	files: Array<GenFile>;
 	elapsed: number;
 }
-export interface Genfile_Module_Result_Failure {
+export interface GenfileModuleResultFailure {
 	ok: false;
-	id: Path_Id;
+	id: PathId;
 	reason: string;
 	error: Error;
 	elapsed: number;
 }
 
-export const to_gen_result = (origin_id: Path_Id, raw_result: Raw_Gen_Result): Gen_Result => {
+export const to_gen_result = (origin_id: PathId, raw_result: RawGenResult): GenResult => {
 	return {
 		origin_id,
 		files: to_gen_files(origin_id, raw_result),
 	};
 };
 
-const to_gen_files = (origin_id: Path_Id, raw_result: Raw_Gen_Result): Array<Gen_File> => {
+const to_gen_files = (origin_id: PathId, raw_result: RawGenResult): Array<GenFile> => {
 	if (raw_result === null) {
 		return [];
 	} else if (typeof raw_result === 'string') {
@@ -137,13 +137,13 @@ const to_gen_files = (origin_id: Path_Id, raw_result: Raw_Gen_Result): Array<Gen
 	return [to_gen_file(origin_id, raw_result)];
 };
 
-const to_gen_file = (origin_id: Path_Id, raw_gen_file: Raw_Gen_File): Gen_File => {
+const to_gen_file = (origin_id: PathId, raw_gen_file: RawGenFile): GenFile => {
 	const {content, filename, format = true} = raw_gen_file;
 	const id = to_output_file_id(origin_id, filename);
 	return {id, content, origin_id, format};
 };
 
-const to_output_file_id = (origin_id: Path_Id, raw_file_name: string | undefined): string => {
+const to_output_file_id = (origin_id: PathId, raw_file_name: string | undefined): string => {
 	if (raw_file_name === '') {
 		throw Error(`Output file name cannot be an empty string`);
 	}
@@ -186,7 +186,7 @@ export const to_output_file_name = (filename: string): string => {
 	return final_parts.join('.');
 };
 
-const validate_gen_files = (files: Array<Gen_File>) => {
+const validate_gen_files = (files: Array<GenFile>) => {
 	const ids = new Set();
 	for (const file of files) {
 		if (ids.has(file.id)) {
@@ -196,30 +196,30 @@ const validate_gen_files = (files: Array<Gen_File>) => {
 	}
 };
 
-export type Analyzed_Gen_Result =
+export type AnalyzedGenResult =
 	| {
-			file: Gen_File;
+			file: GenFile;
 			existing_content: string;
 			is_new: false;
 			has_changed: boolean;
 	  }
 	| {
-			file: Gen_File;
+			file: GenFile;
 			existing_content: null;
 			is_new: true;
 			has_changed: true;
 	  };
 
 export const analyze_gen_results = (
-	gen_results: Gen_Results,
-): Promise<Array<Analyzed_Gen_Result>> =>
+	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_result = async (file: Gen_File): Promise<Analyzed_Gen_Result> => {
+export const analyze_gen_result = async (file: GenFile): Promise<AnalyzedGenResult> => {
 	if (!existsSync(file.id)) {
 		return {
 			file,
@@ -238,8 +238,8 @@ export const analyze_gen_result = async (file: Gen_File): Promise<Analyzed_Gen_R
 };
 
 export const write_gen_results = async (
-	gen_results: Gen_Results,
-	analyzed_gen_results: Array<Analyzed_Gen_Result>,
+	gen_results: GenResults,
+	analyzed_gen_results: Array<AnalyzedGenResult>,
 	log: Logger,
 ): Promise<void> => {
 	await Promise.all(
@@ -265,26 +265,26 @@ export const write_gen_results = async (
 	);
 };
 
-export interface Found_Genfiles {
-	resolved_input_files: Array<Resolved_Input_File>;
-	resolved_input_files_by_root_dir: Map<Path_Id, Array<Resolved_Input_File>>;
-	resolved_input_paths: Array<Resolved_Input_Path>;
+export interface FoundGenfiles {
+	resolved_input_files: Array<ResolvedInputFile>;
+	resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+	resolved_input_paths: Array<ResolvedInputPath>;
 }
 
-export type Find_Genfiles_Result = Result<{value: Found_Genfiles}, Find_Genfiles_Failure>;
-export type Find_Genfiles_Failure =
+export type FindGenfilesResult = Result<{value: FoundGenfiles}, FindGenfilesFailure>;
+export type FindGenfilesFailure =
 	| {
 			type: 'unmapped_input_paths';
-			unmapped_input_paths: Array<Input_Path>;
-			resolved_input_paths: Array<Resolved_Input_Path>;
+			unmapped_input_paths: Array<InputPath>;
+			resolved_input_paths: Array<ResolvedInputPath>;
 			reasons: Array<string>;
 	  }
 	| {
 			type: 'input_directories_with_no_files';
-			input_directories_with_no_files: Array<Input_Path>;
-			resolved_input_files: Array<Resolved_Input_File>;
-			resolved_input_files_by_root_dir: Map<Path_Id, Array<Resolved_Input_File>>;
-			resolved_input_paths: Array<Resolved_Input_Path>;
+			input_directories_with_no_files: Array<InputPath>;
+			resolved_input_files: Array<ResolvedInputFile>;
+			resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+			resolved_input_paths: Array<ResolvedInputPath>;
 			reasons: Array<string>;
 	  };
 
@@ -292,11 +292,11 @@ export type Find_Genfiles_Failure =
  * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
  */
 export const find_genfiles = (
-	input_paths: Array<Input_Path>,
-	root_dirs: Array<Path_Id>,
-	config: Gro_Config,
+	input_paths: Array<InputPath>,
+	root_dirs: Array<PathId>,
+	config: GroConfig,
 	timings?: Timings,
-): Find_Genfiles_Result => {
+): FindGenfilesResult => {
 	const extensions: Array<string> = [GEN_FILE_PATTERN];
 
 	// Check which extension variation works - if it's a directory, prefer others first!
@@ -357,28 +357,28 @@ export const find_genfiles = (
 	};
 };
 
-export interface Genfile_Module {
+export interface GenfileModule {
 	gen: Gen;
 }
 
-export type Genfile_Module_Meta = Module_Meta<Genfile_Module>;
+export type GenfileModuleMeta = ModuleMeta<GenfileModule>;
 
-export interface Loaded_Genfiles {
-	modules: Array<Genfile_Module_Meta>;
-	found_genfiles: Found_Genfiles;
+export interface LoadedGenfiles {
+	modules: Array<GenfileModuleMeta>;
+	found_genfiles: FoundGenfiles;
 }
 
-export type Load_Genfiles_Result = Result<{value: Loaded_Genfiles}, Load_Genfiles_Failure>;
-export type Load_Genfiles_Failure = Load_Modules_Failure<Genfile_Module_Meta>;
+export type LoadGenfilesResult = Result<{value: LoadedGenfiles}, LoadGenfilesFailure>;
+export type LoadGenfilesFailure = LoadModulesFailure<GenfileModuleMeta>;
 
 export const load_genfiles = async (
-	found_genfiles: Found_Genfiles,
+	found_genfiles: FoundGenfiles,
 	timings?: Timings,
-): Promise<Load_Genfiles_Result> => {
+): Promise<LoadGenfilesResult> => {
 	const loaded_modules = await load_modules(
 		found_genfiles.resolved_input_files,
 		validate_gen_module,
-		(resolved_input_file, mod): Genfile_Module_Meta => ({id: resolved_input_file.id, mod}),
+		(resolved_input_file, mod): GenfileModuleMeta => ({id: resolved_input_file.id, mod}),
 		timings,
 	);
 	if (!loaded_modules.ok) {
@@ -390,7 +390,7 @@ export const load_genfiles = async (
 	};
 };
 
-export const validate_gen_module = (mod: Record<string, any>): mod is Genfile_Module => {
+export const validate_gen_module = (mod: Record<string, any>): mod is GenfileModule => {
 	if (typeof mod.gen === 'function') return true;
 	if (typeof mod.gen === 'object' && mod.gen !== null && typeof mod.gen.generate === 'function') {
 		return true;
@@ -398,5 +398,5 @@ export const validate_gen_module = (mod: Record<string, any>): mod is Genfile_Mo
 	return false;
 };
 
-export const normalize_gen_config = (gen: Gen): Gen_Config =>
+export const normalize_gen_config = (gen: Gen): GenConfig =>
 	typeof gen === 'function' ? {generate: gen} : gen;

package/src/lib/gen_helpers.ts

@@ -1,17 +1,17 @@
 import {resolve} from 'node:path';
 import type {Logger} from '@ryanatkn/belt/log.js';
 import type {Timings} from '@ryanatkn/belt/timings.js';
-import type {Path_Id} from '@ryanatkn/belt/path.js';
+import type {PathId} from '@ryanatkn/belt/path.js';
 
-import type {Gro_Config} from './gro_config.ts';
+import type {GroConfig} from './gro_config.ts';
 import {filter_dependents, type Filer} from './filer.ts';
-import type {Invoke_Task} from './task.ts';
+import type {InvokeTask} from './task.ts';
 import {
 	normalize_gen_config,
 	validate_gen_module,
-	type Gen_Context,
-	type Gen_Dependencies,
-	type Gen_Dependencies_Config,
+	type GenContext,
+	type GenDependencies,
+	type GenDependenciesConfig,
 } from './gen.ts';
 import {default_svelte_config} from './svelte_config.ts';
 import {to_root_path} from './paths.ts';
@@ -21,13 +21,13 @@ import {load_module} from './modules.ts';
  * Check if a file change should trigger a gen file.
  */
 export const should_trigger_gen = async (
-	gen_file_id: Path_Id,
-	changed_file_id: Path_Id,
-	config: Gro_Config,
+	gen_file_id: PathId,
+	changed_file_id: PathId,
+	config: GroConfig,
 	filer: Filer,
 	log: Logger,
 	timings: Timings,
-	invoke_task: Invoke_Task,
+	invoke_task: InvokeTask,
 ): Promise<boolean> => {
 	// Always trigger if the gen file itself changed
 	const is_self_change = gen_file_id === changed_file_id;
@@ -74,14 +74,14 @@ export const should_trigger_gen = async (
  */
 const resolve_gen_dependencies = async (
 	gen_file_id: string,
-	changed_file_id: Path_Id | undefined,
+	changed_file_id: PathId | undefined,
 	bust_cache: boolean,
-	config: Gro_Config,
+	config: GroConfig,
 	filer: Filer,
 	log: Logger,
 	timings: Timings,
-	invoke_task: Invoke_Task,
-): Promise<Gen_Dependencies_Config | 'all' | null> => {
+	invoke_task: InvokeTask,
+): Promise<GenDependenciesConfig | 'all' | null> => {
 	const result = await load_module(gen_file_id, validate_gen_module, bust_cache);
 
 	if (!result.ok) {
@@ -96,9 +96,9 @@ const resolve_gen_dependencies = async (
 		return null;
 	}
 
-	let dependencies: Gen_Dependencies | null = gen_config.dependencies;
+	let dependencies: GenDependencies | null = gen_config.dependencies;
 	if (typeof dependencies === 'function') {
-		const gen_ctx: Gen_Context = {
+		const gen_ctx: GenContext = {
 			config,
 			svelte_config: default_svelte_config,
 			filer,
@@ -116,7 +116,7 @@ const resolve_gen_dependencies = async (
 		return dependencies;
 	}
 
-	// At this point, dependencies is either 'all' or Gen_Dependencies_Config
+	// At this point, dependencies is either 'all' or GenDependenciesConfig
 	// For static dependencies, also normalize empty objects
 	if (!dependencies.patterns?.length && !dependencies.files?.length) {
 		return null;

package/src/lib/github.ts

@@ -2,13 +2,13 @@
 // for now it's just calling a single endpoint so we do it manually
 // and we specify just the types we need
 
-import {Fetch_Value_Cache, fetch_value} from '@ryanatkn/belt/fetch.js';
+import {FetchValueCache, fetch_value} from '@ryanatkn/belt/fetch.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
 import {z} from 'zod';
 
 export const GITHUB_REPO_MATCHER = /.+github.com\/(.+)\/(.+)/;
 
-export const Github_Pull_Request = z.looseObject({
+export const GithubPullRequest = z.looseObject({
 	url: z.string(),
 	id: z.number(),
 	html_url: z.string(),
@@ -17,7 +17,7 @@ export const Github_Pull_Request = z.looseObject({
 		login: z.string(),
 	}),
 });
-export type Github_Pull_Request = z.infer<typeof Github_Pull_Request>;
+export type GithubPullRequest = z.infer<typeof GithubPullRequest>;
 
 /**
  * @see https://docs.github.com/en/rest/commits/commits?apiVersion=2022-11-28#list-pull-requests-associated-with-a-commit
@@ -28,14 +28,14 @@ export const github_fetch_commit_prs = async (
 	commit_sha: string,
 	token?: string,
 	log?: Logger,
-	cache?: Fetch_Value_Cache,
+	cache?: FetchValueCache,
 	api_version?: string,
-): Promise<Array<Github_Pull_Request> | null> => {
+): Promise<Array<GithubPullRequest> | null> => {
 	const headers = api_version ? new Headers({'x-github-api-version': api_version}) : undefined;
 	const url = `https://api.github.com/repos/${owner}/${repo}/commits/${commit_sha}/pulls`;
 	const fetched = await fetch_value(url, {
 		request: {headers},
-		parse: (v: Array<any>) => v.map((p) => Github_Pull_Request.parse(p)),
+		parse: (v: Array<any>) => v.map((p) => GithubPullRequest.parse(p)),
 		token,
 		cache,
 		return_early_from_cache: true,

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

@@ -1,4 +1,4 @@
-import type {Create_Gro_Config} from './gro_config.ts';
+import type {CreateGroConfig} from './gro_config.ts';
 import {gro_plugin_sveltekit_library} from './gro_plugin_sveltekit_library.ts';
 import {has_server, gro_plugin_server} from './gro_plugin_server.ts';
 import {gro_plugin_sveltekit_app} from './gro_plugin_sveltekit_app.ts';
@@ -17,7 +17,7 @@ import {load_package_json} from './package_json.ts';
  * - if `src/lib`, assumes a Node library - respects `KitConfig.kit.files.lib`
  * - if `src/lib/server/server.ts`, assumes a Node server - needs config
  */
-const config: Create_Gro_Config = async (cfg, svelte_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 [has_server_result, has_sveltekit_library_result, has_sveltekit_app_result] =

package/src/lib/gro_config.ts

@@ -1,7 +1,7 @@
 import {join, resolve} from 'node:path';
 import {existsSync} from 'node:fs';
 import {identity} from '@ryanatkn/belt/function.js';
-import type {Path_Filter, Path_Id} from '@ryanatkn/belt/path.js';
+import type {PathFilter, PathId} from '@ryanatkn/belt/path.js';
 import {json_stringify_deterministic} from '@ryanatkn/belt/json.js';
 
 import {GRO_DIST_DIR, IS_THIS_GRO, paths} from './paths.ts';
@@ -15,9 +15,9 @@ import {
 	SVELTEKIT_DIST_DIRNAME,
 } from './constants.ts';
 import create_default_config from './gro.config.default.ts';
-import type {Create_Config_Plugins} from './plugin.ts';
-import type {Package_Json_Mapper} from './package_json.ts';
-import type {Parsed_Svelte_Config} from './svelte_config.ts';
+import type {CreateConfigPlugins} from './plugin.ts';
+import type {PackageJsonMapper} from './package_json.ts';
+import type {ParsedSvelteConfig} from './svelte_config.ts';
 import {to_hash} from './hash.ts';
 
 /**
@@ -32,27 +32,27 @@ export const EMPTY_BUILD_CACHE_CONFIG_HASH =
  * This is exposed to users in places like tasks and genfiles.
  * @see https://github.com/ryanatkn/gro/blob/main/src/docs/config.md
  */
-export interface Gro_Config extends Raw_Gro_Config {
+export interface GroConfig extends RawGroConfig {
 	/**
 	 * @see https://github.com/ryanatkn/gro/blob/main/src/docs/plugin.md
 	 */
-	plugins: Create_Config_Plugins;
+	plugins: CreateConfigPlugins;
 	/**
 	 * Maps the project's `package.json` before writing it to the filesystem.
 	 * The `package_json` argument may be mutated, but the return value is what's used by the caller.
 	 * Returning `null` is a no-op for the caller.
 	 */
-	map_package_json: Package_Json_Mapper | null;
+	map_package_json: PackageJsonMapper | null;
 	/**
 	 * The root directories to search for tasks given implicit relative input paths.
 	 * Defaults to `./src/lib`, then the cwd, then the Gro package dist.
 	 */
-	task_root_dirs: Array<Path_Id>;
+	task_root_dirs: Array<PathId>;
 	/**
 	 * When searching the filsystem for tasks and genfiles,
 	 * directories and files are included if they pass all of these filters.
 	 */
-	search_filters: Array<Path_Filter>;
+	search_filters: Array<PathFilter>;
 	/**
 	 * The CLI to use that's compatible with `node`.
 	 */
@@ -67,21 +67,21 @@ export interface Gro_Config extends Raw_Gro_Config {
 	 * SHA-256 hash of the user's `build_cache_config` from `gro.config.ts`.
 	 * This is computed during config normalization and the raw value is immediately deleted.
 	 * If no `build_cache_config` was provided, this is the hash of an empty string.
-	 * @see Raw_Gro_Config.build_cache_config
+	 * @see RawGroConfig.build_cache_config
 	 */
 	build_cache_config_hash: string;
 }
 
 /**
- * The relaxed variant of `Gro_Config` that users can provide via `gro.config.ts`.
- * Superset of `Gro_Config`.
+ * The relaxed variant of `GroConfig` that users can provide via `gro.config.ts`.
+ * Superset of `GroConfig`.
  * @see https://github.com/ryanatkn/gro/blob/main/src/docs/config.md
  */
-export interface Raw_Gro_Config {
-	plugins?: Create_Config_Plugins;
-	map_package_json?: Package_Json_Mapper | null;
+export interface RawGroConfig {
+	plugins?: CreateConfigPlugins;
+	map_package_json?: PackageJsonMapper | null;
 	task_root_dirs?: Array<string>;
-	search_filters?: Path_Filter | Array<Path_Filter> | null;
+	search_filters?: PathFilter | Array<PathFilter> | null;
 	js_cli?: string;
 	pm_cli?: string;
 	/**
@@ -104,12 +104,12 @@ export interface Raw_Gro_Config {
 		| (() => Record<string, unknown> | Promise<Record<string, unknown>>);
 }
 
-export type Create_Gro_Config = (
-	base_config: Gro_Config,
-	svelte_config?: Parsed_Svelte_Config,
-) => Raw_Gro_Config | Promise<Raw_Gro_Config>;
+export type CreateGroConfig = (
+	base_config: GroConfig,
+	svelte_config?: ParsedSvelteConfig,
+) => RawGroConfig | Promise<RawGroConfig>;
 
-export const create_empty_gro_config = (): Gro_Config => ({
+export const create_empty_gro_config = (): GroConfig => ({
 	plugins: () => [],
 	map_package_json: identity,
 	task_root_dirs: [
@@ -127,7 +127,7 @@ export const create_empty_gro_config = (): Gro_Config => ({
 /**
  * The regexp used by default to exclude directories and files
  * when searching the filesystem for tasks and genfiles.
- * Customize via `search_filters` in the `Gro_Config`.
+ * Customize via `search_filters` in the `GroConfig`.
  * See the test cases for the exact behavior.
  */
 export const SEARCH_EXCLUDER_DEFAULT = new RegExp(
@@ -145,11 +145,11 @@ export const SEARCH_EXCLUDER_DEFAULT = new RegExp(
 export const EXPORTS_EXCLUDER_DEFAULT = /(\.md|\.(test|ignore)\.|\/(test|ignore)\/)/;
 
 /**
- * Transforms a `Raw_Gro_Config` to the more strict `Gro_Config`.
+ * Transforms a `RawGroConfig` to the more strict `GroConfig`.
  * This allows users to provide a more relaxed config.
  * Hashes the `build_cache_config` and deletes the raw value for security.
  */
-export const cook_gro_config = async (raw_config: Raw_Gro_Config): Promise<Gro_Config> => {
+export const cook_gro_config = async (raw_config: RawGroConfig): Promise<GroConfig> => {
 	const empty_config = create_empty_gro_config();
 
 	// All of the raw config properties are optional,
@@ -198,11 +198,11 @@ export const cook_gro_config = async (raw_config: Raw_Gro_Config): Promise<Gro_C
 	};
 };
 
-export interface Gro_Config_Module {
-	readonly default: Raw_Gro_Config | Create_Gro_Config;
+export interface GroConfigModule {
+	readonly default: RawGroConfig | CreateGroConfig;
 }
 
-export const load_gro_config = async (dir = paths.root): Promise<Gro_Config> => {
+export const load_gro_config = async (dir = paths.root): Promise<GroConfig> => {
 	const default_config = await cook_gro_config(
 		await create_default_config(create_empty_gro_config()),
 	);
@@ -228,7 +228,7 @@ export const load_gro_config = async (dir = paths.root): Promise<Gro_Config> =>
 export const validate_gro_config_module: (
 	config_module: any,
 	config_path: string,
-) => asserts config_module is Gro_Config_Module = (config_module, config_path) => {
+) => asserts config_module is GroConfigModule = (config_module, config_path) => {
 	const config = config_module.default;
 	if (!config) {
 		throw Error(`Invalid Gro config module at ${config_path}: expected a default export`);

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 Spawn_Result} from '@ryanatkn/belt/process.js';
+import {spawn, type SpawnResult} from '@ryanatkn/belt/process.js';
 
 import {JS_CLI_DEFAULT, NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME} from './constants.ts';
 
@@ -85,7 +85,7 @@ export const spawn_with_loader = (
 	invoke_path: string,
 	argv: Array<string>,
 	js_cli = JS_CLI_DEFAULT, // TODO source from config when possible
-): Promise<Spawn_Result> => {
+): Promise<SpawnResult> => {
 	const args = [
 		'--import',
 		// This does the same as `$lib/register.ts` but without the cost of importing another file.