@ryanatkn/gro 0.116.2 → 0.117.0

package/dist/config.d.ts

@@ -8,6 +8,11 @@ export interface Gro_Config {
      * Returning `null` is a no-op for the caller.
      */
     map_package_json: Map_Package_Json | null;
+    /**
+     * The root directories to search for tasks given implicit relative input paths.
+     * Defaults to `./src/lib`, then the cwd, then the Gro package dist.
+     */
+    task_root_paths: string[];
 }
 export interface Create_Gro_Config {
     (base_config: Gro_Config): Gro_Config | Promise<Gro_Config>;

package/dist/config.js

@@ -1,11 +1,12 @@
-import { join } from 'node:path';
-import { CONFIG_PATH, paths } from './paths.js';
+import { join, resolve } from 'node:path';
+import { CONFIG_PATH, GRO_DIST_DIR, IS_THIS_GRO, paths } from './paths.js';
 import create_default_config from './gro.config.default.js';
 import { exists } from './fs.js';
 export const create_empty_config = () => ({
     plugins: () => [],
     // TODO maybe disable if no SvelteKit `lib` directory? or other detection to improve defaults
     map_package_json: default_map_package_json,
+    task_root_paths: [paths.lib, paths.root, IS_THIS_GRO ? null : GRO_DIST_DIR].filter(Boolean),
 });
 const default_map_package_json = async (package_json) => {
     if (package_json.exports) {
@@ -25,12 +26,18 @@ export const load_config = async (dir = paths.root) => {
             typeof config_module.default === 'function'
                 ? await config_module.default(default_config)
                 : config_module.default;
+        normalize_config(config);
     }
     else {
         config = default_config;
     }
     return config;
 };
+// Mutates `config` with cleaned up values.
+const normalize_config = (config) => {
+    // TODO any validation?
+    config.task_root_paths = config.task_root_paths.map((p) => resolve(p));
+};
 export const validate_config_module = (config_module, config_path) => {
     const config = config_module.default;
     if (!config) {

package/dist/docs/config.md

@@ -44,6 +44,7 @@ export interface Create_Gro_Config {
 export interface Gro_Config {
 	plugins: Create_Config_Plugins;
 	map_package_json: Map_Package_Json | null;
+	task_root_paths: string[];
 }
 ```
 
@@ -80,6 +81,20 @@ const config: Create_Gro_Config = async (cfg) => {
 export default config;
 ```
 
+You can also export a config object and use `create_empty_config` to get the defaults:
+
+```ts
+import {create_empty_config} from '@ryanatkn/gro/config.js';
+
+const config = create_empty_config();
+
+// config.plugins = ...;
+// config.map_package_json = ...;
+// config.task_root_paths = ...;
+
+export default config;
+```
+
 See also [Gro's own internal config](/gro.config.ts).
 
 ## `plugins`
@@ -160,3 +175,13 @@ export interface Map_Package_Json {
 	(package_json: Package_Json): Package_Json | null | Promise<Package_Json | null>;
 }
 ```
+
+## `task_root_paths`
+
+The Gro config option `task_root_paths` allows customizing Gro's task resolution.
+When calling `gro [input_path]`, absolute and explicitly relative paths starting with `.`
+are resolved according to normal filesystem rules,
+but non-explicit input paths, like `foo`, are resolved by searching
+through `task_root_paths` in order until a matching file or directory is found on the filesystem.
+
+The default task paths are `./src/lib`, then `.`, and then Gro's dist directory.

package/dist/docs/task.md

@@ -21,30 +21,29 @@ and defers composition to the user in regular TypeScript modules.
 > use the `gro run` task, which works like the normal `node` CLI
 > but uses the Gro loader to support `.ts`.
 
-- Gro automatically discovers [all `*.task.ts` files](../docs/tasks.md)
-  in your source directory, so creating a new task
-  is as simple as [creating a new file](#define-a-task), no config needed,
-  but part of the convention is that Gro expects all source code to be in `src/`
+- tasks are defined by naming files with the `.task.ts` and `.task.js` suffixes
+- tasks can be run from the CLI via a name (`gro foo`),
+  which uses Gro's task resolution (see more below),
+  or via paths that are absolute (`gro /path/to/foo`) or explicitly relative (`gro ./foo`)
+- Gro automatically discovers all `*.task.ts|js` files
+  in its configurable directory, so creating a new task
+  is as simple as [creating a new file](#define-a-task), no config needed
+  (defaults to `src/lib`, see the config option [`task_root_paths`](./config.md#task_root_paths))
+- to view [the available tasks](https://github.com/ryanatkn/gro/blob/main/src/lib/docs/tasks.md)
+  run `gro` with no arguments
 - task definitions are just objects with an async `run` function and some optional properties,
   so composing tasks is explicit in your code, just like any other module
-  (but there's also the helper `invoke_task`: see more below)
-- on the command line, tasks replace the concept of commands,
-  so running them is as simple as `gro <task>`,
-  and in code the task object's `run` function has access to CLI args;
-  to view [the available tasks](https://github.com/ryanatkn/gro/blob/main/src/lib/docs/tasks.md)
-  run `gro` with no arguments
+  (but there's also the helper `invoke_task`, see more below)
+- the task object's `run` function has access to CLI args
 - tasks optionally use [zod](https://github.com/colinhacks/zod) schemas
   for `args` types, runtime parsing with helpful validation errors,
-  and automatic help output, with DRY co-located definitions
-- it's easy to hook into or override any of Gro's builtin tasks,
-  like [`gro test`](/src/lib/test.task.ts) and [`gro gen`](/src/lib/gen.task.ts)
-  (tasks are copy-paste friendly! just update the imports)
-- the task execution environment is filesystem agnostic by default; `run` receives a
-  [`Task_Context` argument](#user-content-types-task-and-taskcontext) with an `fs` property
-- the `Task_Context` provides a rich baseline context object
-  for both development/build tasks and one-off script authoring/execution;
-  it attempts to be portable and extensibile, but there's a _lot_ of room for improvement
-- it's fast because it imports only the modules that your chosen tasks need
+  and generated help docs (`gro foo --help`), with DRY co-located definitions
+- it's easy to call into or override any of Gro's builtin tasks,
+  like [`gro test`](/src/lib/test.task.ts) and [`gro gen`](/src/lib/gen.task.ts) -
+  your own versions with the same name take precedence, and you can invoke the base
+  tasks using the `gro/` prefix, e.g. `gro gro/test`
+  (tasks are also copy-paste friendly! just update the imports)
+- it's fast because it imports only the modules imported by your invoked tasks, not every task's
 
 The task runner's purpose is to provide an ergonomic interface
 between the CLI, build tools, and app code.
@@ -55,18 +54,24 @@ As a developer, it's nice to be able to reuse TypeScript modules in every contex
 ### show all available tasks
 
 ```bash
-# This looks through `src/` in both the current working directory
-# and Gro's source for all files matching `*.task.ts` and logs them out.
+# This looks through `src/lib` in both the current working directory and Gro's source
+# for all files matching `*.task.ts|js` and logs them out with their args docs.
 $ gro
 ```
 
-> notice that Gro is hardcoded to expect all tasks to be in `src/` --
-> it would be nice to loosen this up, but the API isn't obvious to me right now
+The [config](./config.md) option [task_root_paths](./config.md#task_root_paths)
+tells Gro where to search for tasks.
+
+> Currently, only the first directory specified in `task_root_paths` that's found on the filesystem
+> will be used to automatically discover tasks, like when running `gro` without args.
+> Please open an issue if you would like to see Gro be able to discover
+> tasks in more than one directory - it will take some reworking of internals
+> but it seems like the right design.
 
 ### show tasks in a directory
 
 ```bash
-# Logs all `*.task.ts` files in `src/lib/some/dir` and `gro/src/lib/some/dir`.
+# Logs all `*.task.ts|js` files in `src/lib/some/dir` and `gro/src/lib/some/dir`.
 # If no tasks are found, it displays an error.
 $ gro some/dir
 ```
@@ -329,7 +334,7 @@ export const task: Task = {
 
 ## why?
 
-Gro usage on the command line (`gro <taskOrDirectory> [...flags]`)
+Gro usage on the command line (`gro <task_name_or_directory> [...flags]`)
 looks a lot like using `node`.
 What makes Gro different?
 
@@ -337,14 +342,15 @@ What makes Gro different?
   contains task modules that conform to some interface.
   This allows them to be discoverable by convention,
   so running `gro` displays them all without any config, and it puts generic handles on them,
-  enabling various verbs (e.g. `run`) and structured metadata (e.g. `summary`).
-- Tasks aren't just a script, they can be inspected, composed, and manipulated in code.
+  enabling various verbs (e.g. `run`) and
+  structured metadata (e.g. `summary` and args schemas for docs and validation).
+- Tasks aren't just a script on the filesystem, they can be composed and inspected in code.
   Task modules do not have any side effects when imported,
   while Node scripts just execute when imported -
-  their primary purpose is to cause side effects.
+  their primary purpose is to cause side effects, and they're limited to the filesystem API.
   This is useful in many cases - for example `gro taskname --help`
   inspects the args schema and other metadata to print help to the console,
-  and `gro` prints the `summary` property of each task it finds.
+  and `gro` prints the `summary` property of each task it discovers.
   There's lots more to explore here, like task composition
   and improved DX with new capabilities.
 - Tasks support CLI args that are validated and typesafe
@@ -353,8 +359,8 @@ What makes Gro different?
   - When a task name is given to Gro,
     it first searches `src/lib/` in the current working directory and
     falls back to searching the Gro directory.
-    This allows your code and CLI commands to use Gro's builtin tasks
-    or override or extend them without changing how you invoke them.
+    This allows your code and CLI commands to compose Gro's builtin tasks
+    or override them without changing how you invoke them.
     Gro reserves no special behavior for its own commands -
     `gro test`, `gro gen`, and all the rest are just tasks that all follow the same rules.
     (see its task at [`src/lib/test.task.ts`](/src/lib/test.task.ts)).

package/dist/docs/tasks.gen.md.js

@@ -4,7 +4,7 @@ import { strip_start } from '@ryanatkn/belt/string.js';
 import { to_output_file_name } from '../gen.js';
 import { paths, base_path_to_source_id } from '../paths.js';
 import { load_task_modules } from '../task_module.js';
-import { log_error_reasons } from '../print_task.js';
+import { log_error_reasons } from '../task_logging.js';
 // This is the first simple implementation of Gro's automated docs.
 // It combines Gro's gen and task systems
 // to generate a markdown file describing all of the project's tasks.
@@ -15,7 +15,7 @@ import { log_error_reasons } from '../print_task.js';
 // TODO needs some cleanup and better APIs - paths are confusing and verbose!
 // TODO add backlinks to every document that links to this one
 export const gen = async ({ origin_id, log }) => {
-    const result = await load_task_modules();
+    const result = await load_task_modules([paths.lib]);
     if (!result.ok) {
         log_error_reasons(log, result.reasons);
         throw new Error(result.type);

package/dist/gen.task.js

@@ -7,14 +7,14 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { Task_Error } from './task.js';
 import { run_gen } from './run_gen.js';
 import { load_gen_module, check_gen_modules, find_gen_modules } from './gen_module.js';
-import { resolve_input_paths } from './input_path.js';
+import { Raw_Input_Path, to_input_paths } from './input_path.js';
 import { load_modules } from './modules.js';
 import { format_file } from './format_file.js';
-import { print_path } from './paths.js';
-import { log_error_reasons } from './print_task.js';
+import { paths, print_path } from './paths.js';
+import { log_error_reasons } from './task_logging.js';
 export const Args = z
     .object({
-    _: z.array(z.string(), { description: 'paths to generate' }).default([]),
+    _: z.array(Raw_Input_Path, { description: 'paths to generate' }).default([]),
     check: z
         .boolean({ description: 'exit with a nonzero code if any files need to be generated' })
         .default(false),
@@ -27,8 +27,7 @@ export const task = {
     Args,
     run: async ({ args, log, timings }) => {
         const { _: raw_input_paths, check } = args;
-        // resolve the input paths relative to src/lib/
-        const input_paths = resolve_input_paths(raw_input_paths);
+        const input_paths = raw_input_paths.length ? to_input_paths(raw_input_paths) : [paths.source];
         // load all of the gen modules
         const find_modules_result = await find_gen_modules(input_paths);
         if (!find_modules_result.ok) {

package/dist/gen_module.d.ts

@@ -1,5 +1,6 @@
 import { type Module_Meta, type Load_Module_Result, type Find_Modules_Result } from './modules.js';
 import type { Gen, Gen_Results, Gen_File } from './gen.js';
+import { Input_Path } from './input_path.js';
 export declare const GEN_FILE_PATTERN_TEXT = "gen";
 export declare const GEN_FILE_PATTERN: string;
 export declare const is_gen_path: (path: string) => boolean;
@@ -43,4 +44,4 @@ export type Check_Gen_Module_Result = {
 };
 export declare const check_gen_modules: (gen_results: Gen_Results) => Promise<Check_Gen_Module_Result[]>;
 export declare const check_gen_module: (file: Gen_File) => Promise<Check_Gen_Module_Result>;
-export declare const find_gen_modules: (input_paths?: string[], extensions?: string[], root_dirs?: string[]) => Promise<Find_Modules_Result>;
+export declare const find_gen_modules: (input_paths?: Input_Path[], extensions?: string[], root_dirs?: string[]) => Promise<Find_Modules_Result>;

package/dist/gen_module.js

@@ -1,6 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { load_module, find_modules, } from './modules.js';
-import { get_possible_source_ids } from './input_path.js';
+import { Input_Path, get_possible_source_ids } from './input_path.js';
 import { paths } from './paths.js';
 import { search_fs } from './search_fs.js';
 import { exists } from './fs.js';

package/dist/input_path.d.ts

@@ -1,48 +1,47 @@
+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';
+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;
+export type Raw_Input_Path = Flavored<z.infer<typeof Raw_Input_Path>, 'Raw_Input_Path'>;
 /**
- * Raw input paths are paths that users provide to Gro to reference files
- * enhanced with Gro's conventions like `.test.`, `.task.`, and `.gen.`.
+ * Raw input paths are paths that users provide to Gro to reference files for tasks and gen.
  *
- * A raw input path can be:
+ * A raw input path can be to a file or directory in the following forms:
  *
- * - a relative path to a file, e.g. `src/foo/bar.test.ts`
- * - a file without an extension, e.g. `src/foo/bar` if `extensions` is `.test.ts`
- * - a directory containing any number of files, e.g. `src/foo`
- * - any of the above without the leading `src/` or with a leading `./`
- * - any of the above but leading with `gro/` to ignore the local directory
- * - an absolute path to a file or directory in the current directory or Gro's
+ * - an absolute path, preserved
+ * - an explicit relative path, e.g. `./src/foo`, resolved to `root_path` which defaults to the cwd
+ * - an implicit relative path, e.g. `src/foo`, preserved
+ * - an implicit relative path prefixed with `gro/`, transformed to absolute in the Gro directory
  *
- * The input path API lets the caller customize the allowable extensions.
- * That means that the caller can look for `.test.` files but not `.gen.`,
- * or both, or neither, depending on its needs.
- *
- * In the future we may want to support globbing or regexps.
+ * Thus, input paths are either absolute or implicitly relative.
  */
-export declare const resolve_input_path: (raw_input_path: string) => string;
-export declare const resolve_input_paths: (raw_input_paths?: string[]) => string[];
+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_paths: (raw_input_paths: Raw_Input_Path[], root_path?: string) => Input_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.
  */
-export declare const get_possible_source_ids: (input_path: string, extensions: string[], root_dirs?: string[]) => string[];
+export declare const get_possible_source_ids: (input_path: Flavored<string, "Input_Path">, extensions: string[], root_dirs?: string[]) => Source_Id[];
 /**
- * Gets the path data for each input path,
- * searching for the possibilities based on `extensions`
- * and stopping at the first match.
- * Parameterized by `exists` and `stat` so it's fs-agnostic.
+ * 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: string[], get_possible_source_ids_for_input_path?: (input_path: string) => string[]) => Promise<{
-    source_id_path_data_by_input_path: Map<string, Path_Data>;
-    unmapped_input_paths: string[];
+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[];
 }>;
 /**
  * Finds all of the matching files for the given input paths.
- * Parameterized by `find_files` so it's fs-agnostic.
  * De-dupes source ids.
  */
-export declare const load_source_ids_by_input_path: (source_id_path_data_by_input_path: Map<string, 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<string, string[]>;
-    input_directories_with_no_files: string[];
+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">;

package/dist/input_path.js

@@ -1,48 +1,37 @@
-import { join, isAbsolute, basename } from 'node:path';
-import { strip_end, strip_start } from '@ryanatkn/belt/string.js';
+import { isAbsolute, join, resolve } from 'node:path';
+import { strip_start } from '@ryanatkn/belt/string.js';
 import { stat } from 'node:fs/promises';
-import { lib_path_to_import_id, replace_root_dir, gro_dir_basename, gro_paths, LIB_DIR, LIB_PATH, is_this_project_gro, gro_sveltekit_dist_dir, paths, } from './paths.js';
+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 { 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
+export const Input_Path = z.string();
+export const Raw_Input_Path = z.string();
 /**
- * Raw input paths are paths that users provide to Gro to reference files
- * enhanced with Gro's conventions like `.test.`, `.task.`, and `.gen.`.
+ * Raw input paths are paths that users provide to Gro to reference files for tasks and gen.
  *
- * A raw input path can be:
+ * A raw input path can be to a file or directory in the following forms:
  *
- * - a relative path to a file, e.g. `src/foo/bar.test.ts`
- * - a file without an extension, e.g. `src/foo/bar` if `extensions` is `.test.ts`
- * - a directory containing any number of files, e.g. `src/foo`
- * - any of the above without the leading `src/` or with a leading `./`
- * - any of the above but leading with `gro/` to ignore the local directory
- * - an absolute path to a file or directory in the current directory or Gro's
+ * - an absolute path, preserved
+ * - an explicit relative path, e.g. `./src/foo`, resolved to `root_path` which defaults to the cwd
+ * - an implicit relative path, e.g. `src/foo`, preserved
+ * - an implicit relative path prefixed with `gro/`, transformed to absolute in the Gro directory
  *
- * The input path API lets the caller customize the allowable extensions.
- * That means that the caller can look for `.test.` files but not `.gen.`,
- * or both, or neither, depending on its needs.
- *
- * In the future we may want to support globbing or regexps.
+ * Thus, input paths are either absolute or implicitly relative.
  */
-export const resolve_input_path = (raw_input_path) => {
-    if (isAbsolute(raw_input_path))
-        return strip_end(raw_input_path, '/');
-    // Allow prefix `./` and just remove it if it's there.
-    let base_path = strip_end(strip_start(raw_input_path, './'), '/');
-    let paths;
-    // If it's prefixed with `gro/` or exactly `gro`, use the Gro paths.
-    if (is_this_project_gro || (base_path + '/').startsWith(gro_dir_basename)) {
-        paths = gro_paths;
-        base_path = strip_end(strip_start(base_path + '/', gro_dir_basename), '/');
+export const to_input_path = (raw_input_path, root_path = process.cwd()) => {
+    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);
     }
-    // Handle `src/lib` by itself without conflicting with `src/libFoo` names.
-    if (base_path === LIB_PATH)
-        base_path = ''; // TODO @multiple get from the sveltekit config
-    // Allow prefix `src/lib/` and just remove it if it's there.
-    base_path = strip_start(base_path, LIB_DIR);
-    return lib_path_to_import_id(base_path, paths);
+    return raw_input_path;
 };
-export const resolve_input_paths = (raw_input_paths) => raw_input_paths?.length ? raw_input_paths.map((p) => resolve_input_path(p)) : [paths.source];
+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`.
@@ -50,39 +39,37 @@ export const resolve_input_paths = (raw_input_paths) => raw_input_paths?.length
  * It's the helper used in implementations of `get_possible_source_ids_for_input_path` below.
  */
 export const get_possible_source_ids = (input_path, extensions, root_dirs) => {
-    const possible_source_ids = [input_path];
-    if (!input_path.endsWith('/')) {
-        for (const extension of extensions) {
-            if (!input_path.endsWith(extension)) {
-                possible_source_ids.push(input_path + extension);
-                // Support task directories, so `src/lib/a/a.task.ts` works like `src/a.task.ts`.
-                possible_source_ids.push(join(input_path, basename(input_path) + extension));
+    const possible_source_ids = [];
+    const add_possible_source_ids = (path) => {
+        // 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));
+        }
+        else {
+            possible_source_ids.push(path);
+            if (!path.endsWith('/') && !extensions.some((e) => path.endsWith(e))) {
+                for (const extension of extensions) {
+                    possible_source_ids.push(path + extension);
+                }
             }
         }
+    };
+    if (isAbsolute(input_path)) {
+        add_possible_source_ids(input_path);
     }
-    if (root_dirs?.length) {
-        const ids = possible_source_ids.slice(); // make a copy or infinitely loop!
+    else if (root_dirs?.length) {
         for (const root_dir of root_dirs) {
-            if (input_path.startsWith(root_dir))
-                continue; // avoid duplicates
-            const is_gro_dist = root_dir === gro_sveltekit_dist_dir; // TODO hacky to handle Gro importing its JS tasks from dist/
-            for (const possible_source_id of ids) {
-                if (is_gro_dist && !possible_source_id.endsWith('.js'))
-                    continue;
-                // TODO hacky to handle Gro importing its JS tasks from dist/
-                possible_source_ids.push(is_gro_dist
-                    ? gro_sveltekit_dist_dir + strip_start(possible_source_id, paths.lib)
-                    : replace_root_dir(possible_source_id, root_dir, paths));
-            }
+            add_possible_source_ids(join(root_dir, input_path));
         }
     }
     return possible_source_ids;
 };
 /**
- * Gets the path data for each input path,
- * searching for the possibilities based on `extensions`
- * and stopping at the first match.
- * Parameterized by `exists` and `stat` so it's fs-agnostic.
+ * 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();
@@ -93,22 +80,24 @@ export const load_source_path_data_by_input_path = async (input_paths, get_possi
         const possible_source_ids = get_possible_source_ids_for_input_path
             ? get_possible_source_ids_for_input_path(input_path)
             : [input_path];
+        // 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
             if (stats.isDirectory()) {
-                if (!dir_path_data) {
-                    dir_path_data = to_path_data(possible_source_id, stats);
-                }
+                if (dir_path_data)
+                    continue;
+                dir_path_data = to_path_data(possible_source_id, stats);
             }
             else {
                 file_path_data = to_path_data(possible_source_id, stats);
                 break;
             }
         }
-        if (file_path_data || dir_path_data) {
-            source_id_path_data_by_input_path.set(input_path, file_path_data || dir_path_data); // the ! is needed because TypeScript inference fails
+        const path_data = file_path_data || dir_path_data;
+        if (path_data) {
+            source_id_path_data_by_input_path.set(input_path, path_data);
         }
         else {
             unmapped_input_paths.push(input_path);
@@ -118,7 +107,6 @@ export const load_source_path_data_by_input_path = async (input_paths, get_possi
 };
 /**
  * Finds all of the matching files for the given input paths.
- * Parameterized by `find_files` so it's fs-agnostic.
  * 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) => {
@@ -132,7 +120,9 @@ export const load_source_ids_by_input_path = async (source_id_path_data_by_input
             if (files.size) {
                 const source_ids = [];
                 let has_files = false;
-                for (const path of files.keys()) {
+                for (const [path, stats] of files) {
+                    if (stats.isDirectory())
+                        continue;
                     has_files = true;
                     const source_id = join(id, path);
                     if (!existing_source_ids.has(source_id)) {
@@ -146,7 +136,7 @@ export const load_source_ids_by_input_path = async (source_id_path_data_by_input
                 if (!has_files) {
                     input_directories_with_no_files.push(input_path);
                 }
-                // do callers ever need `inputDirectoriesWithDuplicateFiles`?
+                // do callers ever need `input_directories_with_duplicate_files`?
             }
             else {
                 input_directories_with_no_files.push(input_path);
@@ -159,3 +149,9 @@ export const load_source_ids_by_input_path = async (source_id_path_data_by_input
     }
     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;
+};