@ryanatkn/gro 0.116.2 → 0.118.0

package/dist/gro_plugin_server.js

@@ -1,10 +1,10 @@
 import { spawn_restartable_process } from '@ryanatkn/belt/process.js';
 import * as esbuild from 'esbuild';
-import { cwd } from 'node:process';
 import { join, resolve } from 'node:path';
 import { identity } from '@ryanatkn/belt/function.js';
-import { strip_before } from '@ryanatkn/belt/string.js';
-import { base_path_to_source_id, GRO_DEV_DIRNAME, SERVER_DIST_PATH, LIB_DIRNAME, paths, } from './paths.js';
+import { strip_before, strip_end } from '@ryanatkn/belt/string.js';
+import { base_path_to_source_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';
 import { esbuild_plugin_sveltekit_shim_app } from './esbuild_plugin_sveltekit_shim_app.js';
@@ -16,10 +16,11 @@ import { esbuild_plugin_sveltekit_local_imports } from './esbuild_plugin_sveltek
 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 has_server = (path = SERVER_SOURCE_ID) => exists(path);
-export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = cwd(), outpaths = (dev) => ({
+export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = process.cwd(), outpaths = (dev) => ({
     outdir: join(dir, dev ? GRO_DEV_DIRNAME : SERVER_DIST_PATH),
     outbase: paths.lib,
     outname: 'server/server.js',
@@ -32,7 +33,10 @@ export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = cwd
     return {
         name: 'gro_plugin_server',
         setup: async ({ dev, watch, timings, log }) => {
-            const { alias, base_url, assets_url, env_dir, private_prefix, public_prefix, svelte_compile_options, svelte_compile_module_options, svelte_preprocessors, } = await init_sveltekit_config(sveltekit_config ?? dir);
+            const parsed_sveltekit_config = !sveltekit_config && strip_end(dir, '/') === process.cwd()
+                ? sveltekit_config_global
+                : await init_sveltekit_config(sveltekit_config ?? dir);
+            const { alias, base_url, assets_url, env_dir, private_prefix, public_prefix, svelte_compile_options, svelte_compile_module_options, svelte_preprocessors, } = parsed_sveltekit_config;
             // TODO hacky
             if (svelte_compile_options.generate === undefined) {
                 svelte_compile_options.generate = 'server';

package/dist/gro_plugin_sveltekit_app.d.ts

@@ -1,7 +1,6 @@
 import type { Plugin, Plugin_Context } from './plugin.js';
 import { type Map_Package_Json } from './package_json.js';
 import { type Map_Src_Json } from './src_json.js';
-export declare const has_sveltekit_app: () => Promise<boolean>;
 export interface Options {
     /**
      * Used for finalizing a SvelteKit build like adding a `.nojekyll` file for GitHub Pages.

package/dist/gro_plugin_sveltekit_app.js

@@ -4,13 +4,11 @@ import { dirname, join } from 'node:path';
 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 { init_sveltekit_config } from './sveltekit_config.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_FILENAME } from './paths.js';
-export const has_sveltekit_app = () => exists(SVELTEKIT_CONFIG_FILENAME);
+import { sveltekit_config_global } from './sveltekit_config_global.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 {
@@ -57,7 +55,7 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
                 // maybe a Vite middleware is best? what if this plugin added its plugin to your `vite.config.ts`?
                 // copy files to `static` before building, in such a way
                 // that's non-destructive to existing files and dirs and easy to clean up
-                const { assets_path } = await init_sveltekit_config(); // TODO probably put in plugin context
+                const { assets_path } = sveltekit_config_global;
                 const cleanups = [
                     serialized_package_json
                         ? await create_temporarily(join(assets_path, '.well-known/package.json'), serialized_package_json)

package/dist/gro_plugin_sveltekit_library.d.ts

@@ -1,4 +1,2 @@
 import type { Plugin, Plugin_Context } from './plugin.js';
-import { Package_Json } from './package_json.js';
-export declare const has_sveltekit_library: (package_json?: Package_Json) => Promise<boolean>;
 export declare const gro_plugin_sveltekit_library: () => Plugin<Plugin_Context>;

package/dist/gro_plugin_sveltekit_library.js

@@ -1,14 +1,8 @@
 import { print_spawn_result, spawn } from '@ryanatkn/belt/process.js';
 import { Task_Error } from './task.js';
-import { Package_Json, load_package_json } from './package_json.js';
+import { load_package_json } from './package_json.js';
 import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
 import { find_cli, spawn_cli } from './cli.js';
-export const has_sveltekit_library = async (package_json) => {
-    const p = package_json ?? (await load_package_json()); // TODO from param, on config?
-    return !!p.devDependencies?.['@sveltejs/package'] || !!p.dependencies?.['@sveltejs/package'];
-    // TODO @multiple get from the sveltekit config
-    // && exists(sveltekit_config.lib_path);
-};
 export const gro_plugin_sveltekit_library = () => {
     return {
         name: 'gro_plugin_sveltekit_library',

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 {
         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;
+};

package/dist/input_path.test.js

@@ -1,68 +1,47 @@
-import { suite } from 'uvu';
+import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { resolve } from 'node:path';
-import { resolve_input_path, resolve_input_paths, load_source_ids_by_input_path, get_possible_source_ids, } from './input_path.js';
-import { paths } from './paths.js';
-/* test__resolve_input_path */
-const test__resolve_input_path = suite('resolve_input_path');
-test__resolve_input_path('basic behavior', () => {
-    const target = resolve('dist/foo/bar.ts');
-    assert.is(resolve_input_path('foo/bar.ts'), target);
-    assert.is(resolve_input_path('src/lib/foo/bar.ts'), target);
-    assert.is(resolve_input_path('./src/lib/foo/bar.ts'), target);
-    assert.is(resolve_input_path('./foo/bar.ts'), target); // questionable
-    assert.is(resolve_input_path(target), target);
-    assert.is.not(resolve_input_path('bar.ts'), target);
+import { to_input_path, to_input_paths, load_source_ids_by_input_path, get_possible_source_ids, } 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'));
+    assert.is(to_input_path('./foo.ts'), resolve('foo.ts'));
+    assert.is(to_input_path('foo.ts'), 'foo.ts');
+    assert.is(to_input_path('gro/foo'), GRO_DIST_DIR + 'foo');
+    // trailing slashes are preserved:
+    assert.is(to_input_path(resolve('foo/bar/')), resolve('foo/bar/'));
+    assert.is(to_input_path('./foo/bar/'), resolve('foo/bar/'));
+    assert.is(to_input_path('foo/bar/'), 'foo/bar/');
 });
-test__resolve_input_path('directories', () => {
-    const target_dir = resolve('dist/foo/bar');
-    assert.is(resolve_input_path('foo/bar'), target_dir);
-    assert.is(resolve_input_path('foo/bar/'), target_dir);
-    assert.is(resolve_input_path('./foo/bar'), target_dir);
-    assert.is(resolve_input_path('./foo/bar/'), target_dir);
-    assert.is.not(resolve_input_path('bar'), target_dir);
-});
-test__resolve_input_path.run();
-/* test__resolve_input_path */
-/* test__resolve_input_paths */
-const test__resolve_input_paths = suite('resolve_input_paths');
-test__resolve_input_paths('resolves multiple input path forms', () => {
-    assert.equal(resolve_input_paths(['foo/bar.ts', 'baz', './']), [
-        resolve('dist/foo/bar.ts'),
-        resolve('dist/baz'),
-        resolve('dist') + '/',
+test('to_input_paths', () => {
+    assert.equal(to_input_paths([resolve('foo/bar.ts'), './baz', 'foo']), [
+        resolve('foo/bar.ts'),
+        resolve('baz'),
+        'foo',
     ]);
 });
-test__resolve_input_paths.run();
-/* test__resolve_input_paths */
-/* test__get_possible_source_ids */
-const test__get_possible_source_ids = suite('get_possible_source_ids');
-test__get_possible_source_ids('in the gro directory', () => {
+test('get_possible_source_ids in the gro directory', () => {
     const input_path = resolve('src/foo/bar');
-    assert.equal(get_possible_source_ids(input_path, ['.baz.ts']), [
+    assert.equal(get_possible_source_ids(input_path, ['.baz.ts'], []), [
         input_path,
         input_path + '.baz.ts',
-        input_path + '/bar.baz.ts',
     ]);
 });
-test__get_possible_source_ids('does not repeat the extension', () => {
+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]);
+    assert.equal(get_possible_source_ids(input_path, ['.baz.ts'], []), [input_path]);
 });
-test__get_possible_source_ids('does not repeat with the same root directory', () => {
+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_source_ids('implied to be a directory by trailing slash', () => {
+test('get_possible_source_ids 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_source_ids(input_path, ['.baz.ts'], []), [input_path]);
 });
-test__get_possible_source_ids.run();
-/* test__get_possible_source_ids */
-/* test__load_source_ids_by_input_path */
-const test__load_source_ids_by_input_path = suite('load_source_ids_by_input_path', async () => {
+test('load_source_ids_by_input_path', 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 }]]),
@@ -102,5 +81,4 @@ const test__load_source_ids_by_input_path = suite('load_source_ids_by_input_path
         input_directories_with_no_files: ['fake/nomatches'],
     });
 });
-test__load_source_ids_by_input_path.run();
-/* test__load_source_ids_by_input_path */
+test.run();

package/dist/invoke_task.d.ts

@@ -17,4 +17,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: string, args: Args, config: Gro_Config, timings?: any) => Promise<void>;
+export declare const invoke_task: (task_name: Flavored<string, "Raw_Input_Path">, args: Args, config: Gro_Config, timings?: any) => Promise<void>;