@ryanatkn/gro 0.176.0 → 0.177.1

package/src/lib/gro_plugin_gen.ts

@@ -1,6 +1,6 @@
 import {EMPTY_OBJECT} from '@ryanatkn/belt/object.js';
 import {throttle} from '@ryanatkn/belt/throttle.js';
-import {Unreachable_Error} from '@ryanatkn/belt/error.js';
+import {UnreachableError} from '@ryanatkn/belt/error.js';
 
 import type {Plugin} from './plugin.ts';
 import type {Args} from './args.ts';
@@ -16,11 +16,11 @@ const FLUSH_DEBOUNCE_DELAY = 500;
 // 	await invoke_task('gen', {_: files, bust_cache: true});
 const gen = (files: Array<string> = []) => spawn_cli('gro', ['gen', ...files]);
 
-export interface Task_Args extends Args {
+export interface TaskArgs extends Args {
 	watch?: boolean;
 }
 
-export interface Gro_Plugin_Gen_Options {
+export interface GroPluginGenOptions {
 	input_paths?: Array<string>;
 	root_dirs?: Array<string>;
 	flush_debounce_delay?: number;
@@ -30,7 +30,7 @@ export const gro_plugin_gen = ({
 	input_paths = [paths.source],
 	root_dirs = [paths.source],
 	flush_debounce_delay = FLUSH_DEBOUNCE_DELAY,
-}: Gro_Plugin_Gen_Options = EMPTY_OBJECT): Plugin => {
+}: GroPluginGenOptions = EMPTY_OBJECT): Plugin => {
 	const queued_files: Set<string> = new Set();
 
 	let cleanup_watch: (() => void) | undefined;
@@ -135,7 +135,7 @@ export const gro_plugin_gen = ({
 						break;
 					}
 					default:
-						throw new Unreachable_Error(change.type);
+						throw new UnreachableError(change.type);
 				}
 			});
 		},

package/src/lib/gro_plugin_server.ts

@@ -1,4 +1,4 @@
-import {spawn_restartable_process, type Restartable_Process} from '@ryanatkn/belt/process.js';
+import {spawn_restartable_process, type RestartableProcess} from '@ryanatkn/belt/process.js';
 import * as esbuild from 'esbuild';
 import type {Config as SvelteConfig} from '@sveltejs/kit';
 import {join, resolve} from 'node:path';
@@ -7,7 +7,7 @@ import {strip_before, strip_end} from '@ryanatkn/belt/string.js';
 import type {Result} from '@ryanatkn/belt/result.js';
 import {fs_exists} from '@ryanatkn/belt/fs.js';
 import {throttle} from '@ryanatkn/belt/throttle.js';
-import type {Path_Id} from '@ryanatkn/belt/path.js';
+import type {PathId} from '@ryanatkn/belt/path.js';
 
 import type {Plugin} from './plugin.ts';
 import {base_path_to_path_id, LIB_DIRNAME, paths} from './paths.ts';
@@ -34,7 +34,7 @@ export const has_server = async (
 	return {ok: true};
 };
 
