@ryanatkn/gro 0.176.0 → 0.177.1

package/src/lib/package_json.ts

@@ -4,7 +4,7 @@ import {readFileSync, writeFileSync} from 'node:fs';
 import {plural, strip_end} from '@ryanatkn/belt/string.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
 import {styleText as st} from 'node:util';
-import {Package_Json, Package_Json_Exports} from '@ryanatkn/belt/package_json.js';
+import {PackageJson, PackageJsonExports} from '@ryanatkn/belt/package_json.js';
 
 import {paths, gro_paths, IS_THIS_GRO} from './paths.ts';
 import {
@@ -20,19 +20,19 @@ import {search_fs} from './search_fs.ts';
 import {has_sveltekit_library} from './sveltekit_helpers.ts';
 import {GITHUB_REPO_MATCHER} from './github.ts';
 
-export type Package_Json_Mapper = (
-	package_json: Package_Json,
-) => Package_Json | null | Promise<Package_Json | null>;
+export type PackageJsonMapper = (
+	package_json: PackageJson,
+) => PackageJson | null | Promise<PackageJson | null>;
 
-export const EMPTY_PACKAGE_JSON: Package_Json = {name: '', version: ''};
+export const EMPTY_PACKAGE_JSON: PackageJson = {name: '', version: ''};
 
 export const load_package_json = (
 	dir = IS_THIS_GRO ? gro_paths.root : paths.root,
-	cache?: Record<string, Package_Json>,
+	cache?: Record<string, PackageJson>,
 	parse = true, // TODO pass `false` here in more places, especially anything perf-sensitive like work on startup
 	log?: Logger,
-): Package_Json => {
-	let package_json: Package_Json;
+): PackageJson => {
+	let package_json: PackageJson;
 	if (cache && dir in cache) {
 		return cache[dir]!;
 	}
@@ -43,7 +43,7 @@ export const load_package_json = (
 		return EMPTY_PACKAGE_JSON;
 	}
 	if (parse) {
-		package_json = parse_package_json(Package_Json, package_json);
+		package_json = parse_package_json(PackageJson, package_json);
 	}
 	if (cache) {
 		cache[dir] = package_json;
@@ -52,12 +52,12 @@ export const load_package_json = (
 };
 
 export const sync_package_json = async (
-	map_package_json: Package_Json_Mapper,
+	map_package_json: PackageJsonMapper,
 	log: Logger,
 	write = true,
 	dir = paths.root,
 	exports_dir = paths.lib,
-): Promise<{package_json: Package_Json | null; changed: boolean}> => {
+): Promise<{package_json: PackageJson | null; changed: boolean}> => {
 	const exported_files = search_fs(exports_dir);
 	const exported_paths = exported_files.map((f) => f.path);
 	const updated = await update_package_json(
@@ -66,7 +66,7 @@ export const sync_package_json = async (
 				package_json.exports = to_package_exports(exported_paths);
 			}
 			const mapped = await map_package_json(package_json);
-			return mapped ? parse_package_json(Package_Json, mapped) : mapped;
+			return mapped ? parse_package_json(PackageJson, mapped) : mapped;
 		},
 		dir,
 		write,
@@ -85,7 +85,7 @@ export const sync_package_json = async (
 	return updated;
 };
 
-export const load_gro_package_json = (): Package_Json => load_package_json(gro_paths.root);
+export const load_gro_package_json = (): PackageJson => load_package_json(gro_paths.root);
 
 // TODO probably make this nullable and make callers handle failures
 const load_package_json_contents = (dir: string): string =>
@@ -95,17 +95,17 @@ export const write_package_json = (serialized_package_json: string): void => {
 	writeFileSync(join(paths.root, PACKAGE_JSON_FILENAME), serialized_package_json);
 };
 
-export const serialize_package_json = (package_json: Package_Json): string =>
-	JSON.stringify(parse_package_json(Package_Json, package_json), null, 2) + '\n';
+export const serialize_package_json = (package_json: PackageJson): string =>
+	JSON.stringify(parse_package_json(PackageJson, package_json), null, 2) + '\n';
 
 /**
  * Updates package.json. Writes to the filesystem only when contents change.
  */
 export const update_package_json = async (
-	update: (package_json: Package_Json) => Package_Json | null | Promise<Package_Json | null>,
+	update: (package_json: PackageJson) => PackageJson | null | Promise<PackageJson | null>,
 	dir = paths.root,
 	write = true,
-): Promise<{package_json: Package_Json | null; changed: boolean}> => {
+): Promise<{package_json: PackageJson | null; changed: boolean}> => {
 	const original_contents = load_package_json_contents(dir);
 	const original = JSON.parse(original_contents);
 	const updated = await update(original);
@@ -122,14 +122,14 @@ export const update_package_json = async (
 
 const is_index = (path: string): boolean => path === 'index.ts' || path === 'index.js';
 
-export const to_package_exports = (paths: Array<string>): Package_Json_Exports => {
+export const to_package_exports = (paths: Array<string>): PackageJsonExports => {
 	const has_index = paths.some(is_index);
 	const has_js = paths.some((p) => TS_MATCHER.test(p) || JS_MATCHER.test(p));
 	const has_svelte = paths.some((p) => SVELTE_MATCHER.test(p));
 	const has_json = paths.some((p) => JSON_MATCHER.test(p));
 	const has_css = paths.some((p) => CSS_MATCHER.test(p));
 
-	const exports: Package_Json_Exports = {
+	const exports: PackageJsonExports = {
 		'./package.json': './package.json',
 	};
 
@@ -172,13 +172,13 @@ export const to_package_exports = (paths: Array<string>): Package_Json_Exports =
 		};
 	}
 
-	return parse_or_throw_formatted_error('package.json#exports', Package_Json_Exports, exports);
+	return parse_or_throw_formatted_error('package.json#exports', PackageJsonExports, exports);
 };
 
 const IMPORT_PREFIX = './' + SVELTEKIT_DIST_DIRNAME + '/';
 
 export const parse_repo_url = (
-	package_json: Package_Json,
+	package_json: PackageJson,
 ): {owner: string; repo: string} | undefined => {
 	const {repository} = package_json;
 	const repo_url = repository
@@ -198,9 +198,9 @@ export const parse_repo_url = (
 };
 
 /**
- * Parses a `Package_Json` object but preserves the order of the original keys.
+ * Parses a `PackageJson` object but preserves the order of the original keys.
  */
-const parse_package_json = (schema: typeof Package_Json, value: any): Package_Json => {
+const parse_package_json = (schema: typeof PackageJson, value: any): PackageJson => {
 	const parsed = parse_or_throw_formatted_error(PACKAGE_JSON_FILENAME, schema, value);
 	const keys = Object.keys(value);
 	return Object.fromEntries(
@@ -227,19 +227,19 @@ const parse_or_throw_formatted_error = <T extends z.ZodType>(
 
 export const has_dep = (
 	dep_name: string,
-	package_json: Package_Json = load_package_json(),
+	package_json: PackageJson = load_package_json(),
 ): boolean =>
 	!!package_json.devDependencies?.[dep_name] ||
 	!!package_json.dependencies?.[dep_name] ||
 	!!package_json.peerDependencies?.[dep_name];
 
-export interface Package_Json_Dep {
+export interface PackageJsonDep {
 	name: string;
 	version: string;
 }
 
-export const extract_deps = (package_json: Package_Json): Array<Package_Json_Dep> => {
-	const deps_by_name: Map<string, Package_Json_Dep> = new Map();
+export const extract_deps = (package_json: PackageJson): Array<PackageJsonDep> => {
+	const deps_by_name: Map<string, PackageJsonDep> = new Map();
 	// Earlier versions override later ones, so peer deps goes last.
 	const add_deps = (deps: Record<string, string> | undefined) => {
 		if (!deps) return;

package/src/lib/parse_exports.ts

@@ -2,28 +2,28 @@ import ts from 'typescript';
 import {extname} from 'node:path';
 import type {Flavored} from '@ryanatkn/belt/types.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
-import type {Identifier_Kind} from '@ryanatkn/belt/src_json.js';
-import type {Path_Id} from '@ryanatkn/belt/path.js';
+import type {IdentifierKind} from '@ryanatkn/belt/src_json.js';
+import type {PathId} from '@ryanatkn/belt/path.js';
 
 import {TS_MATCHER} from './constants.ts';
-import {Parse_Exports_Context} from './parse_exports_context.ts';
+import {ParseExportsContext} from './parse_exports_context.ts';
 
 export interface Declaration {
 	name: string;
-	kind: Identifier_Kind | null;
+	kind: IdentifierKind | null;
 }
 
-export type Export_Declaration = Flavored<Declaration, 'Export_Declaration'>;
+export type ExportDeclaration = Flavored<Declaration, 'ExportDeclaration'>;
 
 /**
  * Parse exports from a file based on its file type and content.
  */
 export const parse_exports = (
-	id: Path_Id,
+	id: PathId,
 	program?: ts.Program,
-	declarations: Array<Export_Declaration> = [],
+	declarations: Array<ExportDeclaration> = [],
 	log?: Logger,
-): Array<Export_Declaration> => {
+): Array<ExportDeclaration> => {
 	// First, infer declarations based on file extension
 	infer_declarations_from_file_type(id, declarations);
 
@@ -42,7 +42,7 @@ export const parse_exports = (
 		const exports = checker.getExportsOfModule(symbol);
 
 		// Process TypeScript declarations
-		const export_context = new Parse_Exports_Context(program, log);
+		const export_context = new ParseExportsContext(program, log);
 		export_context.analyze_source_file(source_file);
 		export_context.process_exports(source_file, exports, declarations);
 	}
@@ -52,9 +52,9 @@ export const parse_exports = (
 
 // TODO temporary until proper type inference
 export const infer_declarations_from_file_type = (
-	file_path: Path_Id,
-	declarations: Array<Export_Declaration> = [],
-): Array<Export_Declaration> => {
+	file_path: PathId,
+	declarations: Array<ExportDeclaration> = [],
+): Array<ExportDeclaration> => {
 	const extension = extname(file_path).toLowerCase();
 
 	switch (extension) {
@@ -91,10 +91,10 @@ export const process_ts_exports = (
 	source_file: ts.SourceFile,
 	program: ts.Program,
 	exports: Array<ts.Symbol>,
-	declarations: Array<Export_Declaration> = [],
+	declarations: Array<ExportDeclaration> = [],
 	log?: Logger,
-): Array<Export_Declaration> => {
-	const export_context = new Parse_Exports_Context(program, log);
+): Array<ExportDeclaration> => {
+	const export_context = new ParseExportsContext(program, log);
 	export_context.analyze_source_file(source_file);
 	return export_context.process_exports(source_file, exports, declarations);
 };

package/src/lib/parse_exports_context.ts

@@ -1,19 +1,19 @@
 import ts from 'typescript';
 import type {Logger} from '@ryanatkn/belt/log.js';
-import type {Identifier_Kind} from '@ryanatkn/belt/src_json.js';
+import type {IdentifierKind} from '@ryanatkn/belt/src_json.js';
 
-import type {Export_Declaration} from './parse_exports.ts';
+import type {ExportDeclaration} from './parse_exports.ts';
 
 /**
  * A class to track export context and determine export kinds.
  */
-export class Parse_Exports_Context {
+export class ParseExportsContext {
 	readonly #checker: ts.TypeChecker;
 
 	// Map of source file paths to their symbols
 	readonly #file_symbols: Map<string, ts.Symbol> = new Map();
 	// Cache for resolved symbols to avoid repeated resolution
-	readonly #symbol_kind_cache: Map<ts.Symbol, Identifier_Kind> = new Map();
+	readonly #symbol_kind_cache: Map<ts.Symbol, IdentifierKind> = new Map();
 
 	readonly log: Logger | undefined;
 	debug = process.env.DEBUG_EXPORTS === 'true';
@@ -56,8 +56,8 @@ export class Parse_Exports_Context {
 	process_exports(
 		source_file: ts.SourceFile,
 		exports: Array<ts.Symbol>,
-		declarations: Array<Export_Declaration> = [],
-	): Array<Export_Declaration> {
+		declarations: Array<ExportDeclaration> = [],
+	): Array<ExportDeclaration> {
 		for (const export_symbol of exports) {
 			const name = export_symbol.name;
 			this.#log(`Determining kind for export: ${name}`);
@@ -75,7 +75,7 @@ export class Parse_Exports_Context {
 	/**
 	 * Determine the kind of an export based on its symbol.
 	 */
-	#determine_export_kind(source_file: ts.SourceFile, symbol: ts.Symbol): Identifier_Kind {
+	#determine_export_kind(source_file: ts.SourceFile, symbol: ts.Symbol): IdentifierKind {
 		// Check if this is a type-only export (no value export)
 		if (this.#is_type_only_export(source_file, symbol)) {
 			return 'type';
@@ -115,7 +115,7 @@ export class Parse_Exports_Context {
 	/**
 	 * Infer the declaration kind from a symbol's declaration and type information.
 	 */
-	#infer_declaration_kind(symbol: ts.Symbol): Identifier_Kind {
+	#infer_declaration_kind(symbol: ts.Symbol): IdentifierKind {
 		// Check symbol flags first for direct type matching
 		if (this.#is_class_symbol(symbol)) {
 			return 'class';
@@ -182,7 +182,7 @@ export class Parse_Exports_Context {
 	/**
 	 * Infer the declaration kind from a specific declaration node.
 	 */
-	#infer_kind_from_declaration(decl: ts.Declaration): Identifier_Kind | null {
+	#infer_kind_from_declaration(decl: ts.Declaration): IdentifierKind | null {
 		if (ts.isFunctionDeclaration(decl)) {
 			return 'function';
 		}

package/src/lib/parse_imports.ts

@@ -1,11 +1,11 @@
 import {parseSync, type ImportDeclaration} from 'oxc-parser';
 import type {Flavored} from '@ryanatkn/belt/types.js';
-import {Unreachable_Error} from '@ryanatkn/belt/error.js';
-import type {Path_Id} from '@ryanatkn/belt/path.js';
+import {UnreachableError} from '@ryanatkn/belt/error.js';
+import type {PathId} from '@ryanatkn/belt/path.js';
 
 import {JS_MATCHER, TS_MATCHER, SVELTE_MATCHER, SVELTE_SCRIPT_MATCHER} from './constants.ts';
 
-export type Import_Specifier = Flavored<string, 'Import_Specifier'>;
+export type ImportSpecifier = Flavored<string, 'ImportSpecifier'>;
 
 // TODO this is probably way more complicated that it should be, maybe report the issues upstream unless I made a mistake here
 
@@ -31,10 +31,10 @@ const extract_string_literal = (content: string, start: number, end: number): st
 };
 
 export const parse_imports = (
-	id: Path_Id,
+	id: PathId,
 	contents: string,
 	ignore_types = true,
-): Array<Import_Specifier> => {
+): Array<ImportSpecifier> => {
 	const specifiers: Array<string> = [];
 	const is_svelte = SVELTE_MATCHER.test(id);
 
@@ -129,7 +129,7 @@ export const parse_imports = (
 						specifiers.push(value);
 					}
 				} else {
-					throw new Unreachable_Error(node.source.type);
+					throw new UnreachableError(node.source.type);
 				}
 			}
 		}

package/src/lib/paths.ts

@@ -2,7 +2,7 @@ import {join, extname, relative, basename} from 'node:path';
 import {fileURLToPath} from 'node:url';
 import {ensure_end, strip_end} from '@ryanatkn/belt/string.js';
 import {styleText as st} from 'node:util';
-import type {Path_Id} from '@ryanatkn/belt/path.js';
+import type {PathId} from '@ryanatkn/belt/path.js';
 
 import {
 	GRO_CONFIG_FILENAME,
@@ -53,22 +53,22 @@ export const create_paths = (root_dir: string): Paths => {
 	};
 };
 
-export const infer_paths = (id: Path_Id): Paths => (is_gro_id(id) ? gro_paths : paths);
+export const infer_paths = (id: PathId): Paths => (is_gro_id(id) ? gro_paths : paths);
 
-export const is_gro_id = (id: Path_Id): boolean =>
+export const is_gro_id = (id: PathId): boolean =>
 	id.startsWith(gro_paths.root) || gro_paths.root === ensure_end(id, '/');
 
 // '/home/me/app/src/foo/bar/baz.ts' → 'src/foo/bar/baz.ts'
-export const to_root_path = (id: Path_Id, p = infer_paths(id)): string =>
+export const to_root_path = (id: PathId, p = infer_paths(id)): string =>
 	relative(p.root, id) || './';
 
 // '/home/me/app/src/foo/bar/baz.ts' → 'foo/bar/baz.ts'
-export const path_id_to_base_path = (path_id: Path_Id, p = infer_paths(path_id)): string =>
+export const path_id_to_base_path = (path_id: PathId, p = infer_paths(path_id)): string =>
 	relative(p.source, path_id);
 
 // TODO base_path is an obsolete concept, it was a remnant from forcing `src/`
 // 'foo/bar/baz.ts' → '/home/me/app/src/foo/bar/baz.ts'
-export const base_path_to_path_id = (base_path: string, p = infer_paths(base_path)): Path_Id =>
+export const base_path_to_path_id = (base_path: string, p = infer_paths(base_path)): PathId =>
 	join(p.source, base_path);
 
 export const print_path = (path: string, p = infer_paths(path)): string => {

package/src/lib/plugin.ts

@@ -1,38 +1,38 @@
-import type {Task_Context} from './task.ts';
+import type {TaskContext} from './task.ts';
 
 /**
  * Gro `Plugin`s enable custom behavior during `gro dev` and `gro build`.
  * In contrast, `Adapter`s use the results of `gro build` to produce final artifacts.
  */
-export interface Plugin<T_Plugin_Context extends Plugin_Context = Plugin_Context> {
+export interface Plugin<TPluginContext extends PluginContext = PluginContext> {
 	name: string;
-	setup?: (ctx: T_Plugin_Context) => void | Promise<void>;
-	adapt?: (ctx: T_Plugin_Context) => void | Promise<void>;
-	teardown?: (ctx: T_Plugin_Context) => void | Promise<void>;
+	setup?: (ctx: TPluginContext) => void | Promise<void>;
+	adapt?: (ctx: TPluginContext) => void | Promise<void>;
+	teardown?: (ctx: TPluginContext) => void | Promise<void>;
 }
 
-export type Create_Config_Plugins<T_Plugin_Context extends Plugin_Context = Plugin_Context> = (
-	ctx: T_Plugin_Context,
-) => Array<Plugin<T_Plugin_Context>> | Promise<Array<Plugin<T_Plugin_Context>>>;
+export type CreateConfigPlugins<TPluginContext extends PluginContext = PluginContext> = (
+	ctx: TPluginContext,
+) => Array<Plugin<TPluginContext>> | Promise<Array<Plugin<TPluginContext>>>;
 
-export interface Plugin_Context<T_Args = object> extends Task_Context<T_Args> {
+export interface PluginContext<TArgs = object> extends TaskContext<TArgs> {
 	dev: boolean;
 	watch: boolean;
 }
 
 /** See `Plugins.create` for a usage example. */
-export class Plugins<T_Plugin_Context extends Plugin_Context> {
-	readonly ctx: T_Plugin_Context;
-	readonly instances: Array<Plugin<T_Plugin_Context>>;
+export class Plugins<TPluginContext extends PluginContext> {
+	readonly ctx: TPluginContext;
+	readonly instances: Array<Plugin<TPluginContext>>;
 
-	constructor(ctx: T_Plugin_Context, instances: Array<Plugin>) {
+	constructor(ctx: TPluginContext, instances: Array<Plugin>) {
 		this.ctx = ctx;
 		this.instances = instances;
 	}
 
-	static async create<T_Plugin_Context extends Plugin_Context>(
-		ctx: T_Plugin_Context,
-	): Promise<Plugins<T_Plugin_Context>> {
+	static async create<TPluginContext extends PluginContext>(
+		ctx: TPluginContext,
+	): Promise<Plugins<TPluginContext>> {
 		const {timings} = ctx;
 		const timing_to_create = timings.start('plugins.create');
 		const instances: Array<Plugin> = await ctx.config.plugins(ctx);
@@ -88,7 +88,7 @@ export class Plugins<T_Plugin_Context extends Plugin_Context> {
 /**
  * Replaces a plugin by name in `plugins` without mutating the param.
  * Throws if the plugin name cannot be found.
- * @param plugins - accepts the same types as the return value of `Create_Config_Plugins`
+ * @param plugins - accepts the same types as the return value of `CreateConfigPlugins`
  * @param new_plugin
  * @param name - @default new_plugin.name
  * @returns `plugins` with `new_plugin` at the index of the plugin with `name`

package/src/lib/publish.task.ts

@@ -3,15 +3,15 @@ import {z} from 'zod';
 import {styleText as st} from 'node:util';
 import {existsSync} from 'node:fs';
 import {
-	Git_Branch,
-	Git_Origin,
+	GitBranch,
+	GitOrigin,
 	git_check_clean_workspace,
 	git_checkout,
 	git_fetch,
 	git_pull,
 } from '@ryanatkn/belt/git.js';
 
-import {Task_Error, type Task} from './task.ts';
+import {TaskError, type Task} from './task.ts';
 import {load_package_json, parse_repo_url} from './package_json.ts';
 import {find_cli, spawn_cli} from './cli.ts';
 import {has_sveltekit_library} from './sveltekit_helpers.ts';
@@ -21,8 +21,8 @@ import {CHANGESET_CLI} from './changeset_helpers.ts';
 
 /** @nodocs */
 export const Args = z.strictObject({
-	branch: Git_Branch.describe('branch to publish from').default('main'),
-	origin: Git_Origin.describe('git origin to publish from').default('origin'),
+	branch: GitBranch.describe('branch to publish from').default('main'),
+	origin: GitOrigin.describe('git origin to publish from').default('origin'),
 	changelog: z
 		.string()
 		.meta({description: 'file name and path of the changelog'})
@@ -89,7 +89,7 @@ export const task: Task<Args> = {
 
 		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,
 			);
 		}
@@ -98,7 +98,7 @@ export const task: Task<Args> = {
 
 		const found_changeset_cli = find_cli(changeset_cli);
 		if (!found_changeset_cli) {
-			throw new Task_Error(
+			throw new TaskError(
 				'changeset command not found, install @changesets/cli locally or globally',
 			);
 		}
@@ -108,7 +108,7 @@ export const task: Task<Args> = {
 		await git_checkout(branch);
 		if (pull) {
 			if (await git_check_clean_workspace()) {
-				throw new Task_Error('The git workspace is not clean, pass --no-pull to bypass git pull');
+				throw new TaskError('The git workspace is not clean, pass --no-pull to bypass git pull');
 			}
 			await git_pull(origin, branch);
 		}
@@ -138,11 +138,11 @@ export const task: Task<Args> = {
 			log.info('dry run, skipping changeset version');
 		} else {
 			if (typeof package_json.version !== 'string') {
-				throw new Task_Error('Failed to find package.json version');
+				throw new TaskError('Failed to find package.json version');
 			}
 			const parsed_repo_url = parse_repo_url(package_json);
 			if (!parsed_repo_url) {
-				throw new Task_Error(
+				throw new TaskError(
 					'package.json `repository` must contain a repo url (and GitHub only for now, sorry),' +
 						' like `git+https://github.com/ryanatkn/gro.git` or `https://github.com/ryanatkn/gro`' +
 						' or an object with the `url` key',
@@ -170,7 +170,7 @@ export const task: Task<Args> = {
 			if (install) {
 				const install_result = await spawn(config.pm_cli, ['install']);
 				if (!install_result.ok) {
-					throw new Task_Error(`Failed \`${config.pm_cli} install\` after version bump`);
+					throw new TaskError(`Failed \`${config.pm_cli} install\` after version bump`);
 				}
 			}
 
@@ -187,7 +187,7 @@ export const task: Task<Args> = {
 					optional_and_version_unchanged = true;
 				} else {
 					// Doesn't build if the version didn't change and publishing isn't optional.
-					throw new Task_Error(`\`${changeset_cli} version\` failed: are there any changes?`);
+					throw new TaskError(`\`${changeset_cli} version\` failed: are there any changes?`);
 				}
 			}
 		}
@@ -212,7 +212,7 @@ export const task: Task<Args> = {
 
 		const changeset_publish_result = await spawn_cli(found_changeset_cli, ['publish'], log);
 		if (!changeset_publish_result?.ok) {
-			throw new Task_Error(
+			throw new TaskError(
 				`\`${changeset_cli} publish\` failed - continue manually or try again after running \`git reset --hard\``,
 			);
 		}

package/src/lib/reinstall.task.ts

@@ -2,7 +2,7 @@ import {z} from 'zod';
 import {spawn} from '@ryanatkn/belt/process.js';
 import {rm} from 'node:fs/promises';
 
-import {Task_Error, type Task} from './task.ts';
+import {TaskError, type Task} from './task.ts';
 import {LOCKFILE_FILENAME, NODE_MODULES_DIRNAME} from './constants.ts';
 
 /** @nodocs */
@@ -17,7 +17,7 @@ export const task: Task<Args> = {
 		log.info(`running the initial \`${config.pm_cli} install\``);
 		const initial_install_result = await spawn(config.pm_cli, ['install']);
 		if (!initial_install_result.ok) {
-			throw new Task_Error(`Failed initial \`${config.pm_cli} install\``);
+			throw new TaskError(`Failed initial \`${config.pm_cli} install\``);
 		}
 
 		// Deleting both the lockfile and node_modules upgrades to the latest minor/patch versions.
@@ -27,7 +27,7 @@ export const task: Task<Args> = {
 		);
 		const second_install_result = await spawn(config.pm_cli, ['install']);
 		if (!second_install_result.ok) {
-			throw new Task_Error(
+			throw new TaskError(
 				`Failed \`${config.pm_cli} install\` after deleting ${LOCKFILE_FILENAME} and ${NODE_MODULES_DIRNAME}`,
 			);
 		}
@@ -39,7 +39,7 @@ export const task: Task<Args> = {
 		log.info(`running \`${config.pm_cli} install\` one last time to clean ${LOCKFILE_FILENAME}`);
 		const final_install_result = await spawn(config.pm_cli, ['install']);
 		if (!final_install_result.ok) {
-			throw new Task_Error(`Failed \`${config.pm_cli} install\``);
+			throw new TaskError(`Failed \`${config.pm_cli} install\``);
 		}
 	},
 };

package/src/lib/resolve_specifier.ts

@@ -1,16 +1,16 @@
 import {extname, isAbsolute, join, relative} from 'node:path';
 import {existsSync} from 'node:fs';
-import type {Path_Id} from '@ryanatkn/belt/path.js';
+import type {PathId} from '@ryanatkn/belt/path.js';
 
 import {replace_extension} from './paths.ts';
 
 // TODO ideally this module doesnt exist, but import.meta.resolve doesn't work in loaders last I tried
 
-export interface Resolved_Specifier {
+export interface ResolvedSpecifier {
 	/**
 	 * The resolved filesystem path for the specifier.
 	 */
-	path_id: Path_Id;
+	path_id: PathId;
 	/**
 	 * Same as `path_id` but includes `?raw` and other querystrings. (currently none)
 	 */
@@ -26,14 +26,14 @@ export interface Resolved_Specifier {
  * and infer the correct extension following Vite conventions.
  * If no `.js` file is found for the specifier on the filesystem, it assumes `.ts`.
  */
-export const resolve_specifier = (specifier: string, dir: string): Resolved_Specifier => {
+export const resolve_specifier = (specifier: string, dir: string): ResolvedSpecifier => {
 	const raw = specifier.endsWith('?raw'); // TODO more robust detection? other values?
 	const final_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
 	const absolute_path = isAbsolute(final_specifier) ? final_specifier : join(dir, final_specifier);
 
 	let mapped_path;
 	let path_id;
-	let namespace: Resolved_Specifier['namespace'];
+	let namespace: ResolvedSpecifier['namespace'];
 
 	const ext = extname(absolute_path);
 	const is_js = ext === '.js';

package/src/lib/run.task.ts

@@ -2,9 +2,9 @@ import {z} from 'zod';
 import {styleText as st} from 'node:util';
 import {existsSync} from 'node:fs';
 
-import {Task_Error, type Task} from './task.ts';
+import {TaskError, type Task} from './task.ts';
 import {resolve_gro_module_path, spawn_with_loader} from './gro_helpers.ts';
-import {serialize_args} from './args.ts';
+import {serialize_args, to_implicit_forwarded_args} from './args.ts';
 
 /**
  * Runs a TypeScript file with Gro's loader, forwarding all args to the script.
@@ -40,18 +40,22 @@ export const task: Task<Args> = {
 		}
 
 		if (!existsSync(path)) {
-			throw new Task_Error('Cannot find file to run at path: ' + path);
+			throw new TaskError('Cannot find file to run at path: ' + path);
 		}
 
-		// Reconstruct argv: positional args + serialized named args
-		const named_argv = serialize_args(forwarded_args);
+		// Get args after `--` without requiring a command name.
+		// This allows `gro run script.ts -- --help` to pass --help to the script.
+		const implicit_args = to_implicit_forwarded_args();
+
+		// Reconstruct argv: positional args + explicit named args + implicit args after --
+		const named_argv = serialize_args({...forwarded_args, ...implicit_args});
 		const full_argv = [...positional_argv, ...named_argv];
 
 		const loader_path = resolve_gro_module_path('loader.js');
 
 		const spawned = await spawn_with_loader(loader_path, path, full_argv);
 		if (!spawned.ok) {
-			throw new Task_Error(`\`gro run ${path}\` failed with exit code ${spawned.code}`);
+			throw new TaskError(`\`gro run ${path}\` failed with exit code ${spawned.code}`);
 		}
 	},
 };