@ryanatkn/gro 0.119.1 → 0.120.0

package/dist/git.js

@@ -1,6 +1,6 @@
 import { spawn, spawn_out } from '@ryanatkn/belt/process.js';
 import { z } from 'zod';
-import { exists } from './fs.js';
+import { existsSync } from 'node:fs';
 import { to_file_path } from './path.js';
 // TODO maybe extract to `util-git`
 export const Git_Origin = z.string().brand('Git_Origin');
@@ -20,7 +20,7 @@ export const git_current_branch_name = async (options) => {
  */
 export const git_remote_branch_exists = async (origin = 'origin', branch, options) => {
     const final_branch = branch ?? (await git_current_branch_name(options));
-    if (options?.cwd && !(await exists(to_file_path(options.cwd)))) {
+    if (options?.cwd && !existsSync(to_file_path(options.cwd))) {
         return false;
     }
     const result = await spawn('git', ['ls-remote', '--exit-code', '--heads', origin, 'refs/heads/' + final_branch], options);
@@ -38,7 +38,7 @@ export const git_remote_branch_exists = async (origin = 'origin', branch, option
  * @returns a boolean indicating if the local git branch exists
  */
 export const git_local_branch_exists = async (branch, options) => {
-    if (options?.cwd && !(await exists(to_file_path(options.cwd)))) {
+    if (options?.cwd && !existsSync(to_file_path(options.cwd))) {
         return false;
     }
     const result = await spawn('git', ['show-ref', '--quiet', 'refs/heads/' + branch], options);

package/dist/gro_helpers.js

@@ -2,7 +2,7 @@ import { realpath } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from '@ryanatkn/belt/process.js';
-import { exists } from './fs.js';
+import { existsSync } from 'node:fs';
 import { NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME } from './path_constants.js';
 /*
 
@@ -47,14 +47,14 @@ export const resolve_gro_module_path = async (path = '') => {
     const gro_bin_path = resolve(NODE_MODULES_DIRNAME, '.bin/gro');
     // case 1
     // Prefer any locally installed version of Gro.
-    if (await exists(gro_bin_path)) {
+    if (existsSync(gro_bin_path)) {
         return join(await realpath(gro_bin_path), '..', path);
     }
     // case 2
     // If running Gro inside its own repo, require the local dist.
     // If the local dist is not yet built it will fall back to the global.
-    if ((await exists(join(SVELTEKIT_DIST_DIRNAME, 'gro.js'))) &&
-        (await exists(join(SVELTEKIT_DIST_DIRNAME, path)))) {
+    if (existsSync(join(SVELTEKIT_DIST_DIRNAME, 'gro.js')) &&
+        existsSync(join(SVELTEKIT_DIST_DIRNAME, path))) {
         return resolve(SVELTEKIT_DIST_DIRNAME, path);
     }
     // case 3

package/dist/gro_plugin_gen.js

@@ -2,8 +2,8 @@
 // because we no longer have a normal system build - replace with an esbuild plugin
 // @ts-nocheck
 import { spawn } from '@ryanatkn/belt/process.js';
-import { source_id_to_base_path } from './paths.js';
-import { find_gen_modules, is_gen_path } from './gen_module.js';
+import { path_id_to_base_path } from './paths.js';
+import { find_genfiles, is_gen_path } from './gen.js';
 import { filter_dependents } from './build/source_file.js';
 import { throttle } from './throttle.js';
 const FLUSH_DEBOUNCE_DELAY = 500;
@@ -35,7 +35,7 @@ export const plugin = () => {
     const gen = (files = []) => spawn_cli('gro', ['gen', ...files]);
     return {
         name: 'gro_plugin_gen',
-        setup: async ({ args: { watch }, dev, log }) => {
+        setup: async ({ args: { watch }, dev, log, config }) => {
             // For production builds, we assume `gen` is already fresh,
             // which should be checked by CI via `gro check` which calls `gro gen --check`.
             if (!dev)
@@ -44,8 +44,8 @@ export const plugin = () => {
             // Some parts of the build may have already happened,
             // making us miss `build` events for gen dependencies,
             // so we run `gen` here even if it's usually wasteful.
-            const found = await find_gen_modules();
-            if (found.ok && found.source_ids_by_input_path.size > 0) {
+            const found = await find_genfiles([paths.source], root_dirs, config);
+            if (found.ok && found.resolved_input_files_by_input_path.size > 0) {
                 await gen();
             }
             // Do we need to just generate everything once and exit?
@@ -61,12 +61,12 @@ export const plugin = () => {
                 // but we probably want to make this an esbuild plugin instead
                 // if (build_config.name !== 'system') return;
                 if (is_gen_path(source_file.id)) {
-                    queue_gen(source_id_to_base_path(source_file.id));
+                    queue_gen(path_id_to_base_path(source_file.id));
                 }
                 const dependent_gen_file_ids = filter_dependents(source_file, build_config, filer.find_by_id, // cast because we can assume they're all `SourceFile`s
                 is_gen_path);
                 for (const dependent_gen_file_id of dependent_gen_file_ids) {
-                    queue_gen(source_id_to_base_path(dependent_gen_file_id));
+                    queue_gen(path_id_to_base_path(dependent_gen_file_id));
                 }
             };
             filer.on('build', on_filer_build);

package/dist/gro_plugin_server.d.ts

@@ -2,8 +2,8 @@ import * as esbuild from 'esbuild';
 import type { Config as SvelteKitConfig } from '@sveltejs/kit';
 import type { Result } from '@ryanatkn/belt/result.js';
 import type { Plugin, Plugin_Context } from './plugin.js';
-export declare const SERVER_SOURCE_ID: Flavored<string, "Source_Id">;
-export declare const has_server: (path?: Flavored<string, "Source_Id">) => Promise<Result<object, {
+export declare const SERVER_SOURCE_ID: Flavored<string, "Path_Id">;
+export declare const has_server: (path?: Flavored<string, "Path_Id">) => Promise<Result<object, {
     message: string;
 }>>;
 export interface Options {

package/dist/gro_plugin_server.js

@@ -3,7 +3,8 @@ import * as esbuild from 'esbuild';
 import { join, resolve } from 'node:path';
 import { identity } from '@ryanatkn/belt/function.js';
 import { strip_before, strip_end } from '@ryanatkn/belt/string.js';
-import { base_path_to_source_id, LIB_DIRNAME, paths } from './paths.js';
+import { existsSync } from 'node:fs';
+import { base_path_to_path_id, LIB_DIRNAME, paths } from './paths.js';
 import { GRO_DEV_DIRNAME, SERVER_DIST_PATH } from './path_constants.js';
 import { watch_dir } from './watch_dir.js';
 import { init_sveltekit_config } from './sveltekit_config.js';
@@ -13,14 +14,13 @@ import { print_build_result, to_define_import_meta_env } from './esbuild_helpers
 import { esbuild_plugin_sveltekit_shim_alias } from './esbuild_plugin_sveltekit_shim_alias.js';
 import { esbuild_plugin_external_worker } from './esbuild_plugin_external_worker.js';
 import { esbuild_plugin_sveltekit_local_imports } from './esbuild_plugin_sveltekit_local_imports.js';
-import { exists } from './fs.js';
 import { esbuild_plugin_svelte } from './esbuild_plugin_svelte.js';
 import { throttle } from './throttle.js';
 import { sveltekit_config_global } from './sveltekit_config_global.js';
 // TODO sourcemap as a hoisted option? disable for production by default - or like `outpaths`, passed a `dev` param
-export const SERVER_SOURCE_ID = base_path_to_source_id(LIB_DIRNAME + '/server/server.ts');
+export const SERVER_SOURCE_ID = base_path_to_path_id(LIB_DIRNAME + '/server/server.ts');
 export const has_server = async (path = SERVER_SOURCE_ID) => {
-    if (!(await exists(path))) {
+    if (!existsSync(path)) {
         return { ok: false, message: `no server file found at ${path}` };
     }
     return { ok: true };
@@ -138,7 +138,7 @@ export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = pro
                 await watcher.init();
                 watcher_ready = true;
             }
-            if (!(await exists(server_outpath))) {
+            if (!existsSync(server_outpath)) {
                 throw Error(`Node server failed to start due to missing file: ${server_outpath}`);
             }
             if (run ?? dev) {

package/dist/gro_plugin_sveltekit_app.js

@@ -1,14 +1,15 @@
 import { spawn_process } from '@ryanatkn/belt/process.js';
 import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
 import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
-import { exists } from './fs.js';
 import { serialize_package_json, load_package_json } from './package_json.js';
 import { Task_Error } from './task.js';
 import { spawn_cli } from './cli.js';
 import { serialize_src_json, create_src_json } from './src_json.js';
 import { DEFAULT_EXPORTS_EXCLUDER } from './config.js';
 import { sveltekit_config_global } from './sveltekit_config_global.js';
+import { SOURCE_DIRNAME } from './path_constants.js';
 export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_known_package_json, well_known_src_json, well_known_src_files, } = {}) => {
     let sveltekit_process = null;
     return {
@@ -64,7 +65,7 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
                         ? await create_temporarily(join(assets_path, '.well-known/src.json'), serialized_src_json)
                         : null,
                     serialized_src_json && well_known_src_files
-                        ? await copy_temporarily('src', assets_path, '.well-known', well_known_src_files === true
+                        ? await copy_temporarily(SOURCE_DIRNAME, assets_path, '.well-known', well_known_src_files === true
                             ? (file_path) => !DEFAULT_EXPORTS_EXCLUDER.test(file_path)
                             : well_known_src_files)
                         : null,
@@ -106,7 +107,7 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
 const copy_temporarily = async (source_path, dest_dir, dest_base_dir = '', filter) => {
     const path = join(dest_dir, dest_base_dir, source_path);
     const dir = dirname(path);
-    const dir_already_exists = await exists(dir);
+    const dir_already_exists = existsSync(dir);
     let root_created_dir;
     if (!dir_already_exists) {
         root_created_dir = await to_root_dir_that_doesnt_exist(dir);
@@ -114,7 +115,7 @@ const copy_temporarily = async (source_path, dest_dir, dest_base_dir = '', filte
             throw Error();
         await mkdir(dir, { recursive: true });
     }
-    const path_already_exists = await exists(path);
+    const path_already_exists = existsSync(path);
     if (!path_already_exists) {
         await cp(source_path, path, { recursive: true, filter });
     }
@@ -138,7 +139,7 @@ const copy_temporarily = async (source_path, dest_dir, dest_base_dir = '', filte
  */
 const create_temporarily = async (path, contents) => {
     const dir = dirname(path);
-    const dir_already_exists = await exists(dir);
+    const dir_already_exists = existsSync(dir);
     let root_created_dir;
     if (!dir_already_exists) {
         root_created_dir = await to_root_dir_that_doesnt_exist(dir);
@@ -146,7 +147,7 @@ const create_temporarily = async (path, contents) => {
             throw Error();
         await mkdir(dir, { recursive: true });
     }
-    const path_already_exists = await exists(path);
+    const path_already_exists = existsSync(path);
     if (!path_already_exists) {
         await writeFile(path, contents, 'utf8');
     }
@@ -170,8 +171,7 @@ const to_root_dir_that_doesnt_exist = async (dir) => {
     let prev;
     let d = dir;
     do {
-        // eslint-disable-next-line no-await-in-loop
-        if (await exists(d)) {
+        if (existsSync(d)) {
             return prev;
         }
         prev = d;

package/dist/hash.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
 /**
  * @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto
  */
-export declare const to_hash: (data: Buffer, algorithm?: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512') => Promise<string>;
+export declare const to_hash: (data: Buffer, algorithm?: "SHA-1" | "SHA-256" | "SHA-384" | "SHA-512") => Promise<string>;

package/dist/input_path.d.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
 import type { Flavored } from '@ryanatkn/belt/types.js';
-import { Source_Id } from './paths.js';
-import { type Path_Data } from './path.js';
+import type { Path_Id } from './path.js';
 export declare const Input_Path: z.ZodString;
 export type Input_Path = Flavored<z.infer<typeof Input_Path>, 'Input_Path'>;
 export declare const Raw_Input_Path: z.ZodString;
@@ -18,30 +17,49 @@ export type Raw_Input_Path = Flavored<z.infer<typeof Raw_Input_Path>, 'Raw_Input
  *
  * Thus, input paths are either absolute or implicitly relative.
  */
-export declare const to_input_path: (raw_input_path: Flavored<string, "Raw_Input_Path">, root_path?: string) => Flavored<string, "Input_Path">;
+export declare const to_input_path: (raw_input_path: Raw_Input_Path, root_path?: string) => Input_Path;
 export declare const to_input_paths: (raw_input_paths: Raw_Input_Path[], root_path?: string) => Input_Path[];
+export interface Possible_Path {
+    id: Path_Id;
+    input_path: Input_Path;
+    root_dir: Path_Id;
+}
 /**
  * Gets a list of possible source ids for each input path with `extensions`,
- * duplicating each under `root_dirs`.
- * This is first used to fall back to the Gro dir to search for tasks.
- * It's the helper used in implementations of `get_possible_source_ids_for_input_path` below.
+ * duplicating each under `root_dirs`, without checking the filesystem.
  */
-export declare const get_possible_source_ids: (input_path: Flavored<string, "Input_Path">, extensions: string[], root_dirs: string[]) => Source_Id[];
+export declare const get_possible_paths: (input_path: Input_Path, root_dirs: Path_Id[], extensions: string[]) => Possible_Path[];
+export interface Resolved_Input_Path {
+    input_path: Input_Path;
+    id: Path_Id;
+    is_directory: boolean;
+    root_dir: Path_Id;
+}
+export interface Resolved_Input_File {
+    id: Path_Id;
+    input_path: Input_Path;
+    resolved_input_path: Resolved_Input_Path;
+}
+export interface Resolved_Input_Paths {
+    resolved_input_paths: Resolved_Input_Path[];
+    resolved_input_paths_by_input_path: Map<Input_Path, Resolved_Input_Path[]>;
+    possible_paths_by_input_path: Map<Input_Path, Possible_Path[]>;
+    unmapped_input_paths: Input_Path[];
+}
 /**
  * Gets the path data for each input path, checking the filesystem for the possibilities
  * and stopping at the first existing file or falling back to the first existing directory.
  * If none is found for an input path, it's added to `unmapped_input_paths`.
  */
-export declare const load_source_path_data_by_input_path: (input_paths: Input_Path[], get_possible_source_ids_for_input_path?: (input_path: Input_Path) => Source_Id[]) => Promise<{
-    source_id_path_data_by_input_path: Map<Input_Path, Path_Data>;
-    unmapped_input_paths: Input_Path[];
-}>;
+export declare const resolve_input_paths: (input_paths: Input_Path[], root_dirs: Path_Id[], extensions: string[]) => Promise<Resolved_Input_Paths>;
+export interface Resolved_Input_Files {
+    resolved_input_files: Resolved_Input_File[];
+    resolved_input_files_by_input_path: Map<Input_Path, Resolved_Input_File[]>;
+    resolved_input_files_by_root_dir: Map<Path_Id, Resolved_Input_File[]>;
+    input_directories_with_no_files: Resolved_Input_Path[];
+}
 /**
  * Finds all of the matching files for the given input paths.
  * De-dupes source ids.
  */
-export declare const load_source_ids_by_input_path: (source_id_path_data_by_input_path: Map<Input_Path, Path_Data>, custom_search_fs?: (dir: string, options?: import("./search_fs.js").Search_Fs_Options) => Promise<Map<string, import("./path.js").Path_Stats>>) => Promise<{
-    source_ids_by_input_path: Map<Input_Path, Source_Id[]>;
-    input_directories_with_no_files: Input_Path[];
-}>;
-export declare const to_gro_input_path: (input_path: Flavored<string, "Input_Path">) => Flavored<string, "Input_Path">;
+export declare const resolve_input_files: (resolved_input_paths: Resolved_Input_Path[], custom_search_fs?: (dir: string, options?: import("./search_fs.js").Search_Fs_Options) => Promise<import("./path.js").Resolved_Path[]>) => Promise<Resolved_Input_Files>;

package/dist/input_path.js

@@ -1,10 +1,8 @@
-import { isAbsolute, join, resolve } from 'node:path';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { existsSync, statSync } from 'node:fs';
 import { strip_start } from '@ryanatkn/belt/string.js';
-import { stat } from 'node:fs/promises';
 import { z } from 'zod';
-import { GRO_PACKAGE_DIR, GRO_DIST_DIR, paths, Source_Id } from './paths.js';
-import { to_path_data } from './path.js';
-import { exists } from './fs.js';
+import { GRO_PACKAGE_DIR, GRO_DIST_DIR } from './paths.js';
 import { search_fs } from './search_fs.js';
 import { TASK_FILE_SUFFIX_JS } from './task.js';
 // TODO Flavored doesn't work when used in schemas, use Zod brand instead? problem is ergonomics
@@ -34,124 +32,178 @@ export const to_input_path = (raw_input_path, root_path = process.cwd()) => {
 export const to_input_paths = (raw_input_paths, root_path) => raw_input_paths.map((p) => to_input_path(p, root_path));
 /**
  * Gets a list of possible source ids for each input path with `extensions`,
- * duplicating each under `root_dirs`.
- * This is first used to fall back to the Gro dir to search for tasks.
- * It's the helper used in implementations of `get_possible_source_ids_for_input_path` below.
+ * duplicating each under `root_dirs`, without checking the filesystem.
  */
-export const get_possible_source_ids = (input_path, extensions, root_dirs) => {
-    const possible_source_ids = [];
-    const add_possible_source_ids = (path) => {
+export const get_possible_paths = (input_path, root_dirs, extensions) => {
+    const possible_paths = new Set();
+    const add_possible_paths = (path, root_dir) => {
         // Specifically for paths to the Gro package dist, optimize by only looking for `.task.js`.
         if (path.startsWith(GRO_DIST_DIR)) {
-            possible_source_ids.push((path.endsWith('/') || path.endsWith(TASK_FILE_SUFFIX_JS)
-                ? path
-                : path + TASK_FILE_SUFFIX_JS));
+            possible_paths.add({
+                id: (path.endsWith('/') || path.endsWith(TASK_FILE_SUFFIX_JS)
+                    ? path
+                    : path + TASK_FILE_SUFFIX_JS),
+                input_path,
+                root_dir,
+            });
         }
         else {
-            possible_source_ids.push(path);
+            possible_paths.add({ id: path, input_path, root_dir });
             if (!path.endsWith('/') && !extensions.some((e) => path.endsWith(e))) {
                 for (const extension of extensions) {
-                    possible_source_ids.push(path + extension);
+                    possible_paths.add({ id: path + extension, input_path, root_dir });
                 }
             }
         }
     };
     if (isAbsolute(input_path)) {
-        add_possible_source_ids(input_path);
+        // TODO this is hacky because it's the only place we're using sync fs calls (even if they're faster, it's oddly inconsistent),
+        // we probably should just change this function to check the filesystem and not return non-existing paths
+        add_possible_paths(input_path, existsSync(input_path) && statSync(input_path).isDirectory()
+            ? input_path
+            : dirname(input_path));
     }
     else {
         for (const root_dir of root_dirs) {
-            add_possible_source_ids(join(root_dir, input_path));
+            add_possible_paths(join(root_dir, input_path), root_dir);
         }
     }
-    return possible_source_ids;
+    return Array.from(possible_paths);
 };
 /**
  * Gets the path data for each input path, checking the filesystem for the possibilities
  * and stopping at the first existing file or falling back to the first existing directory.
  * If none is found for an input path, it's added to `unmapped_input_paths`.
  */
-export const load_source_path_data_by_input_path = async (input_paths, get_possible_source_ids_for_input_path) => {
-    const source_id_path_data_by_input_path = new Map();
+export const resolve_input_paths = async (input_paths, root_dirs, extensions) => {
+    const resolved_input_paths = [];
+    const possible_paths_by_input_path = new Map();
     const unmapped_input_paths = [];
     for (const input_path of input_paths) {
-        let file_path_data = null;
-        let dir_path_data = null;
-        const possible_source_ids = get_possible_source_ids_for_input_path
-            ? get_possible_source_ids_for_input_path(input_path)
-            : [input_path];
+        let found_file = null;
+        let found_dirs = null;
+        const possible_paths = get_possible_paths(input_path, root_dirs, extensions);
+        possible_paths_by_input_path.set(input_path, possible_paths);
         // Find the first existing file path or fallback to the first directory path.
-        for (const possible_source_id of possible_source_ids) {
-            if (!(await exists(possible_source_id)))
-                continue; // eslint-disable-line no-await-in-loop
-            const stats = await stat(possible_source_id); // eslint-disable-line no-await-in-loop
+        for (const possible_path of possible_paths) {
+            if (!existsSync(possible_path.id))
+                continue;
+            const stats = statSync(possible_path.id);
             if (stats.isDirectory()) {
-                if (dir_path_data)
-                    continue;
-                dir_path_data = to_path_data(possible_source_id, stats);
+                found_dirs ??= [];
+                found_dirs.push([{ id: possible_path.id, is_directory: stats.isDirectory() }, possible_path]);
             }
             else {
-                file_path_data = to_path_data(possible_source_id, stats);
+                found_file = [{ id: possible_path.id, is_directory: stats.isDirectory() }, possible_path];
                 break;
             }
         }
-        const path_data = file_path_data || dir_path_data;
-        if (path_data) {
-            source_id_path_data_by_input_path.set(input_path, path_data);
+        if (found_file) {
+            resolved_input_paths.push({
+                input_path,
+                id: found_file[0].id,
+                is_directory: found_file[0].is_directory,
+                root_dir: found_file[1].root_dir,
+            });
+        }
+        else if (found_dirs) {
+            for (const found_dir of found_dirs) {
+                resolved_input_paths.push({
+                    input_path,
+                    id: found_dir[0].id,
+                    is_directory: found_dir[0].is_directory,
+                    root_dir: found_dir[1].root_dir,
+                });
+            }
         }
         else {
             unmapped_input_paths.push(input_path);
         }
     }
-    return { source_id_path_data_by_input_path, unmapped_input_paths };
+    return {
+        resolved_input_paths,
+        resolved_input_paths_by_input_path: resolved_input_paths.reduce((map, resolved_input_path) => {
+            if (map.has(resolved_input_path.input_path)) {
+                map.get(resolved_input_path.input_path).push(resolved_input_path);
+            }
+            else {
+                map.set(resolved_input_path.input_path, [resolved_input_path]);
+            }
+            return map;
+        }, new Map()),
+        possible_paths_by_input_path,
+        unmapped_input_paths,
+    };
 };
 /**
  * Finds all of the matching files for the given input paths.
  * De-dupes source ids.
  */
-export const load_source_ids_by_input_path = async (source_id_path_data_by_input_path, custom_search_fs = search_fs) => {
-    const source_ids_by_input_path = new Map();
+export const resolve_input_files = async (resolved_input_paths, custom_search_fs = search_fs) => {
+    const resolved_input_files = [];
+    const resolved_input_files_by_input_path = new Map();
     const input_directories_with_no_files = [];
-    const existing_source_ids = new Set();
-    for (const [input_path, path_data] of source_id_path_data_by_input_path) {
-        const { id } = path_data;
-        if (path_data.isDirectory) {
-            const files = await custom_search_fs(id, { files_only: false }); // eslint-disable-line no-await-in-loop
-            if (files.size) {
-                const source_ids = [];
+    const existing_path_ids = new Set();
+    // TODO parallelize but would need to de-dupe and retain order
+    for (const resolved_input_path of resolved_input_paths) {
+        const { input_path, id, is_directory } = resolved_input_path;
+        if (is_directory) {
+            const files = await custom_search_fs(id, { include_directories: true }); // eslint-disable-line no-await-in-loop
+            if (files.length) {
+                const path_ids = [];
                 let has_files = false;
-                for (const [path, stats] of files) {
-                    if (stats.isDirectory())
+                for (const { path, is_directory } of files) {
+                    if (is_directory)
                         continue;
                     has_files = true;
-                    const source_id = join(id, path);
-                    if (!existing_source_ids.has(source_id)) {
-                        existing_source_ids.add(source_id);
-                        source_ids.push(source_id);
+                    const path_id = join(id, path);
+                    if (!existing_path_ids.has(path_id)) {
+                        existing_path_ids.add(path_id);
+                        path_ids.push(path_id);
                     }
                 }
-                if (source_ids.length) {
-                    source_ids_by_input_path.set(input_path, source_ids);
+                if (path_ids.length) {
+                    const resolved_input_files_for_input_path = [];
+                    for (const path_id of path_ids) {
+                        const resolved_input_file = {
+                            id: path_id,
+                            input_path,
+                            resolved_input_path,
+                        };
+                        resolved_input_files.push(resolved_input_file);
+                        resolved_input_files_for_input_path.push(resolved_input_file);
+                    }
+                    resolved_input_files_by_input_path.set(input_path, resolved_input_files_for_input_path);
                 }
                 if (!has_files) {
-                    input_directories_with_no_files.push(input_path);
+                    input_directories_with_no_files.push(resolved_input_path);
                 }
                 // do callers ever need `input_directories_with_duplicate_files`?
             }
             else {
-                input_directories_with_no_files.push(input_path);
+                input_directories_with_no_files.push(resolved_input_path);
             }
         }
-        else if (!existing_source_ids.has(id)) {
-            existing_source_ids.add(id);
-            source_ids_by_input_path.set(input_path, [id]);
+        else if (!existing_path_ids.has(id)) {
+            existing_path_ids.add(id);
+            const resolved_input_file = { id, input_path, resolved_input_path };
+            resolved_input_files.push(resolved_input_file);
+            resolved_input_files_by_input_path.set(input_path, [resolved_input_file]);
         }
     }
-    return { source_ids_by_input_path, input_directories_with_no_files };
-};
-// TODO I don't think this is valid any more, we shouldn't transform absolute paths like this,
-// the searching should happen with the input paths
-export const to_gro_input_path = (input_path) => {
-    const base_path = input_path === paths.lib.slice(0, -1) ? '' : strip_start(input_path, paths.lib);
-    return GRO_DIST_DIR + base_path;
+    return {
+        resolved_input_files,
+        resolved_input_files_by_input_path,
+        resolved_input_files_by_root_dir: resolved_input_files.reduce((map, resolved_input_file) => {
+            const { root_dir } = resolved_input_file.resolved_input_path;
+            if (map.has(root_dir)) {
+                map.get(root_dir).push(resolved_input_file);
+            }
+            else {
+                map.set(root_dir, [resolved_input_file]);
+            }
+            return map;
+        }, new Map()),
+        input_directories_with_no_files,
+    };
 };