-export interface Gro_Plugin_Server_Options {
+export interface GroPluginServerOptions {
 	/**
 	 * same as esbuild's `entryPoints`
 	 */
@@ -48,7 +48,7 @@ export interface Gro_Plugin_Server_Options {
 	 * Decoupling this from plugin creation allows it to be created generically,
 	 * so the build and dev tasks can be the source of truth for `dev`.
 	 */
-	outpaths?: Create_Outpaths;
+	outpaths?: CreateOutpaths;
 	/**
 	 * @default ```SvelteKit's `.env`, `.env.development`, and `.env.production````
 	 */
@@ -104,7 +104,7 @@ export interface Outpaths {
 	outname: string;
 }
 
-export type Create_Outpaths = (dev: boolean) => Outpaths;
+export type CreateOutpaths = (dev: boolean) => Outpaths;
 
 export const gro_plugin_server = ({
 	entry_points = [SERVER_SOURCE_ID],
@@ -122,11 +122,11 @@ export const gro_plugin_server = ({
 	rebuild_throttle_delay = 1000,
 	cli_command,
 	run, // `dev` default is not available in this scope
-}: Gro_Plugin_Server_Options = {}): Plugin => {
+}: GroPluginServerOptions = {}): Plugin => {
 	let build_ctx: esbuild.BuildContext | undefined;
 	let cleanup_watch: (() => void) | undefined;
-	let server_process: Restartable_Process | undefined;
-	let deps: Set<Path_Id> | undefined;
+	let server_process: RestartableProcess | undefined;
+	let deps: Set<PathId> | undefined;
 
 	return {
 		name: 'gro_plugin_server',

package/src/lib/gro_plugin_sveltekit_app.ts

@@ -1,4 +1,4 @@
-import type {Spawned_Process} from '@ryanatkn/belt/process.js';
+import type {SpawnedProcess} from '@ryanatkn/belt/process.js';
 import {cpSync, mkdirSync, rmSync, writeFileSync, existsSync} from 'node:fs';
 import {dirname, join} from 'node:path';
 
@@ -6,49 +6,49 @@ import type {Plugin} from './plugin.ts';
 import {serialize_args, to_forwarded_args} from './args.ts';
 import {
 	serialize_package_json,
-	type Package_Json_Mapper,
+	type PackageJsonMapper,
 	load_package_json,
 } from './package_json.ts';
-import {Task_Error} from './task.ts';
+import {TaskError} from './task.ts';
 import {find_cli, spawn_cli, spawn_cli_process} from './cli.ts';
-import {type Src_Json_Mapper, src_json_serialize, src_json_create} from './src_json.ts';
+import {type SrcJsonMapper, src_json_serialize, src_json_create} from './src_json.ts';
 import {EXPORTS_EXCLUDER_DEFAULT} from './gro_config.ts';
 import {default_svelte_config} from './svelte_config.ts';
 import {SOURCE_DIRNAME, VITE_CLI} from './constants.ts';
 
-export interface Gro_Plugin_Sveltekit_App_Options {
+export interface GroPluginSveltekitAppOptions {
 	/**
 	 * Used for finalizing a SvelteKit build like adding a `.nojekyll` file for GitHub Pages.
 	 * @default 'github_pages'
 	 */
-	host_target?: Host_Target;
+	host_target?: HostTarget;
 
 	/**
 	 * If truthy, adds `/.well-known/package.json` to the static output.
 	 * If a function, maps the value.
 	 */
-	well_known_package_json?: boolean | Package_Json_Mapper;
+	well_known_package_json?: boolean | PackageJsonMapper;
 
 	/**
 	 * If truthy, adds `/.well-known/src.json` and `/.well-known/src/` to the static output.
 	 * If a function, maps the value.
 	 */
-	well_known_src_json?: boolean | Src_Json_Mapper;
+	well_known_src_json?: boolean | SrcJsonMapper;
 
 	/**
 	 * If truthy, copies `src/` to `/.well-known/src/` to the static output.
 	 * Pass a function to customize which files get copied.
 	 */
-	well_known_src_files?: boolean | Copy_File_Filter;
+	well_known_src_files?: boolean | CopyFileFilter;
 	/**
 	 * The Vite CLI to use.
 	 */
 	vite_cli?: string;
 }
 
-export type Host_Target = 'github_pages' | 'static' | 'node';
+export type HostTarget = 'github_pages' | 'static' | 'node';
 
-export type Copy_File_Filter = (file_path: string) => boolean;
+export type CopyFileFilter = (file_path: string) => boolean;
 
 export const gro_plugin_sveltekit_app = ({
 	host_target = 'github_pages',
@@ -56,8 +56,8 @@ export const gro_plugin_sveltekit_app = ({
 	well_known_src_json,
 	well_known_src_files,
 	vite_cli = VITE_CLI,
-}: Gro_Plugin_Sveltekit_App_Options = {}): Plugin => {
-	let sveltekit_process: Spawned_Process | undefined = undefined;
+}: GroPluginSveltekitAppOptions = {}): Plugin => {
+	let sveltekit_process: SpawnedProcess | undefined = undefined;
 	return {
 		name: 'gro_plugin_sveltekit_app',
 		setup: async ({dev, watch, log, config}) => {
@@ -149,7 +149,7 @@ export const gro_plugin_sveltekit_app = ({
 					const serialized_args = ['build', ...serialize_args(to_forwarded_args(vite_cli))];
 					const spawned = await spawn_cli(found_vite_cli, serialized_args, log);
 					if (!spawned?.ok) {
-						throw new Task_Error(`${vite_cli} build failed with exit code ${spawned?.code}`);
+						throw new TaskError(`${vite_cli} build failed with exit code ${spawned?.code}`);
 					}
 				} catch (err) {
 					cleanup();
@@ -175,7 +175,7 @@ const copy_temporarily = (
 	source_path: string,
 	dest_dir: string,
 	dest_base_dir = '',
-	filter?: Copy_File_Filter,
+	filter?: CopyFileFilter,
 ): Cleanup => {
 	const path = join(dest_dir, dest_base_dir, source_path);
 	const dir = dirname(path);

package/src/lib/gro_plugin_sveltekit_library.ts

@@ -1,17 +1,17 @@
 import {print_spawn_result, spawn} from '@ryanatkn/belt/process.js';
 
 import type {Plugin} from './plugin.ts';
-import {Task_Error} from './task.ts';
+import {TaskError} from './task.ts';
 import {load_package_json} from './package_json.ts';
-import {run_svelte_package, type Svelte_Package_Options} from './sveltekit_helpers.ts';
+import {run_svelte_package, type SveltePackageOptions} from './sveltekit_helpers.ts';
 import {SVELTE_PACKAGE_CLI} from './constants.ts';
 
-export interface Gro_Plugin_Sveltekit_Library_Options {
+export interface GroPluginSveltekitLibraryOptions {
 	/**
 	 * The options passed to the SvelteKit packaging CLI.
 	 * @see https://kit.svelte.dev/docs/packaging#options
 	 */
-	svelte_package_options?: Svelte_Package_Options;
+	svelte_package_options?: SveltePackageOptions;
 	/**
 	 * The SvelteKit packaging CLI to use. Defaults to `svelte-package`.
 	 * @see https://kit.svelte.dev/docs/packaging
@@ -22,7 +22,7 @@ export interface Gro_Plugin_Sveltekit_Library_Options {
 export const gro_plugin_sveltekit_library = ({
 	svelte_package_options,
 	svelte_package_cli = SVELTE_PACKAGE_CLI,
-}: Gro_Plugin_Sveltekit_Library_Options = {}): Plugin => {
+}: GroPluginSveltekitLibraryOptions = {}): Plugin => {
 	const package_json = load_package_json();
 
 	return {
@@ -52,7 +52,7 @@ export const gro_plugin_sveltekit_library = ({
 				log.info(`linking`);
 				const link_result = await spawn(config.pm_cli, ['link', '-f']); // TODO don't use `-f` unless necessary or at all?
 				if (!link_result.ok) {
-					throw new Task_Error(`Failed to link. ${print_spawn_result(link_result)}`);
+					throw new TaskError(`Failed to link. ${print_spawn_result(link_result)}`);
 				}
 				timing_to_link();
 			}

package/src/lib/index.ts

@@ -1,8 +1,8 @@
 /** @nodocs */
-export type {Gro_Config, Create_Gro_Config, Raw_Gro_Config} from './gro_config.ts';
+export type {GroConfig, CreateGroConfig, RawGroConfig} from './gro_config.ts';
 /** @nodocs */
 export {type Plugin, replace_plugin} from './plugin.ts';
 /** @nodocs */
-export type {Gen, Gen_Context} from './gen.ts';
+export type {Gen, GenContext} from './gen.ts';
 /** @nodocs */
-export {type Task, type Task_Context, Task_Error} from './task.ts';
+export {type Task, type TaskContext, TaskError} from './task.ts';

package/src/lib/input_path.ts

@@ -3,18 +3,18 @@ import {existsSync, statSync} from 'node:fs';
 import {strip_start} from '@ryanatkn/belt/string.js';
 import {z} from 'zod';
 import type {Flavored} from '@ryanatkn/belt/types.js';
-import type {Path_Info, Path_Id, Resolved_Path} from '@ryanatkn/belt/path.js';
+import type {PathInfo, PathId, ResolvedPath} from '@ryanatkn/belt/path.js';
 
 import {GRO_PACKAGE_DIR, GRO_DIST_DIR} from './paths.ts';
 import {search_fs} from './search_fs.ts';
 import {TASK_FILE_SUFFIX_JS} from './task.ts';
 
 // TODO Flavored doesn't work when used in schemas, use Zod brand instead? problem is ergonomics
-export const Input_Path = z.string();
-export type Input_Path = Flavored<z.infer<typeof Input_Path>, 'Input_Path'>;
+export const InputPath = z.string();
+export type InputPath = Flavored<z.infer<typeof InputPath>, 'InputPath'>;
 
-export const Raw_Input_Path = z.string();
-export type Raw_Input_Path = Flavored<z.infer<typeof Raw_Input_Path>, 'Raw_Input_Path'>;
+export const RawInputPath = z.string();
+export type RawInputPath = Flavored<z.infer<typeof RawInputPath>, 'RawInputPath'>;
 
 /**
  * Raw input paths are paths that users provide to Gro to reference files for tasks and gen.
@@ -29,26 +29,26 @@ export type Raw_Input_Path = Flavored<z.infer<typeof Raw_Input_Path>, 'Raw_Input
  * Thus, input paths are either absolute or implicitly relative.
  */
 export const to_input_path = (
-	raw_input_path: Raw_Input_Path,
+	raw_input_path: RawInputPath,
 	root_path = process.cwd(), // TODO @many isn't passed in anywhere, maybe hoist to `invoke_task` and others
-): Input_Path => {
+): InputPath => {
 	if (raw_input_path.startsWith(GRO_PACKAGE_DIR)) {
 		return GRO_DIST_DIR + strip_start(raw_input_path, GRO_PACKAGE_DIR);
 	} else if (raw_input_path[0] === '.') {
 		return resolve(root_path, raw_input_path);
 	}
-	return raw_input_path as Input_Path;
+	return raw_input_path as InputPath;
 };
 
 export const to_input_paths = (
-	raw_input_paths: Array<Raw_Input_Path>,
+	raw_input_paths: Array<RawInputPath>,
 	root_path?: string, // TODO @many isn't passed in anywhere, maybe hoist to `invoke_task` and others
-): Array<Input_Path> => raw_input_paths.map((p) => to_input_path(p, root_path));
+): Array<InputPath> => raw_input_paths.map((p) => to_input_path(p, root_path));
 
-export interface Possible_Path {
-	id: Path_Id;
-	input_path: Input_Path;
-	root_dir: Path_Id;
+export interface PossiblePath {
+	id: PathId;
+	input_path: InputPath;
+	root_dir: PathId;
 }
 
 /**
@@ -56,24 +56,24 @@ export interface Possible_Path {
  * duplicating each under `root_dirs`, without checking the filesystem.
  */
 export const get_possible_paths = (
-	input_path: Input_Path,
-	root_dirs: Array<Path_Id>,
+	input_path: InputPath,
+	root_dirs: Array<PathId>,
 	extensions: Array<string>,
-): Array<Possible_Path> => {
-	const possible_paths: Set<Possible_Path> = new Set();
+): Array<PossiblePath> => {
+	const possible_paths: Set<PossiblePath> = new Set();
 
-	const add_possible_paths = (path: string, root_dir: Path_Id) => {
+	const add_possible_paths = (path: string, root_dir: PathId) => {
 		// Specifically for paths to the Gro package dist, optimize by only looking for `.task.js`.
 		if (path.startsWith(GRO_DIST_DIR)) {
 			possible_paths.add({
 				id: (path.endsWith('/') || path.endsWith(TASK_FILE_SUFFIX_JS)
 					? path
-					: path + TASK_FILE_SUFFIX_JS) as Path_Id,
+					: path + TASK_FILE_SUFFIX_JS) as PathId,
 				input_path,
 				root_dir,
 			});
 		} else {
-			possible_paths.add({id: path as Path_Id, input_path, root_dir});
+			possible_paths.add({id: path as PathId, input_path, root_dir});
 			if (!path.endsWith('/') && !extensions.some((e) => path.endsWith(e))) {
 				for (const extension of extensions) {
 					possible_paths.add({id: path + extension, input_path, root_dir});
@@ -99,23 +99,23 @@ export const get_possible_paths = (
 	return Array.from(possible_paths);
 };
 
-export interface Resolved_Input_Path {
-	input_path: Input_Path;
-	id: Path_Id;
+export interface ResolvedInputPath {
+	input_path: InputPath;
+	id: PathId;
 	is_directory: boolean;
-	root_dir: Path_Id;
+	root_dir: PathId;
 }
 
-export interface Resolved_Input_File {
-	id: Path_Id;
-	input_path: Input_Path;
-	resolved_input_path: Resolved_Input_Path;
+export interface ResolvedInputFile {
+	id: PathId;
+	input_path: InputPath;
+	resolved_input_path: ResolvedInputPath;
 }
 
-export interface Resolved_Input_Paths {
-	resolved_input_paths: Array<Resolved_Input_Path>;
-	possible_paths_by_input_path: Map<Input_Path, Array<Possible_Path>>;
-	unmapped_input_paths: Array<Input_Path>;
+export interface ResolvedInputPaths {
+	resolved_input_paths: Array<ResolvedInputPath>;
+	possible_paths_by_input_path: Map<InputPath, Array<PossiblePath>>;
+	unmapped_input_paths: Array<InputPath>;
 }
 
 /**
@@ -124,16 +124,16 @@ export interface Resolved_Input_Paths {
  * If none is found for an input path, it's added to `unmapped_input_paths`.
  */
 export const resolve_input_paths = (
-	input_paths: Array<Input_Path>,
-	root_dirs: Array<Path_Id>,
+	input_paths: Array<InputPath>,
+	root_dirs: Array<PathId>,
 	extensions: Array<string>,
-): Resolved_Input_Paths => {
-	const resolved_input_paths: Array<Resolved_Input_Path> = [];
-	const possible_paths_by_input_path: Map<Input_Path, Array<Possible_Path>> = new Map();
-	const unmapped_input_paths: Array<Input_Path> = [];
+): ResolvedInputPaths => {
+	const resolved_input_paths: Array<ResolvedInputPath> = [];
+	const possible_paths_by_input_path: Map<InputPath, Array<PossiblePath>> = new Map();
+	const unmapped_input_paths: Array<InputPath> = [];
 	for (const input_path of input_paths) {
-		let found_file: [Path_Info, Possible_Path] | null = null;
-		let found_dirs: Array<[Path_Info, Possible_Path]> | null = null;
+		let found_file: [PathInfo, PossiblePath] | null = null;
+		let found_dirs: Array<[PathInfo, PossiblePath]> | null = null;
 		const possible_paths = get_possible_paths(input_path, root_dirs, extensions);
 		possible_paths_by_input_path.set(input_path, possible_paths);
 
@@ -176,10 +176,10 @@ export const resolve_input_paths = (
 	};
 };
 
-export interface Resolved_Input_Files {
-	resolved_input_files: Array<Resolved_Input_File>;
-	resolved_input_files_by_root_dir: Map<Path_Id, Array<Resolved_Input_File>>;
-	input_directories_with_no_files: Array<Input_Path>;
+export interface ResolvedInputFiles {
+	resolved_input_files: Array<ResolvedInputFile>;
+	resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+	input_directories_with_no_files: Array<InputPath>;
 }
 
 /**
@@ -187,15 +187,15 @@ export interface Resolved_Input_Files {
  * De-dupes source ids.
  */
 export const resolve_input_files = (
-	resolved_input_paths: Array<Resolved_Input_Path>,
-	search: (dir: string) => Array<Resolved_Path> = search_fs,
-): Resolved_Input_Files => {
-	const resolved_input_files: Array<Resolved_Input_File> = [];
+	resolved_input_paths: Array<ResolvedInputPath>,
+	search: (dir: string) => Array<ResolvedPath> = search_fs,
+): ResolvedInputFiles => {
+	const resolved_input_files: Array<ResolvedInputFile> = [];
 	// Add all input paths initially, and remove each when resolved to a file.
-	const existing_path_ids: Set<Path_Id> = new Set();
+	const existing_path_ids: Set<PathId> = new Set();
 
 	let remaining = resolved_input_paths.slice();
-	const handle_found = (input_path: Input_Path, id: Path_Id) => {
+	const handle_found = (input_path: InputPath, id: PathId) => {
 		remaining = remaining.filter(
 			(r) => !(r.id === id || r.input_path === input_path || r.input_path === id), // `r.input_path === id` may be unnecessary
 		);
@@ -208,7 +208,7 @@ export const resolve_input_files = (
 			// Handle input paths that resolve to directories.
 			const files = search(id);
 			if (!files.length) continue;
-			const path_ids: Array<Path_Id> = [];
+			const path_ids: Array<PathId> = [];
 			for (const {path, is_directory} of files) {
 				if (is_directory) continue;
 				const path_id = join(id, path);
@@ -219,9 +219,9 @@ export const resolve_input_files = (
 				handle_found(input_path, path_id);
 			}
 			if (!path_ids.length) continue;
-			const resolved_input_files_for_input_path: Array<Resolved_Input_File> = [];
+			const resolved_input_files_for_input_path: Array<ResolvedInputFile> = [];
 			for (const path_id of path_ids) {
-				const resolved_input_file: Resolved_Input_File = {
+				const resolved_input_file: ResolvedInputFile = {
 					id: path_id,
 					input_path,
 					resolved_input_path,
@@ -233,7 +233,7 @@ export const resolve_input_files = (
 			if (!existing_path_ids.has(id)) {
 				// Handle input paths that resolve to files.
 				existing_path_ids.add(id);
-				const resolved_input_file: Resolved_Input_File = {id, input_path, resolved_input_path};
+				const resolved_input_file: ResolvedInputFile = {id, input_path, resolved_input_path};
 				resolved_input_files.push(resolved_input_file);
 			}
 			handle_found(input_path, id);
@@ -249,7 +249,7 @@ export const resolve_input_files = (
 				map.set(root_dir, [resolved_input_file]);
 			}
 			return map;
-		}, new Map<Path_Id, Array<Resolved_Input_File>>()),
+		}, new Map<PathId, Array<ResolvedInputFile>>()),
 		input_directories_with_no_files: remaining.map((r) => r.input_path),
 	};
 };

package/src/lib/invoke.ts

@@ -19,8 +19,8 @@ and the rest of the args are forwarded to the task's `run` function.
 
 // handle uncaught errors
 attach_process_error_handlers(
-	(err) => (err.constructor.name === 'Task_Error' ? 'Task_Error' : null),
-	(err) => (err.constructor.name === 'Silent_Error' ? '' : null),
+	(err) => (err.constructor.name === 'TaskError' ? 'TaskError' : null),
+	(err) => (err.constructor.name === 'SilentError' ? '' : null),
 );
 
 if (!process.env.NO_COLOR) {

package/src/lib/invoke_task.ts

@@ -5,11 +5,11 @@ import {Logger} from '@ryanatkn/belt/log.js';
 
 import {to_forwarded_args, type Args} from './args.ts';
 import {run_task} from './run_task.ts';
-import {to_input_path, Raw_Input_Path} from './input_path.ts';
-import {find_tasks, load_tasks, Silent_Error} from './task.ts';
+import {to_input_path, RawInputPath} from './input_path.ts';
+import {find_tasks, load_tasks, SilentError} from './task.ts';
 import {load_gro_package_json} from './package_json.ts';
 import {log_tasks, log_error_reasons} from './task_logging.ts';
-import type {Gro_Config} from './gro_config.ts';
+import type {GroConfig} from './gro_config.ts';
 import {Filer} from './filer.ts';
 
 /**
@@ -35,9 +35,9 @@ import {Filer} from './filer.ts';
  * @param initial_timings - The timings to use for the top-level task, `null` for composed tasks.
  */
 export const invoke_task = async (
-	task_name: Raw_Input_Path,
+	task_name: RawInputPath,
 	args: Args | undefined,
-	config: Gro_Config,
+	config: GroConfig,
 	initial_filer?: Filer,
 	initial_timings?: Timings | null,
 	parent_log?: Logger,
@@ -84,7 +84,7 @@ export const invoke_task = async (
 	const found = find_tasks([input_path], task_root_dirs, config);
 	if (!found.ok) {
 		log_error_reasons(log, found.reasons);
-		throw new Silent_Error();
+		throw new SilentError();
 	}
 
 	// Found a match either in the current working directory or Gro's directory.
@@ -95,7 +95,7 @@ export const invoke_task = async (
 	const loaded = await load_tasks(found_tasks);
 	if (!loaded.ok) {
 		log_error_reasons(log, loaded.reasons);
-		throw new Silent_Error();
+		throw new SilentError();
 	}
 	const loaded_tasks = loaded.value;
 

package/src/lib/lint.task.ts

@@ -1,7 +1,7 @@
 import {print_spawn_result} from '@ryanatkn/belt/process.js';
 import {z} from 'zod';
 
-import {Task_Error, type Task} from './task.ts';
+import {TaskError, type Task} from './task.ts';
 import {serialize_args, to_forwarded_args} from './args.ts';
 import {find_cli, spawn_cli} from './cli.ts';
 
@@ -32,7 +32,7 @@ export const task: Task<Args> = {
 		const serialized_args = serialize_args(forwarded_args);
 		const eslintResult = await spawn_cli(found_eslint_cli, serialized_args, log);
 		if (!eslintResult?.ok) {
-			throw new Task_Error(`ESLint found some problems. ${print_spawn_result(eslintResult!)}`);
+			throw new TaskError(`ESLint found some problems. ${print_spawn_result(eslintResult!)}`);
 		}
 	},
 };

package/src/lib/modules.ts

@@ -1,37 +1,37 @@
 import type {Timings} from '@ryanatkn/belt/timings.js';
-import {Unreachable_Error} from '@ryanatkn/belt/error.js';
+import {UnreachableError} from '@ryanatkn/belt/error.js';
 import type {Result} from '@ryanatkn/belt/result.js';
 import {print_error} from '@ryanatkn/belt/print.js';
 import {pathToFileURL} from 'node:url';
-import type {Path_Id} from '@ryanatkn/belt/path.js';
+import type {PathId} from '@ryanatkn/belt/path.js';
 
-import type {Resolved_Input_File} from './input_path.ts';
+import type {ResolvedInputFile} from './input_path.ts';
 import {print_path} from './paths.ts';
 
-export interface Module_Meta<T_Module extends Record<string, any> = Record<string, any>> {
-	id: Path_Id;
-	mod: T_Module;
+export interface ModuleMeta<TModule extends Record<string, any> = Record<string, any>> {
+	id: PathId;
+	mod: TModule;
 }
 
-export type Load_Module_Result<T_Module> = Result<
-	{id: Path_Id; mod: T_Module},
-	Load_Module_Failure
+export type LoadModuleResult<TModule> = Result<
+	{id: PathId; mod: TModule},
+	LoadModuleFailure
 >;
-export type Load_Module_Failure =
-	| {ok: false; type: 'failed_import'; id: Path_Id; error: Error}
+export type LoadModuleFailure =
+	| {ok: false; type: 'failed_import'; id: PathId; error: Error}
 	| {
 			ok: false;
 			type: 'failed_validation';
-			id: Path_Id;
+			id: PathId;
 			mod: Record<string, any>;
 			validation: string;
 	  };
 
-export const load_module = async <T_Module extends Record<string, any>>(
-	id: Path_Id,
-	validate?: (mod: Record<string, any>) => mod is T_Module,
+export const load_module = async <TModule extends Record<string, any>>(
+	id: PathId,
+	validate?: (mod: Record<string, any>) => mod is TModule,
 	bust_cache?: boolean,
-): Promise<Load_Module_Result<T_Module>> => {
+): Promise<LoadModuleResult<TModule>> => {
 	let mod;
 	try {
 		let import_path = id;
@@ -50,34 +50,34 @@ export const load_module = async <T_Module extends Record<string, any>>(
 	return {ok: true, id, mod};
 };
 
-export interface Load_Modules_Failure<T_Module_Meta extends Module_Meta> {
+export interface LoadModulesFailure<TModuleMeta extends ModuleMeta> {
 	type: 'load_module_failures';
-	load_module_failures: Array<Load_Module_Failure>;
+	load_module_failures: Array<LoadModuleFailure>;
 	reasons: Array<string>;
 	// still return the modules and timings, deferring to the caller
-	modules: Array<T_Module_Meta>;
+	modules: Array<TModuleMeta>;
 }
 
-export type Load_Modules_Result<T_Module_Meta extends Module_Meta> = Result<
+export type LoadModulesResult<TModuleMeta extends ModuleMeta> = Result<
 	{
-		modules: Array<T_Module_Meta>;
+		modules: Array<TModuleMeta>;
 	},
-	Load_Modules_Failure<T_Module_Meta>
+	LoadModulesFailure<TModuleMeta>
 >;
 
 // TODO parallelize and sort afterwards
 export const load_modules = async <
-	T_Module extends Record<string, any>,
-	T_Module_Meta extends Module_Meta<T_Module>,
+	TModule extends Record<string, any>,
+	TModuleMeta extends ModuleMeta<TModule>,
 >(
-	resolved_input_files: Array<Resolved_Input_File>,
-	validate: (mod: any) => mod is T_Module,
-	map_module_meta: (resolved_input_file: Resolved_Input_File, mod: T_Module) => T_Module_Meta,
+	resolved_input_files: Array<ResolvedInputFile>,
+	validate: (mod: any) => mod is TModule,
+	map_module_meta: (resolved_input_file: ResolvedInputFile, mod: TModule) => TModuleMeta,
 	timings?: Timings,
-): Promise<Load_Modules_Result<T_Module_Meta>> => {
+): Promise<LoadModulesResult<TModuleMeta>> => {
 	const timing_to_load_modules = timings?.start('load modules');
-	const modules: Array<T_Module_Meta> = [];
-	const load_module_failures: Array<Load_Module_Failure> = [];
+	const modules: Array<TModuleMeta> = [];
+	const load_module_failures: Array<LoadModuleFailure> = [];
 	const reasons: Array<string> = [];
 	for (const resolved_input_file of resolved_input_files.values()) {
 		const {id, input_path} = resolved_input_file;
@@ -100,7 +100,7 @@ export const load_modules = async <
 					break;
 				}
 				default:
-					throw new Unreachable_Error(result);
+					throw new UnreachableError(result);
 			}
 		}
 	}