@ryanatkn/gro 0.176.0 → 0.177.0

package/src/lib/run_gen.ts

@@ -4,43 +4,43 @@ import type {Timings} from '@ryanatkn/belt/timings.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
 
 import {
-	type Gen_Results,
-	type Genfile_Module_Result,
-	type Gen_Context,
-	type Genfile_Module_Meta,
+	type GenResults,
+	type GenfileModuleResult,
+	type GenContext,
+	type GenfileModuleMeta,
 	to_gen_result,
-	type Raw_Gen_Result,
+	type RawGenResult,
 	normalize_gen_config,
 } from './gen.ts';
 import {print_path, to_root_path} from './paths.ts';
 import type {format_file as base_format_file} from './format_file.ts';
-import type {Gro_Config} from './gro_config.ts';
+import type {GroConfig} from './gro_config.ts';
 import {default_svelte_config} from './svelte_config.ts';
 import type {Filer} from './filer.ts';
-import type {Invoke_Task} from './task.ts';
+import type {InvokeTask} from './task.ts';
 
 export const GEN_NO_PROD_MESSAGE = 'gen runs only during development';
 
 export const run_gen = async (
-	gen_modules: Array<Genfile_Module_Meta>,
-	config: Gro_Config,
+	gen_modules: Array<GenfileModuleMeta>,
+	config: GroConfig,
 	filer: Filer,
 	log: Logger,
 	timings: Timings,
-	invoke_task: Invoke_Task,
+	invoke_task: InvokeTask,
 	format_file?: typeof base_format_file,
-): Promise<Gen_Results> => {
+): Promise<GenResults> => {
 	let input_count = 0;
 	let output_count = 0;
 	const timing_for_run_gen = timings.start('run_gen');
 	const results = await Promise.all(
-		gen_modules.map(async (module_meta): Promise<Genfile_Module_Result> => {
+		gen_modules.map(async (module_meta): Promise<GenfileModuleResult> => {
 			input_count++;
 			const {id} = module_meta;
 			const timing_for_module = timings.start(id);
 
 			const gen_config = normalize_gen_config(module_meta.mod.gen);
-			const gen_ctx: Gen_Context = {
+			const gen_ctx: GenContext = {
 				config,
 				svelte_config: default_svelte_config,
 				filer,
@@ -51,7 +51,7 @@ export const run_gen = async (
 				origin_path: to_root_path(id),
 				changed_file_id: undefined,
 			};
-			let raw_gen_result: Raw_Gen_Result;
+			let raw_gen_result: RawGenResult;
 			try {
 				raw_gen_result = await gen_config.generate(gen_ctx);
 			} catch (err) {

package/src/lib/run_task.ts

@@ -6,12 +6,12 @@ import {z} from 'zod';
 import {parse_args, type Args} from './args.ts';
 import type {invoke_task as base_invoke_task} from './invoke_task.ts';
 import {log_task_help} from './task_logging.ts';
-import type {Gro_Config} from './gro_config.ts';
-import {Task_Error, type Task_Module_Meta} from './task.ts';
+import type {GroConfig} from './gro_config.ts';
+import {TaskError, type TaskModuleMeta} from './task.ts';
 import {default_svelte_config} from './svelte_config.ts';
 import type {Filer} from './filer.ts';
 
-export type Run_Task_Result =
+export type RunTaskResult =
 	| {
 			ok: true;
 			output: unknown;
@@ -23,14 +23,14 @@ export type Run_Task_Result =
 	  };
 
 export const run_task = async (
-	task_meta: Task_Module_Meta,
+	task_meta: TaskModuleMeta,
 	unparsed_args: Args,
 	invoke_task: typeof base_invoke_task,
-	config: Gro_Config,
+	config: GroConfig,
 	filer: Filer,
 	log: Logger,
 	timings: Timings,
-): Promise<Run_Task_Result> => {
+): Promise<RunTaskResult> => {
 	const {task} = task_meta.mod;
 
 	if (unparsed_args.help) {
@@ -43,7 +43,7 @@ export const run_task = async (
 	if (task.Args) {
 		const parsed = parse_args(unparsed_args, task.Args);
 		if (!parsed.success) {
-			throw new Task_Error(
+			throw new TaskError(
 				`Failed task args validation for task '${task_meta.name}':\n${z.prettifyError(parsed.error)}`,
 			);
 		}
@@ -68,7 +68,7 @@ export const run_task = async (
 			ok: false,
 			reason: st(
 				'red',
-				err?.constructor?.name === 'Task_Error'
+				err?.constructor?.name === 'TaskError'
 					? (err.message as string)
 					: `Unexpected error running task ${st(
 							'cyan',

package/src/lib/search_fs.ts

@@ -3,21 +3,21 @@ import {to_array} from '@ryanatkn/belt/array.js';
 import {ensure_end} from '@ryanatkn/belt/string.js';
 import {isAbsolute, join} from 'node:path';
 import {existsSync, readdirSync} from 'node:fs';
-import type {File_Filter, Resolved_Path, Path_Filter} from '@ryanatkn/belt/path.js';
+import type {FileFilter, ResolvedPath, PathFilter} from '@ryanatkn/belt/path.js';
 
-export interface Search_Fs_Options {
+export interface SearchFsOptions {
 	/**
 	 * One or more filter functions, any of which can short-circuit the search by returning `false`.
 	 */
-	filter?: Path_Filter | Array<Path_Filter>;
+	filter?: PathFilter | Array<PathFilter>;
 	/**
 	 * One or more file filter functions. Every filter must pass for a file to be included.
 	 */
-	file_filter?: File_Filter | Array<File_Filter>;
+	file_filter?: FileFilter | Array<FileFilter>;
 	/**
 	 * Pass `null` or `false` to speed things up at the cost of volatile ordering.
 	 */
-	sort?: boolean | null | ((a: Resolved_Path, b: Resolved_Path) => number);
+	sort?: boolean | null | ((a: ResolvedPath, b: ResolvedPath) => number);
 	/**
 	 * Set to `true` to include directories. Defaults to `false`.
 	 */
@@ -30,8 +30,8 @@ export interface Search_Fs_Options {
 
 export const search_fs = (
 	dir: string,
-	options: Search_Fs_Options = EMPTY_OBJECT,
-): Array<Resolved_Path> => {
+	options: SearchFsOptions = EMPTY_OBJECT,
+): Array<ResolvedPath> => {
 	const {
 		filter,
 		file_filter,
@@ -51,22 +51,22 @@ export const search_fs = (
 
 	if (!existsSync(final_dir)) return [];
 
-	const paths: Array<Resolved_Path> = [];
+	const paths: Array<ResolvedPath> = [];
 	crawl(final_dir, paths, filters, file_filters, include_directories, null);
 
 	return sort ? paths.sort(typeof sort === 'boolean' ? default_sort : sort) : paths;
 };
 
-const default_sort = (a: Resolved_Path, b: Resolved_Path): number => a.path.localeCompare(b.path);
+const default_sort = (a: ResolvedPath, b: ResolvedPath): number => a.path.localeCompare(b.path);
 
 const crawl = (
 	dir: string,
-	paths: Array<Resolved_Path>,
-	filters: Array<Path_Filter> | undefined,
-	file_filter: Array<File_Filter> | undefined,
+	paths: Array<ResolvedPath>,
+	filters: Array<PathFilter> | undefined,
+	file_filter: Array<FileFilter> | undefined,
 	include_directories: boolean,
 	base_dir: string | null,
-): Array<Resolved_Path> => {
+): Array<ResolvedPath> => {
 	// This sync version is significantly faster than using the `fs/promises` version -
 	// it doesn't parallelize but that's not the common case in Gro.
 	const dirents = readdirSync(dir, {withFileTypes: true});

package/src/lib/src_json.ts

@@ -2,8 +2,8 @@ import {join} from 'node:path';
 import {ensure_end, strip_start} from '@ryanatkn/belt/string.js';
 import {existsSync} from 'node:fs';
 import ts from 'typescript';
-import type {Package_Json, Package_Json_Exports} from '@ryanatkn/belt/package_json.js';
-import {Src_Json, type Module_Json, type Identifier_Kind} from '@ryanatkn/belt/src_json.js';
+import type {PackageJson, PackageJsonExports} from '@ryanatkn/belt/package_json.js';
+import {SrcJson, type ModuleJson, type IdentifierKind} from '@ryanatkn/belt/src_json.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
 
 import {paths, replace_extension} from './paths.ts';
@@ -11,29 +11,29 @@ import {parse_exports} from './parse_exports.ts';
 import {TS_MATCHER, SVELTE_MATCHER, JSON_MATCHER, CSS_MATCHER} from './constants.ts';
 import {search_fs} from './search_fs.ts';
 
-export type Src_Json_Mapper = (src_json: Src_Json) => Src_Json | null | Promise<Src_Json | null>;
+export type SrcJsonMapper = (src_json: SrcJson) => SrcJson | null | Promise<SrcJson | null>;
 
 export const src_json_create = (
-	package_json: Package_Json,
+	package_json: PackageJson,
 	lib_path?: string,
 	log?: Logger,
-): Src_Json =>
-	Src_Json.parse({
+): SrcJson =>
+	SrcJson.parse({
 		name: package_json.name,
 		version: package_json.version,
 		modules: src_modules_create(package_json.exports, lib_path, log),
 	});
 
-export const src_json_serialize = (src_json: Src_Json): string => {
-	const parsed = Src_Json.parse(src_json);
+export const src_json_serialize = (src_json: SrcJson): string => {
+	const parsed = SrcJson.parse(src_json);
 	return JSON.stringify(parsed, null, 2) + '\n';
 };
 
 export const src_modules_create = (
-	exports: Package_Json_Exports | undefined,
+	exports: PackageJsonExports | undefined,
 	lib_path = paths.lib,
 	log?: Logger,
-): Array<Module_Json> | undefined => {
+): Array<ModuleJson> | undefined => {
 	if (!exports) return;
 
 	const file_paths = collect_file_paths(exports, lib_path);
@@ -58,14 +58,14 @@ export const src_modules_create = (
 		);
 	}
 
-	const result: Array<Module_Json> = [];
+	const result: Array<ModuleJson> = [];
 
 	// Process each file
 	for (const {file_path} of file_paths) {
 		const relative_path = file_path.replace(ensure_end(lib_path, '/'), '');
 
 		const identifiers = parse_exports(file_path, program, undefined, log)
-			.filter((d): d is {name: string; kind: Identifier_Kind} => d.kind !== null) // TODO maybe dont filter out?
+			.filter((d): d is {name: string; kind: IdentifierKind} => d.kind !== null) // TODO maybe dont filter out?
 			.map(({name, kind}) => ({name, kind}));
 
 		result.push(
@@ -84,7 +84,7 @@ export const src_modules_create = (
 };
 
 const collect_file_paths = (
-	exports: Package_Json_Exports,
+	exports: PackageJsonExports,
 	lib_path: string,
 ): Array<{export_key: string; file_path: string}> => {
 	const file_paths: Array<{export_key: string; file_path: string}> = [];

package/src/lib/svelte_config.ts

@@ -37,7 +37,7 @@ export const load_svelte_config = async ({
  * The `base` and `assets` in particular are renamed for clarity with Gro's internal systems,
  * so these properties become first-class vocabulary inside Gro.
  */
-export interface Parsed_Svelte_Config {
+export interface ParsedSvelteConfig {
 	// TODO probably fill these out with defaults
 	svelte_config: SvelteConfig | null;
 	alias: Record<string, string>;
@@ -78,7 +78,7 @@ export const parse_svelte_config = async ({
 }: {
 	dir_or_config?: string | SvelteConfig;
 	config_filename?: string;
-} = EMPTY_OBJECT): Promise<Parsed_Svelte_Config> => {
+} = EMPTY_OBJECT): Promise<ParsedSvelteConfig> => {
 	const svelte_config =
 		typeof dir_or_config === 'string'
 			? await load_svelte_config({dir: dir_or_config, config_filename})

package/src/lib/sveltekit_helpers.ts

@@ -1,11 +1,11 @@
 import type {Result} from '@ryanatkn/belt/result.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
 import {join} from 'node:path';
-import type {Package_Json} from '@ryanatkn/belt/package_json.js';
+import type {PackageJson} from '@ryanatkn/belt/package_json.js';
 import {fs_exists} from '@ryanatkn/belt/fs.js';
 
 import {has_dep} from './package_json.ts';
-import {default_svelte_config, type Parsed_Svelte_Config} from './svelte_config.ts';
+import {default_svelte_config, type ParsedSvelteConfig} from './svelte_config.ts';
 import {
 	SVELTE_CONFIG_FILENAME,
 	SVELTEKIT_DEV_DIRNAME,
@@ -14,7 +14,7 @@ import {
 	SVELTEKIT_CLI,
 } from './constants.ts';
 import {find_cli, spawn_cli, to_cli_name, type Cli} from './cli.ts';
-import {Task_Error} from './task.ts';
+import {TaskError} from './task.ts';
 import {serialize_args, to_forwarded_args} from './args.ts';
 
 export const has_sveltekit_app = async (
@@ -28,8 +28,8 @@ export const has_sveltekit_app = async (
 };
 
 export const has_sveltekit_library = async (
-	package_json: Package_Json,
-	svelte_config: Parsed_Svelte_Config = default_svelte_config,
+	package_json: PackageJson,
+	svelte_config: ParsedSvelteConfig = default_svelte_config,
 	dep_name = SVELTE_PACKAGE_DEP_NAME,
 ): Promise<Result<object, {message: string}>> => {
 	const has_sveltekit_app_result = await has_sveltekit_app();
@@ -57,11 +57,11 @@ export const sveltekit_sync = async (
 ): Promise<void> => {
 	const result = await spawn_cli(sveltekit_cli, ['sync']);
 	if (!result) {
-		throw new Task_Error(
+		throw new TaskError(
 			`Failed to find SvelteKit CLI \`${to_cli_name(sveltekit_cli)}\`, do you need to run \`${pm_cli} install\`?`,
 		);
 	} else if (!result.ok) {
-		throw new Task_Error(`Failed ${to_cli_name(sveltekit_cli)} sync`);
+		throw new TaskError(`Failed ${to_cli_name(sveltekit_cli)} sync`);
 	}
 };
 
@@ -100,7 +100,7 @@ export const sveltekit_sync_if_obviously_needed = async (
  * Options to the SvelteKit packaging CLI.
  * @see https://kit.svelte.dev/docs/packaging#options
  */
-export interface Svelte_Package_Options {
+export interface SveltePackageOptions {
 	/**
 	 * Watch files in src/lib for changes and rebuild the package
 	 */
@@ -147,22 +147,22 @@ export interface Svelte_Package_Options {
 }
 
 export const run_svelte_package = async (
-	package_json: Package_Json,
-	options: Svelte_Package_Options | undefined,
+	package_json: PackageJson,
+	options: SveltePackageOptions | undefined,
 	cli: string | Cli,
 	log: Logger,
 	pm_cli: string,
 ): Promise<void> => {
 	const has_sveltekit_library_result = await has_sveltekit_library(package_json);
 	if (!has_sveltekit_library_result.ok) {
-		throw new Task_Error(
+		throw new TaskError(
 			'Failed to find SvelteKit library: ' + has_sveltekit_library_result.message,
 		);
 	}
 	const cli_name = typeof cli === 'string' ? cli : cli.name;
 	const found_svelte_package_cli = cli === cli_name ? find_cli(cli) : (cli as Cli);
 	if (found_svelte_package_cli?.kind !== 'local') {
-		throw new Task_Error(
+		throw new TaskError(
 			`Failed to find SvelteKit packaging CLI \`${cli_name}\`, do you need to run \`${pm_cli} install\`?`,
 		);
 	}

package/src/lib/sveltekit_shim_app.ts

@@ -1,4 +1,4 @@
-import type {Parsed_Svelte_Config} from './svelte_config.ts';
+import type {ParsedSvelteConfig} from './svelte_config.ts';
 
 export const SVELTEKIT_SHIM_APP_PATHS_MATCHER = /\/util\/sveltekit_shim_app_paths\.js$/;
 export const SVELTEKIT_SHIM_APP_ENVIRONMENT_MATCHER = /\/util\/sveltekit_shim_app_environment\.js$/;
@@ -16,8 +16,8 @@ export const sveltekit_shim_app_specifiers = new Map([
 ]);
 
 export const render_sveltekit_shim_app_paths = (
-	base_url: Parsed_Svelte_Config['base_url'] = '',
-	assets_url: Parsed_Svelte_Config['assets_url'] = '',
+	base_url: ParsedSvelteConfig['base_url'] = '',
+	assets_url: ParsedSvelteConfig['assets_url'] = '',
 ): string => `// shim for $app/paths
 // @see https://github.com/sveltejs/kit/issues/1485
 

package/src/lib/sync.task.ts

@@ -1,7 +1,7 @@
 import {z} from 'zod';
 import {spawn} from '@ryanatkn/belt/process.js';
 
-import {Task_Error, type Task} from './task.ts';
+import {TaskError, type Task} from './task.ts';
 import {sync_package_json} from './package_json.ts';
 import {sveltekit_sync} from './sveltekit_helpers.ts';
 
@@ -27,7 +27,7 @@ export const task: Task<Args> = {
 		if (install) {
 			const result = await spawn(config.pm_cli, ['install']);
 			if (!result.ok) {
-				throw new Task_Error(`Failed \`${config.pm_cli} install\``);
+				throw new TaskError(`Failed \`${config.pm_cli} install\``);
 			}
 		}
 

package/src/lib/task.ts

@@ -5,57 +5,57 @@ import type {Timings} from '@ryanatkn/belt/timings.js';
 import {styleText as st} from 'node:util';
 import type {Result} from '@ryanatkn/belt/result.js';
 import {isAbsolute, join, relative} from 'node:path';
-import type {Path_Id} from '@ryanatkn/belt/path.js';
+import type {PathId} from '@ryanatkn/belt/path.js';
 
 import type {Args} from './args.ts';
-import type {Gro_Config} from './gro_config.ts';
-import type {Parsed_Svelte_Config} from './svelte_config.ts';
+import type {GroConfig} from './gro_config.ts';
+import type {ParsedSvelteConfig} from './svelte_config.ts';
 import {
 	resolve_input_files,
 	resolve_input_paths,
-	type Input_Path,
-	type Resolved_Input_File,
-	type Resolved_Input_Path,
+	type InputPath,
+	type ResolvedInputFile,
+	type ResolvedInputPath,
 } from './input_path.ts';
 import {GRO_DIST_DIR, print_path} from './paths.ts';
 import {search_fs} from './search_fs.ts';
-import {load_modules, type Load_Modules_Failure, type Module_Meta} from './modules.ts';
+import {load_modules, type LoadModulesFailure, type ModuleMeta} from './modules.ts';
 import type {Filer} from './filer.ts';
 
 export interface Task<
-	T_Args = Args,
-	T_Args_Schema extends z.ZodType<Args, Args> = z.ZodType<Args, Args>, // TODO improve type? separate input/output?
-	T_Return = unknown,
+	TArgs = Args,
+	TArgsSchema extends z.ZodType<Args, Args> = z.ZodType<Args, Args>, // TODO improve type? separate input/output?
+	TReturn = unknown,
 > {
-	run: (ctx: Task_Context<T_Args>) => T_Return | Promise<T_Return>; // TODO unused return value
+	run: (ctx: TaskContext<TArgs>) => TReturn | Promise<TReturn>; // TODO unused return value
 	summary?: string;
-	Args?: T_Args_Schema;
+	Args?: TArgsSchema;
 }
 
-export interface Task_Context<T_Args = object> {
-	args: T_Args;
-	config: Gro_Config;
-	svelte_config: Parsed_Svelte_Config;
+export interface TaskContext<TArgs = object> {
+	args: TArgs;
+	config: GroConfig;
+	svelte_config: ParsedSvelteConfig;
 	filer: Filer;
 	log: Logger;
 	timings: Timings;
-	invoke_task: Invoke_Task;
+	invoke_task: InvokeTask;
 }
 
-export type Invoke_Task = (task_name: string, args?: Args, config?: Gro_Config) => Promise<void>;
+export type InvokeTask = (task_name: string, args?: Args, config?: GroConfig) => Promise<void>;
 
 export const TASK_FILE_SUFFIX_TS = '.task.ts';
 export const TASK_FILE_SUFFIX_JS = '.task.js';
-export const TASK_FILE_SUFFIXES = [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS]; // TODO from `Gro_Config`, but needs to be used everywhere the constants are
+export const TASK_FILE_SUFFIXES = [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS]; // TODO from `GroConfig`, but needs to be used everywhere the constants are
 
 export const is_task_path = (path: string): boolean =>
 	path.endsWith(TASK_FILE_SUFFIX_TS) || path.endsWith(TASK_FILE_SUFFIX_JS);
 
 export const to_task_name = (
-	id: Path_Id,
-	task_root_dir: Path_Id,
-	input_path: Input_Path,
-	root_path: Path_Id,
+	id: PathId,
+	task_root_dir: PathId,
+	input_path: InputPath,
+	root_path: PathId,
 ): string => {
 	let task_name = id.startsWith(task_root_dir)
 		? strip_start(strip_start(id, task_root_dir), '/')
@@ -80,46 +80,46 @@ export const to_task_name = (
  * It's useful for cleaning up logging because
  * we usually don't need their stack trace.
  */
-export class Task_Error extends Error {}
+export class TaskError extends Error {}
 
 /**
  * This is used to tell Gro to exit silently, usually still with with a non-zero exit code.
  * Using it means error logging is handled by the code that threw it.
  */
-export class Silent_Error extends Error {}
+export class SilentError extends Error {}
 
-export interface Found_Task {
-	input_path: Input_Path;
-	id: Path_Id;
-	task_root_dir: Path_Id;
+export interface FoundTask {
+	input_path: InputPath;
+	id: PathId;
+	task_root_dir: PathId;
 }
 
-export interface Found_Tasks {
-	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_paths: Array<Input_Path>;
-	task_root_dirs: Array<Path_Id>;
+export interface FoundTasks {
+	resolved_input_files: Array<ResolvedInputFile>;
+	resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+	resolved_input_paths: Array<ResolvedInputPath>;
+	input_paths: Array<InputPath>;
+	task_root_dirs: Array<PathId>;
 }
 
-export type Find_Tasks_Result = Result<{value: Found_Tasks}, Find_Modules_Failure>;
-export type Find_Modules_Failure =
+export type FindTasksResult = Result<{value: FoundTasks}, FindModulesFailure>;
+export type FindModulesFailure =
 	| {
 			type: 'unmapped_input_paths';
-			unmapped_input_paths: Array<Input_Path>;
-			resolved_input_paths: Array<Resolved_Input_Path>;
-			input_paths: Array<Input_Path>;
-			task_root_dirs: Array<Path_Id>;
+			unmapped_input_paths: Array<InputPath>;
+			resolved_input_paths: Array<ResolvedInputPath>;
+			input_paths: Array<InputPath>;
+			task_root_dirs: Array<PathId>;
 			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_paths: Array<Input_Path>;
-			task_root_dirs: Array<Path_Id>;
+			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>;
+			input_paths: Array<InputPath>;
+			task_root_dirs: Array<PathId>;
 			reasons: Array<string>;
 	  };
 
@@ -127,11 +127,11 @@ export type Find_Modules_Failure =
  * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
  */
 export const find_tasks = (
-	input_paths: Array<Input_Path>,
-	task_root_dirs: Array<Path_Id>,
-	config: Gro_Config,
+	input_paths: Array<InputPath>,
+	task_root_dirs: Array<PathId>,
+	config: GroConfig,
 	timings?: Timings,
-): Find_Tasks_Result => {
+): FindTasksResult => {
 	// Check which extension variation works - if it's a directory, prefer others first!
 	const timing_to_resolve_input_paths = timings?.start('resolve input paths');
 	const {resolved_input_paths, unmapped_input_paths} = resolve_input_paths(
@@ -196,30 +196,30 @@ export const find_tasks = (
 	};
 };
 
-export interface Loaded_Tasks {
-	modules: Array<Task_Module_Meta>;
-	found_tasks: Found_Tasks;
+export interface LoadedTasks {
+	modules: Array<TaskModuleMeta>;
+	found_tasks: FoundTasks;
 }
 
-export interface Task_Module {
+export interface TaskModule {
 	task: Task;
 }
 
-export interface Task_Module_Meta extends Module_Meta<Task_Module> {
+export interface TaskModuleMeta extends ModuleMeta<TaskModule> {
 	name: string;
 }
 
-export type Load_Tasks_Result = Result<{value: Loaded_Tasks}, Load_Tasks_Failure>;
-export type Load_Tasks_Failure = Load_Modules_Failure<Task_Module_Meta>;
+export type LoadTasksResult = Result<{value: LoadedTasks}, LoadTasksFailure>;
+export type LoadTasksFailure = LoadModulesFailure<TaskModuleMeta>;
 
 export const load_tasks = async (
-	found_tasks: Found_Tasks,
-	root_path: Path_Id = process.cwd(), // TODO @many isn't passed in anywhere, maybe hoist to `invoke_task` and others
-): Promise<Load_Tasks_Result> => {
+	found_tasks: FoundTasks,
+	root_path: PathId = process.cwd(), // TODO @many isn't passed in anywhere, maybe hoist to `invoke_task` and others
+): Promise<LoadTasksResult> => {
 	const loaded_modules = await load_modules(
 		found_tasks.resolved_input_files,
 		validate_task_module,
-		(resolved_input_file, mod): Task_Module_Meta => ({
+		(resolved_input_file, mod): TaskModuleMeta => ({
 			id: resolved_input_file.id,
 			mod,
 			name: to_task_name(
@@ -240,5 +240,5 @@ export const load_tasks = async (
 	};
 };
 
-export const validate_task_module = (mod: Record<string, any>): mod is Task_Module =>
+export const validate_task_module = (mod: Record<string, any>): mod is TaskModule =>
 	!!mod.task && typeof mod.task.run === 'function';