@ryanatkn/gro 0.119.1 → 0.120.0

package/dist/input_path.test.js

@@ -1,7 +1,7 @@
 import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { resolve } from 'node:path';
-import { to_input_path, to_input_paths, load_source_ids_by_input_path, get_possible_source_ids, } from './input_path.js';
+import { to_input_path, to_input_paths, resolve_input_files, get_possible_paths, } from './input_path.js';
 import { GRO_DIST_DIR, paths } from './paths.js';
 test('to_input_path', () => {
     assert.is(to_input_path(resolve('foo.ts')), resolve('foo.ts'));
@@ -20,65 +20,169 @@ test('to_input_paths', () => {
         'foo',
     ]);
 });
-test('get_possible_source_ids in the gro directory', () => {
+test('get_possible_paths with an implicit relative path', () => {
+    const input_path = 'src/foo/bar';
+    assert.equal(get_possible_paths(input_path, [resolve('src/foo'), resolve('src/baz'), resolve('src'), resolve('.')], ['.ext.ts']), [
+        {
+            id: resolve('src/foo/src/foo/bar'),
+            input_path: 'src/foo/bar',
+            root_dir: resolve('src/foo'),
+        },
+        {
+            id: resolve('src/foo/src/foo/bar.ext.ts'),
+            input_path: 'src/foo/bar',
+            root_dir: resolve('src/foo'),
+        },
+        {
+            id: resolve('src/baz/src/foo/bar'),
+            input_path: 'src/foo/bar',
+            root_dir: resolve('src/baz'),
+        },
+        {
+            id: resolve('src/baz/src/foo/bar.ext.ts'),
+            input_path: 'src/foo/bar',
+            root_dir: resolve('src/baz'),
+        },
+        {
+            id: resolve('src/src/foo/bar'),
+            input_path: 'src/foo/bar',
+            root_dir: resolve('src'),
+        },
+        {
+            id: resolve('src/src/foo/bar.ext.ts'),
+            input_path: 'src/foo/bar',
+            root_dir: resolve('src'),
+        },
+        {
+            id: resolve('src/foo/bar'),
+            input_path: 'src/foo/bar',
+            root_dir: resolve('.'),
+        },
+        {
+            id: resolve('src/foo/bar.ext.ts'),
+            input_path: 'src/foo/bar',
+            root_dir: resolve('.'),
+        },
+    ]);
+});
+test('get_possible_paths in the gro directory', () => {
     const input_path = resolve('src/foo/bar');
-    assert.equal(get_possible_source_ids(input_path, ['.baz.ts'], []), [
-        input_path,
-        input_path + '.baz.ts',
+    assert.equal(get_possible_paths(input_path, [], ['.ext.ts']), [
+        { id: input_path, input_path: resolve('src/foo/bar'), root_dir: resolve('src/foo') },
+        { id: input_path + '.ext.ts', input_path: resolve('src/foo/bar'), root_dir: resolve('src/foo') },
     ]);
 });
-test('get_possible_source_ids does not repeat the extension', () => {
-    const input_path = resolve('src/foo/bar.baz.ts');
-    assert.equal(get_possible_source_ids(input_path, ['.baz.ts'], []), [input_path]);
+test('get_possible_paths does not repeat the extension', () => {
+    const input_path = resolve('src/foo/bar.ext.ts');
+    assert.equal(get_possible_paths(input_path, [], ['.ext.ts']), [
+        { id: input_path, input_path: resolve('src/foo/bar.ext.ts'), root_dir: resolve('src/foo') },
+    ]);
 });
-test('get_possible_source_ids does not repeat with the same root directory', () => {
-    const input_path = resolve('src/foo/bar.baz.ts');
-    assert.equal(get_possible_source_ids(input_path, ['.baz.ts'], [paths.root, paths.root]), [
-        input_path,
+test('get_possible_paths does not repeat with the same root directory', () => {
+    const input_path = resolve('src/foo/bar.ext.ts');
+    assert.equal(get_possible_paths(input_path, [paths.root, paths.root], ['.ext.ts']), [
+        { id: input_path, input_path: resolve('src/foo/bar.ext.ts'), root_dir: resolve('src/foo') },
     ]);
 });
-test('get_possible_source_ids implied to be a directory by trailing slash', () => {
+test('get_possible_paths implied to be a directory by trailing slash', () => {
     const input_path = resolve('src/foo/bar') + '/';
-    assert.equal(get_possible_source_ids(input_path, ['.baz.ts'], []), [input_path]);
+    assert.equal(get_possible_paths(input_path, [], ['.ext.ts']), [
+        { id: input_path, input_path: resolve('src/foo/bar') + '/', root_dir: resolve('src/foo') },
+    ]);
 });
-test('load_source_ids_by_input_path', async () => {
+test('resolve_input_files', async () => {
     const test_files = {
-        'fake/test1.bar.ts': new Map([['fake/test1.bar.ts', { isDirectory: () => false }]]),
-        'fake/test2.bar.ts': new Map([['fake/test2.bar.ts', { isDirectory: () => false }]]),
-        'fake/test3': new Map([
-            ['fake/test3', { isDirectory: () => true }],
-            ['a.ts', { isDirectory: () => false }],
-            ['b.ts', { isDirectory: () => false }],
-        ]),
+        'fake/test1.ext.ts': [{ id: '', path: 'fake/test1.ext.ts', is_directory: false }],
+        'fake/test2.ext.ts': [{ id: '', path: 'fake/test2.ext.ts', is_directory: false }],
+        'fake/test3': [
+            { id: '', path: 'fake/test3', is_directory: true },
+            { id: '', path: 'a.ts', is_directory: false },
+            { id: '', path: 'b.ts', is_directory: false },
+        ],
         // duplicate
-        'fake/': new Map([
-            ['fake/test3', { isDirectory: () => true }],
-            ['test3/a.ts', { isDirectory: () => false }],
-        ]),
+        'fake/': [
+            { id: '', path: 'fake/test3', is_directory: true },
+            { id: '', path: 'test3/a.ts', is_directory: false },
+        ],
         // duplicate and not
-        fake: new Map([
-            ['fake/test3', { isDirectory: () => true }],
-            ['test3/a.ts', { isDirectory: () => false }],
-            ['test3/c.ts', { isDirectory: () => false }],
-        ]),
-        'fake/nomatches': new Map([['fake/nomatches', { isDirectory: () => true }]]),
+        fake: [
+            { id: '', path: 'fake/test3', is_directory: true },
+            { id: '', path: 'test3/a.ts', is_directory: false },
+            { id: '', path: 'test3/c.ts', is_directory: false },
+        ],
+        'fake/nomatches': [{ id: '', path: 'fake/nomatches', is_directory: true }],
     };
-    const result = await load_source_ids_by_input_path(new Map([
-        ['fake/test1.bar.ts', { id: 'fake/test1.bar.ts', isDirectory: false }],
-        ['fake/test2', { id: 'fake/test2.bar.ts', isDirectory: false }],
-        ['fake/test3', { id: 'fake/test3', isDirectory: true }],
-        ['fake/', { id: 'fake/', isDirectory: true }],
-        ['fake', { id: 'fake', isDirectory: true }],
-        ['fake/nomatches', { id: 'fake/nomatches', isDirectory: true }],
-    ]), async (id) => test_files[id]);
+    const a = {
+        id: 'fake/test1.ext.ts',
+        is_directory: false,
+        input_path: 'fake/test1.ext.ts',
+        root_dir: process.cwd(),
+    };
+    const b = {
+        id: 'fake/test2.ext.ts',
+        is_directory: false,
+        input_path: 'fake/test2',
+        root_dir: process.cwd(),
+    };
+    const c = {
+        id: 'fake/test3',
+        is_directory: true,
+        input_path: 'fake/test3',
+        root_dir: process.cwd(),
+    };
+    const d = {
+        id: 'fake/',
+        is_directory: true,
+        input_path: 'fake/',
+        root_dir: process.cwd(),
+    };
+    const e = {
+        id: 'fake',
+        is_directory: true,
+        input_path: 'fake',
+        root_dir: process.cwd(),
+    };
+    const f = {
+        id: 'fake/nomatches',
+        is_directory: true,
+        input_path: 'fake/nomatches',
+        root_dir: process.cwd(),
+    };
+    const result = await resolve_input_files([a, b, c, d, e, f], async (id) => test_files[id]);
+    const resolved_input_files = [
+        { id: a.id, input_path: a.input_path, resolved_input_path: a },
+        { id: b.id, input_path: b.input_path, resolved_input_path: b },
+        { id: 'fake/test3/a.ts', input_path: c.input_path, resolved_input_path: c },
+        { id: 'fake/test3/b.ts', input_path: c.input_path, resolved_input_path: c },
+        { id: 'fake/test3/c.ts', input_path: e.input_path, resolved_input_path: e },
+    ];
     assert.equal(result, {
-        source_ids_by_input_path: new Map([
-            ['fake/test1.bar.ts', ['fake/test1.bar.ts']],
-            ['fake/test2', ['fake/test2.bar.ts']],
-            ['fake/test3', ['fake/test3/a.ts', 'fake/test3/b.ts']],
-            ['fake', ['fake/test3/c.ts']],
+        resolved_input_files,
+        resolved_input_files_by_input_path: new Map([
+            ['fake/test1.ext.ts', [{ id: a.id, input_path: a.input_path, resolved_input_path: a }]],
+            ['fake/test2', [{ id: b.id, input_path: b.input_path, resolved_input_path: b }]],
+            [
+                'fake/test3',
+                [
+                    { id: 'fake/test3/a.ts', input_path: c.input_path, resolved_input_path: c },
+                    { id: 'fake/test3/b.ts', input_path: c.input_path, resolved_input_path: c },
+                ],
+            ],
+            ['fake', [{ id: 'fake/test3/c.ts', input_path: e.input_path, resolved_input_path: e }]],
+        ]),
+        resolved_input_files_by_root_dir: new Map([
+            [
+                process.cwd(),
+                [
+                    { id: 'fake/test1.ext.ts', input_path: 'fake/test1.ext.ts', resolved_input_path: a },
+                    { id: 'fake/test2.ext.ts', input_path: 'fake/test2', resolved_input_path: b },
+                    { id: 'fake/test3/a.ts', input_path: 'fake/test3', resolved_input_path: c },
+                    { id: 'fake/test3/b.ts', input_path: 'fake/test3', resolved_input_path: c },
+                    { id: 'fake/test3/c.ts', input_path: 'fake', resolved_input_path: e },
+                ],
+            ],
         ]),
-        input_directories_with_no_files: ['fake/nomatches'],
+        input_directories_with_no_files: [f],
     });
 });
 test.run();

package/dist/invoke_task.d.ts

@@ -1,4 +1,5 @@
 import { type Args } from './args.js';
+import { Raw_Input_Path } from './input_path.js';
 import type { Gro_Config } from './config.js';
 /**
  * Invokes Gro tasks by name using the filesystem as the source.
@@ -17,4 +18,4 @@ import type { Gro_Config } from './config.js';
  * there are some subtle differences in the complex logical branches.
  * The comments describe each condition.
  */
-export declare const invoke_task: (task_name: Flavored<string, "Raw_Input_Path">, args: Args | undefined, config: Gro_Config, timings?: any) => Promise<void>;
+export declare const invoke_task: (task_name: Raw_Input_Path, args: Args | undefined, config: Gro_Config, timings?: any) => Promise<void>;

package/dist/invoke_task.js

@@ -5,11 +5,9 @@ import { print_ms, print_timings } from '@ryanatkn/belt/print.js';
 import { to_forwarded_args } from './args.js';
 import { run_task } from './run_task.js';
 import { to_input_path, Raw_Input_Path } from './input_path.js';
-import { is_gro_id, IS_THIS_GRO, print_path, print_path_or_gro_path } from './paths.js';
-import { load_modules } from './modules.js';
-import { find_task_modules, load_task_module } from './task_module.js';
+import { find_tasks, load_tasks } from './task.js';
 import { load_gro_package_json } from './package_json.js';
-import { log_tasks, log_error_reasons, log_gro_package_tasks } from './task_logging.js';
+import { log_tasks, log_error_reasons } from './task_logging.js';
 /**
  * Invokes Gro tasks by name using the filesystem as the source.
  *
@@ -44,87 +42,43 @@ export const invoke_task = async (task_name, args, config, timings = new Timings
     }
     // Resolve the input path for the provided task name.
     const input_path = to_input_path(task_name);
-    const { task_root_paths } = config;
+    const { task_root_dirs } = config;
     // Find the task or directory specified by the `input_path`.
     // Fall back to searching the Gro directory as well.
-    const find_modules_result = await find_task_modules([input_path], task_root_paths);
-    if (!find_modules_result.ok) {
-        if (find_modules_result.type === 'input_directories_with_no_files') {
-            // The input path matched a directory, but it contains no matching files.
-            if (IS_THIS_GRO ||
-                // this is null safe because of the failure type
-                is_gro_id(find_modules_result.source_id_path_data_by_input_path.get(input_path).id)) {
-                // If the directory is inside Gro, just log the errors.
-                log_error_reasons(log, find_modules_result.reasons);
-                process.exit(1);
-            }
-            else {
-                // If there's a matching directory in the current working directory,
-                // but it has no matching files, we still want to search Gro's directory.
-                const gro_dir_find_modules_result = await log_gro_package_tasks(input_path, task_root_paths, log);
-                if (!gro_dir_find_modules_result.ok) {
-                    // Log the original errors, not the Gro-specific ones.
-                    log_error_reasons(log, find_modules_result.reasons);
-                    process.exit(1);
-                }
-                finish();
-                return;
-            }
-        }
-        else {
-            // Some unknown find modules result failure happened, so log it out.
-            // (currently, just "unmapped_input_paths")
-            log_error_reasons(log, find_modules_result.reasons);
-            process.exit(1);
-        }
+    const found = await find_tasks([input_path], task_root_dirs, config);
+    if (!found.ok) {
+        log_error_reasons(log, found.reasons);
+        process.exit(1);
     }
     // Found a match either in the current working directory or Gro's directory.
-    const path_data = find_modules_result.source_id_path_data_by_input_path.get(input_path); // this is null safe because result is ok
-    if (!path_data.isDirectory) {
-        // The input path matches a file, so load and run it.
-        // Try to load the task module.
-        const load_modules_result = await load_modules(find_modules_result.source_ids_by_input_path, (id) => load_task_module(id, task_root_paths));
-        if (load_modules_result.ok) {
-            // We found a task module. Run it!
-            // `path_data` is not a directory, so there's a single task module here.
-            const task = load_modules_result.modules[0];
-            log.info(`→ ${cyan(task.name)} ${(task.mod.task.summary && gray(task.mod.task.summary)) || ''}`);
-            const timing_to_run_task = timings.start('run task ' + task_name);
-            const result = await run_task(task, { ...args, ...to_forwarded_args(`gro ${task.name}`) }, invoke_task, config, timings);
-            timing_to_run_task();
-            if (result.ok) {
-                log.info(`✓ ${cyan(task.name)}`);
-            }
-            else {
-                log.info(`${red('🞩')} ${cyan(task.name)}`);
-                log_error_reasons(log, [result.reason]);
-                throw result.error;
-            }
-        }
-        else {
-            log_error_reasons(log, load_modules_result.reasons);
-            process.exit(1);
-        }
+    const found_tasks = found.value;
+    const { resolved_input_files } = found_tasks;
+    // Load the task module.
+    const loaded = await load_tasks(found_tasks);
+    if (!loaded.ok) {
+        log_error_reasons(log, loaded.reasons);
+        process.exit(1);
     }
-    else {
+    const loaded_tasks = loaded.value;
+    if (resolved_input_files.length > 1 || resolved_input_files[0].resolved_input_path.is_directory) {
         // The input path matches a directory. Log the tasks but don't run them.
-        if (IS_THIS_GRO) {
-            // Is the Gro directory the same as the cwd? Log the matching files.
-            await log_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path, task_root_paths);
-        }
-        else if (is_gro_id(path_data.id)) {
-            // Does the Gro directory contain the matching files? Log them.
-            await log_tasks(log, print_path_or_gro_path(path_data.id), find_modules_result.source_ids_by_input_path, task_root_paths);
-        }
-        else {
-            // The Gro directory is not the same as the cwd and it doesn't contain the matching files.
-            // Find all of the possible matches in both the current project and the Gro directory,
-            // and log everything out.
-            // Ignore any errors - the directory may not exist or have any files!
-            const gro_dir_find_modules_result = await log_gro_package_tasks(input_path, task_root_paths, log);
-            // Then log the current working directory matches.
-            await log_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path, task_root_paths, !gro_dir_find_modules_result.ok);
-        }
+        await log_tasks(log, loaded_tasks);
+        finish();
+        return;
+    }
+    // The input path matches a file that's presumable a task, so load and run it.
+    if (loaded_tasks.modules.length !== 1)
+        throw Error('expected one loaded task'); // run only one task at a time
+    const task = loaded_tasks.modules[0];
+    log.info(`→ ${cyan(task.name)} ${(task.mod.task.summary && gray(task.mod.task.summary)) || ''}`);
+    const timing_to_run_task = timings.start('run task ' + task_name);
+    const result = await run_task(task, { ...args, ...to_forwarded_args(`gro ${task.name}`) }, invoke_task, config, timings);
+    timing_to_run_task();
+    if (!result.ok) {
+        log.info(`${red('🞩')} ${cyan(task.name)}`);
+        log_error_reasons(log, [result.reason]);
+        throw result.error;
     }
+    log.info(`✓ ${cyan(task.name)}`);
     finish();
 };

package/dist/loader.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { LoadHook, ResolveHook } from 'node:module';
 export declare const load: LoadHook;
 export declare const resolve: ResolveHook;

package/dist/loader.js

@@ -164,13 +164,13 @@ export const resolve = async (specifier, context, nextResolve) => {
         if (SVELTE_MATCHER.test(path) || json_matcher.test(path)) {
             // Match the behavior of Vite and esbuild for Svelte and JSON imports.
             // TODO maybe `.ts` too
-            const source_id = await resolve_node_specifier(path, dir, parent_url, package_json_cache);
-            return { url: pathToFileURL(source_id).href, format: 'module', shortCircuit: true };
+            const path_id = await resolve_node_specifier(path, dir, parent_url, package_json_cache);
+            return { url: pathToFileURL(path_id).href, format: 'module', shortCircuit: true };
         }
         else {
             return nextResolve(path, context);
         }
     }
-    const { source_id } = await resolve_specifier(path, dirname(fileURLToPath(parent_url)));
-    return { url: pathToFileURL(source_id).href, format: 'module', shortCircuit: true };
+    const { path_id } = await resolve_specifier(path, dirname(fileURLToPath(parent_url)));
+    return { url: pathToFileURL(path_id).href, format: 'module', shortCircuit: true };
 };

package/dist/modules.d.ts

@@ -1,53 +1,34 @@
 import type { Result } from '@ryanatkn/belt/result.js';
-import { Input_Path } from './input_path.js';
-import type { Path_Data } from './path.js';
-import { type Source_Id } from './paths.js';
+import type { Resolved_Input_File } from './input_path.js';
+import type { Path_Id } from './path.js';
 export interface Module_Meta<T_Module extends Record<string, any> = Record<string, any>> {
-    id: string;
+    id: Path_Id;
     mod: T_Module;
 }
-export type Load_Module_Result<T> = Result<{
-    mod: T;
+export type Load_Module_Result<T_Module> = Result<{
+    id: Path_Id;
+    mod: T_Module;
 }, Load_Module_Failure>;
 export type Load_Module_Failure = {
     ok: false;
-    type: 'importFailed';
-    id: string;
+    type: 'failed_import';
+    id: Path_Id;
     error: Error;
 } | {
     ok: false;
-    type: 'invalid';
-    id: string;
+    type: 'failed_validation';
+    id: Path_Id;
     mod: Record<string, any>;
     validation: string;
 };
-export declare const load_module: <T extends Record<string, any>>(id: string, validate?: (mod: Record<string, any>) => mod is T) => Promise<Load_Module_Result<Module_Meta<T>>>;
-export type Find_Modules_Result = Result<{
-    source_ids_by_input_path: Map<Input_Path, Source_Id[]>;
-    source_id_path_data_by_input_path: Map<Input_Path, Path_Data>;
-}, Find_Modules_Failure>;
-export type Find_Modules_Failure = {
-    type: 'unmapped_input_paths';
-    source_id_path_data_by_input_path: Map<Input_Path, Path_Data>;
-    unmapped_input_paths: Input_Path[];
-    reasons: string[];
-} | {
-    type: 'input_directories_with_no_files';
-    source_ids_by_input_path: Map<Input_Path, Source_Id[]>;
-    source_id_path_data_by_input_path: Map<Input_Path, Path_Data>;
-    input_directories_with_no_files: Input_Path[];
-    reasons: string[];
-};
-export type Load_Modules_Result<T_Module_Meta extends Module_Meta> = Result<{
-    modules: T_Module_Meta[];
-}, {
+export declare const load_module: <T_Module extends Record<string, any>>(id: Path_Id, validate?: (mod: Record<string, any>) => mod is T_Module) => Promise<Load_Module_Result<T_Module>>;
+export interface Load_Modules_Failure<T_Module_Meta extends Module_Meta> {
     type: 'load_module_failures';
     load_module_failures: Load_Module_Failure[];
     reasons: string[];
     modules: T_Module_Meta[];
-}>;
-/**
- * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
- */
-export declare const find_modules: (input_paths: Input_Path[], custom_search_fs?: (dir: string, options?: import("./search_fs.js").Search_Fs_Options) => Promise<Map<string, import("./path.js").Path_Stats>>, get_possible_source_ids?: (input_path: Input_Path) => Source_Id[], timings?: any) => Promise<Find_Modules_Result>;
-export declare const load_modules: <Module_Type extends Record<string, any>, T_Module_Meta extends Module_Meta<Module_Type>>(source_ids_by_input_path: Map<Input_Path, Source_Id[]>, load_module_by_id: (source_id: Source_Id) => Promise<Load_Module_Result<T_Module_Meta>>, timings?: any) => Promise<Load_Modules_Result<T_Module_Meta>>;
+}
+export type Load_Modules_Result<T_Module_Meta extends Module_Meta> = Result<{
+    modules: T_Module_Meta[];
+}, Load_Modules_Failure<T_Module_Meta>>;
+export declare const load_modules: <T_Module extends Record<string, any>, T_Module_Meta extends Module_Meta<T_Module>>(resolved_input_files: 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, timings?: any) => Promise<Load_Modules_Result<T_Module_Meta>>;

package/dist/modules.js

@@ -1,95 +1,56 @@
-import { red } from 'kleur/colors';
 import { Unreachable_Error } from '@ryanatkn/belt/error.js';
 import { print_error } from '@ryanatkn/belt/print.js';
-import { load_source_path_data_by_input_path, load_source_ids_by_input_path, Input_Path, } from './input_path.js';
-import { paths_from_id, print_path, print_path_or_gro_path } from './paths.js';
-import { search_fs } from './search_fs.js';
+import { print_path } from './paths.js';
 export const load_module = async (id, validate) => {
     let mod;
     try {
         mod = await import(id);
     }
     catch (err) {
-        return { ok: false, type: 'importFailed', id, error: err };
+        return { ok: false, type: 'failed_import', id, error: err };
     }
     if (validate && !validate(mod)) {
-        return { ok: false, type: 'invalid', id, mod, validation: validate.name };
+        return { ok: false, type: 'failed_validation', id, mod, validation: validate.name };
     }
-    return { ok: true, mod: { id, mod } };
+    return { ok: true, id, mod };
 };
-/**
- * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
- */
-export const find_modules = async (input_paths, custom_search_fs = search_fs, get_possible_source_ids, timings) => {
-    // Check which extension variation works - if it's a directory, prefer others first!
-    const timing_to_map_input_paths = timings?.start('map input paths');
-    const { source_id_path_data_by_input_path, unmapped_input_paths } = await load_source_path_data_by_input_path(input_paths, get_possible_source_ids);
-    timing_to_map_input_paths?.();
-    // Error if any input path could not be mapped.
-    if (unmapped_input_paths.length) {
-        return {
-            ok: false,
-            type: 'unmapped_input_paths',
-            source_id_path_data_by_input_path,
-            unmapped_input_paths,
-            reasons: unmapped_input_paths.map((input_path) => red(`Input path ${print_path_or_gro_path(input_path, paths_from_id(input_path))} cannot be mapped to a file or directory.`)),
-        };
-    }
-    // Find all of the files for any directories.
-    const timing_to_search_fs = timings?.start('find files');
-    const { source_ids_by_input_path, input_directories_with_no_files } = await load_source_ids_by_input_path(source_id_path_data_by_input_path, custom_search_fs);
-    timing_to_search_fs?.();
-    // Error if any input path has no files. (means we have an empty directory)
-    return input_directories_with_no_files.length
-        ? {
-            ok: false,
-            type: 'input_directories_with_no_files',
-            source_id_path_data_by_input_path,
-            source_ids_by_input_path,
-            input_directories_with_no_files,
-            reasons: input_directories_with_no_files.map((input_path) => red(`Input directory ${print_path_or_gro_path(source_id_path_data_by_input_path.get(input_path).id, paths_from_id(input_path))} contains no matching files.`)),
-        }
-        : { ok: true, source_ids_by_input_path, source_id_path_data_by_input_path };
-};
-// TODO parallelize, originally it needed to be serial for a specific usecase we no longer have
-export const load_modules = async (source_ids_by_input_path, // TODO maybe make this a flat array and remove `input_path`?
-load_module_by_id, timings) => {
+// TODO parallelize and sort afterwards
+export const load_modules = async (resolved_input_files, validate, map_module_meta, timings) => {
     const timing_to_load_modules = timings?.start('load modules');
     const modules = [];
     const load_module_failures = [];
     const reasons = [];
-    for (const [input_path, source_ids] of source_ids_by_input_path) {
-        for (const id of source_ids) {
-            const result = await load_module_by_id(id); // eslint-disable-line no-await-in-loop
-            if (result.ok) {
-                modules.push(result.mod);
-            }
-            else {
-                load_module_failures.push(result);
-                switch (result.type) {
-                    case 'importFailed': {
-                        reasons.push(`Module import ${print_path(id, paths_from_id(id))} failed from input ${print_path(input_path, paths_from_id(input_path))}: ${print_error(result.error)}`);
-                        break;
-                    }
-                    case 'invalid': {
-                        // TODO try to make this a good error message for the task case
-                        reasons.push(`Module ${print_path(id, paths_from_id(id))} failed validation '${result.validation}'.`);
-                        break;
-                    }
-                    default:
-                        throw new Unreachable_Error(result);
+    for (const resolved_input_file of resolved_input_files.values()) {
+        const { id, input_path } = resolved_input_file;
+        const result = await load_module(id, validate); // eslint-disable-line no-await-in-loop
+        if (result.ok) {
+            modules.push(map_module_meta(resolved_input_file, result.mod));
+        }
+        else {
+            load_module_failures.push(result);
+            switch (result.type) {
+                case 'failed_import': {
+                    reasons.push(`Module import ${print_path(id)} failed from input ${print_path(input_path)}: ${print_error(result.error)}`);
+                    break;
                 }
+                case 'failed_validation': {
+                    reasons.push(`Module ${print_path(id)} failed validation '${result.validation}'.`);
+                    break;
+                }
+                default:
+                    throw new Unreachable_Error(result);
             }
         }
     }
     timing_to_load_modules?.();
-    return load_module_failures.length
-        ? {
+    if (load_module_failures.length) {
+        return {
             ok: false,
             type: 'load_module_failures',
             load_module_failures,
             reasons,
             modules,
-        }
-        : { ok: true, modules };
+        };
+    }
+    return { ok: true, modules };
 };