@ryanatkn/gro 0.116.2 → 0.118.0

package/dist/publish.task.js

@@ -5,8 +5,8 @@ import { Task_Error } from './task.js';
 import { load_package_json, parse_repo_url } from './package_json.js';
 import { find_cli, spawn_cli } from './cli.js';
 import { exists } from './fs.js';
-import { is_this_project_gro } from './paths.js';
-import { has_sveltekit_library } from './gro_plugin_sveltekit_library.js';
+import { IS_THIS_GRO } from './paths.js';
+import { has_sveltekit_library } from './sveltekit_helpers.js';
 import { update_changelog } from './changelog.js';
 import { load_from_env } from './env.js';
 import { Git_Branch, Git_Origin, git_checkout, git_fetch, git_pull } from './git.js';
@@ -55,7 +55,7 @@ export const task = {
             throw new Task_Error('gro publish failed to detect a library, run `npm i -D @sveltejs/package` to enable it');
         }
         // TODO hacky, ensures Gro bootstraps itself
-        if (is_this_project_gro) {
+        if (IS_THIS_GRO) {
             await spawn('npm', ['run', 'build']);
         }
         const changelog_exists = await exists(changelog);

package/dist/register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/register.js

@@ -0,0 +1,2 @@
+import { register } from 'node:module';
+register('./loader.js', import.meta.url);

package/dist/release.task.js

@@ -1,6 +1,5 @@
 import { z } from 'zod';
-import { has_sveltekit_library } from './gro_plugin_sveltekit_library.js';
-import { has_sveltekit_app } from './gro_plugin_sveltekit_app.js';
+import { has_sveltekit_library, has_sveltekit_app } from './sveltekit_helpers.js';
 export const Args = z.object({}).strict();
 export const task = {
     summary: 'publish and deploy',

package/dist/resolve_node_specifier.js

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import { Package_Json, load_package_json } from './package_json.js';
-import { NODE_MODULES_DIRNAME, Source_Id, paths } from './paths.js';
+import { Source_Id, paths } from './paths.js';
+import { NODE_MODULES_DIRNAME } from './path_constants.js';
 export const resolve_node_specifier = async (specifier, dir = paths.root, parent_url, cache, exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default') => {
     const parsed = parse_node_specifier(specifier);
     const subpath = './' + parsed.path;

package/dist/run_gen.d.ts

@@ -1,6 +1,7 @@
 import { type Gen_Module_Meta } from './gen_module.js';
 import { type Gen_Results } from './gen.js';
 import type { format_file as base_format_file } from './format_file.js';
+import type { Gro_Config } from './config.js';
 export declare const GEN_NO_PROD_MESSAGE = "gen runs only during development";
-export declare const run_gen: (gen_modules: Gen_Module_Meta[], log: Logger, timings: Timings, format_file?: typeof base_format_file) => Promise<Gen_Results>;
+export declare const run_gen: (gen_modules: Gen_Module_Meta[], config: Gro_Config, log: Logger, timings: Timings, format_file?: typeof base_format_file) => Promise<Gen_Results>;
 export declare const to_gen_import_path: (id: string) => string;

package/dist/run_gen.js

@@ -6,7 +6,7 @@ import { GEN_SCHEMA_PATH_SUFFIX } from './gen_module.js';
 import { to_gen_result, } from './gen.js';
 import { print_path, source_id_to_base_path } from './paths.js';
 export const GEN_NO_PROD_MESSAGE = 'gen runs only during development';
-export const run_gen = async (gen_modules, log, timings, format_file) => {
+export const run_gen = async (gen_modules, config, log, timings, format_file) => {
     let input_count = 0;
     let output_count = 0;
     const timing_for_run_gen = timings.start('run_gen');
@@ -15,7 +15,7 @@ export const run_gen = async (gen_modules, log, timings, format_file) => {
         const { id } = module_meta;
         const timing_for_module = timings.start(id);
         // Perform code generation by calling `gen` on the module.
-        const gen_ctx = { origin_id: id, log };
+        const gen_ctx = { origin_id: id, config, log };
         let raw_gen_result;
         try {
             switch (module_meta.type) {

package/dist/run_gen.test.js

@@ -4,6 +4,7 @@ import { resolve, join } from 'node:path';
 import { Logger } from '@ryanatkn/belt/log.js';
 import { Timings } from '@ryanatkn/belt/timings.js';
 import { run_gen } from './run_gen.js';
+import { load_config } from './config.js';
 const log = new Logger('test__gen'); // TODO test logger?
 /* test__gen */
 const test__gen = suite('gen');
@@ -69,7 +70,7 @@ test__gen('basic behavior', async () => {
         },
     };
     const gen_modules_by_input_path = [mod_a, mod_b, mod_c];
-    const gen_results = await run_gen(gen_modules_by_input_path, log, new Timings(), async (content, opts) => opts.filepath.endsWith('output_b.ts') ? `${content}/*FORMATTED*/` : content);
+    const gen_results = await run_gen(gen_modules_by_input_path, await load_config(), log, new Timings(), async (content, opts) => opts.filepath.endsWith('output_b.ts') ? `${content}/*FORMATTED*/` : content);
     assert.is(gen_results.input_count, 3);
     assert.is(gen_results.output_count, 4);
     assert.is(gen_results.successes.length, 3);
@@ -153,7 +154,7 @@ test__gen('failing gen function', async () => {
         },
     };
     const gen_modules_by_input_path = [mod_a, mod_b];
-    const gen_results = await run_gen(gen_modules_by_input_path, log, new Timings());
+    const gen_results = await run_gen(gen_modules_by_input_path, await load_config(), log, new Timings());
     assert.is(gen_results.input_count, 2);
     assert.is(gen_results.output_count, 1);
     assert.is(gen_results.successes.length, 1);

package/dist/run_task.js

@@ -1,13 +1,13 @@
 import { cyan, red } from 'kleur/colors';
 import { print_log_label, System_Logger } from '@ryanatkn/belt/log.js';
 import { parse_args } from './args.js';
-import { print_task_help } from './print_task.js';
+import { log_task_help } from './task_logging.js';
 import { Task_Error } from './task.js';
 export const run_task = async (task_meta, unparsed_args, invoke_task, config, timings) => {
     const { task } = task_meta.mod;
     const log = new System_Logger(print_log_label(task_meta.name));
     if (unparsed_args.help) {
-        print_task_help(log, task_meta);
+        log_task_help(log, task_meta);
         return { ok: true, output: null };
     }
     // Parse and validate args.

package/dist/sveltekit_config.d.ts

@@ -3,7 +3,7 @@ import type { Config as SveltekitConfig } from '@sveltejs/kit';
 import type { CompileOptions, PreprocessorGroup, ModuleCompileOptions } from 'svelte/compiler';
 /**
  * Loads a SvelteKit config at `dir`.
- * @returns
+ * @returns `null` if no config is found
  */
 export declare const load_sveltekit_config: (dir?: string) => Promise<SveltekitConfig | null>;
 /**

package/dist/sveltekit_config.js

@@ -1,11 +1,15 @@
 import { join } from 'node:path';
-import { cwd } from 'node:process';
-import { SVELTEKIT_CONFIG_FILENAME } from './paths.js';
+import { SVELTEKIT_CONFIG_FILENAME } from './path_constants.js';
+/*
+
+This module is intended to have minimal dependencies to avoid over-imports in the CLI.
+
+*/
 /**
  * Loads a SvelteKit config at `dir`.
- * @returns
+ * @returns `null` if no config is found
  */
-export const load_sveltekit_config = async (dir = cwd()) => {
+export const load_sveltekit_config = async (dir = process.cwd()) => {
     try {
         return (await import(join(dir, SVELTEKIT_CONFIG_FILENAME))).default;
     }
@@ -19,7 +23,7 @@ export const load_sveltekit_config = async (dir = cwd()) => {
  * as a convenience wrapper around `load_sveltekit_config`.
  * Needed because SvelteKit doesn't expose its config resolver.
  */
-export const init_sveltekit_config = async (dir_or_config = cwd()) => {
+export const init_sveltekit_config = async (dir_or_config = process.cwd()) => {
     const sveltekit_config = typeof dir_or_config === 'string' ? await load_sveltekit_config(dir_or_config) : dir_or_config;
     const kit = sveltekit_config?.kit;
     const alias = kit?.alias;

package/dist/sveltekit_config_global.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The parsed SvelteKit config for the cwd, cached globally at the module level.
+ */
+export declare const sveltekit_config_global: import("./sveltekit_config.js").Parsed_Sveltekit_Config;

package/dist/sveltekit_config_global.js

@@ -0,0 +1,5 @@
+import { init_sveltekit_config } from './sveltekit_config.js';
+/**
+ * The parsed SvelteKit config for the cwd, cached globally at the module level.
+ */
+export const sveltekit_config_global = await init_sveltekit_config(); // always load it to keep things simple ahead

package/dist/sveltekit_helpers.d.ts

@@ -0,0 +1,4 @@
+import { Package_Json } from './package_json.js';
+import type { Parsed_Sveltekit_Config } from './sveltekit_config.js';
+export declare const has_sveltekit_app: () => Promise<boolean>;
+export declare const has_sveltekit_library: (package_json?: Package_Json, sveltekit_config?: Parsed_Sveltekit_Config) => Promise<boolean>;

package/dist/sveltekit_helpers.js

@@ -0,0 +1,12 @@
+import { Package_Json, load_package_json } from './package_json.js';
+import { exists } from './fs.js';
+import { sveltekit_config_global } from './sveltekit_config_global.js';
+import { SVELTEKIT_CONFIG_FILENAME } from './path_constants.js';
+export const has_sveltekit_app = () => exists(SVELTEKIT_CONFIG_FILENAME);
+export const has_sveltekit_library = async (package_json, sveltekit_config = sveltekit_config_global) => {
+    if (!(await has_sveltekit_app()) || !(await exists(sveltekit_config.lib_path))) {
+        return false;
+    }
+    const p = package_json ?? (await load_package_json());
+    return !!p.devDependencies?.['@sveltejs/package'] || !!p.dependencies?.['@sveltejs/package'];
+};

package/dist/sync.task.js

@@ -20,7 +20,10 @@ export const task = {
     run: async ({ args, invoke_task, config, log }) => {
         const { sveltekit, package_json, gen, install } = args;
         if (install) {
-            await spawn('npm', ['i']);
+            const result = await spawn('npm', ['i']);
+            if (!result.ok) {
+                throw new Task_Error('failed npm install');
+            }
         }
         if (sveltekit) {
             await sveltekit_sync();

package/dist/task.d.ts

@@ -19,7 +19,7 @@ export interface Task_Context<T_Args = object> {
 export declare const TASK_FILE_SUFFIX_TS = ".task.ts";
 export declare const TASK_FILE_SUFFIX_JS = ".task.js";
 export declare const is_task_path: (path: string) => boolean;
-export declare const to_task_name: (id: Flavored<string, "Source_Id">) => string;
+export declare const to_task_name: (id: Flavored<string, "Source_Id">, task_root_paths: string[]) => string;
 /**
  * This is used by tasks to signal a known failure.
  * It's useful for cleaning up logging because

package/dist/task.js

@@ -1,12 +1,17 @@
-import { strip_end } from '@ryanatkn/belt/string.js';
-import { import_id_to_lib_path } from './paths.js';
+import { strip_end, strip_start } from '@ryanatkn/belt/string.js';
 export const TASK_FILE_SUFFIX_TS = '.task.ts';
 export const TASK_FILE_SUFFIX_JS = '.task.js';
 export const is_task_path = (path) => path.endsWith(TASK_FILE_SUFFIX_TS) || path.endsWith(TASK_FILE_SUFFIX_JS);
-export const to_task_name = (id) => {
-    const lib_path = import_id_to_lib_path(id);
-    const name = strip_end(strip_end(lib_path, TASK_FILE_SUFFIX_TS), TASK_FILE_SUFFIX_JS);
-    return name;
+export const to_task_name = (id, task_root_paths) => {
+    let base_path = id;
+    // If the id is in any of the task root paths, use the first match and strip it.
+    for (const task_root_path of task_root_paths) {
+        if (id.startsWith(task_root_path)) {
+            base_path = strip_start(strip_start(id, task_root_path), '/');
+            break;
+        }
+    }
+    return strip_end(strip_end(base_path, TASK_FILE_SUFFIX_TS), TASK_FILE_SUFFIX_JS);
 };
 /**
  * This is used by tasks to signal a known failure.

package/dist/task.test.js

@@ -1,22 +1,18 @@
-import { suite } from 'uvu';
+import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { is_task_path, to_task_name } from './task.js';
-/* test__is_task_path */
-const test__is_task_path = suite('is_task_path');
-test__is_task_path('basic behavior', () => {
+test('is_task_path basic behavior', () => {
     assert.ok(is_task_path('foo.task.ts'));
     assert.ok(is_task_path('foo.task.js'));
     assert.ok(!is_task_path('foo.ts'));
     assert.ok(is_task_path('bar/baz/foo.task.ts'));
     assert.ok(!is_task_path('bar/baz/foo.ts'));
 });
-test__is_task_path.run();
-/* test__is_task_path */
-/* test__to_task_name */
-const test__to_task_name = suite('to_task_name');
-test__to_task_name('basic behavior', () => {
-    assert.is(to_task_name('foo.task.ts'), 'foo');
-    assert.is(to_task_name('bar/baz/foo.task.ts'), 'bar/baz/foo');
+test('to_task_name basic behavior', () => {
+    assert.is(to_task_name('foo.task.ts', []), 'foo');
+    assert.is(to_task_name('bar/baz/foo.task.ts', []), 'bar/baz/foo');
+    assert.is(to_task_name('a/b/c/foo.task.ts', ['a/b/c', 'a']), 'foo');
+    assert.is(to_task_name('a/b/c/foo.task.ts', ['a']), 'b/c/foo');
+    assert.is(to_task_name('a/b/c/foo.task.ts', ['a/b', 'a']), 'c/foo');
 });
-test__to_task_name.run();
-/* test__to_task_name */
+test.run();

package/dist/task_logging.d.ts

@@ -0,0 +1,8 @@
+import { type Find_Modules_Result } from './modules.js';
+import { type Task_Module_Meta } from './task_module.js';
+import { type Input_Path } from './input_path.js';
+import { type Source_Id } from './paths.js';
+export declare const log_tasks: (log: Logger, dir_label: string, source_ids_by_input_path: Map<Input_Path, Source_Id[]>, task_root_paths: string[], log_intro?: boolean) => Promise<void>;
+export declare const log_gro_package_tasks: (input_path: Flavored<string, "Input_Path">, task_root_paths: string[], log: Logger) => Promise<Find_Modules_Result>;
+export declare const log_error_reasons: (log: Logger, reasons: string[]) => void;
+export declare const log_task_help: (log: Logger, meta: Task_Module_Meta) => void;

package/dist/{print_task.js → task_logging.js}

@@ -2,43 +2,57 @@ import { cyan, gray, green, red } from 'kleur/colors';
 import { plural } from '@ryanatkn/belt/string.js';
 import { print_value } from '@ryanatkn/belt/print.js';
 import { ZodFirstPartyTypeKind } from 'zod';
-import { load_modules } from './modules.js';
+import { find_modules, load_modules } from './modules.js';
 import { load_task_module } from './task_module.js';
-export const log_available_tasks = async (log, dir_label, source_ids_by_input_path, print_intro = true) => {
+import { to_gro_input_path } from './input_path.js';
+import { print_path_or_gro_path } from './paths.js';
+import { is_task_path } from './task.js';
+import { search_fs } from './search_fs.js';
+export const log_tasks = async (log, dir_label, source_ids_by_input_path, task_root_paths, log_intro = true) => {
     const source_ids = Array.from(source_ids_by_input_path.values()).flat();
     if (source_ids.length) {
-        // Load all of the tasks so we can print their summary, and args for the `--help` flag.
-        const load_modules_result = await load_modules(source_ids_by_input_path, load_task_module);
+        // Load all of the tasks so we can log their summary, and args for the `--help` flag.
+        const load_modules_result = await load_modules(source_ids_by_input_path, (id) => load_task_module(id, task_root_paths));
         if (!load_modules_result.ok) {
             log_error_reasons(log, load_modules_result.reasons);
             process.exit(1);
         }
-        const printed = [
-            `${print_intro ? '\n\n' : ''}${source_ids.length} task${plural(source_ids.length)} in ${dir_label}:\n`,
+        const logged = [
+            `${log_intro ? '\n\n' : ''}${source_ids.length} task${plural(source_ids.length)} in ${dir_label}:\n`,
         ];
-        if (print_intro) {
-            printed.unshift(`\n\n${gray('Run a task:')} gro [name]`, `\n${gray('View help:')}  gro [name] --help`);
+        if (log_intro) {
+            logged.unshift(`\n\n${gray('Run a task:')} gro [name]`, `\n${gray('View help:')}  gro [name] --help`);
         }
         const longest_task_name = to_max_length(load_modules_result.modules, (m) => m.name);
         for (const meta of load_modules_result.modules) {
-            printed.push('\n' + cyan(pad(meta.name, longest_task_name)), '  ', meta.mod.task.summary || '');
+            logged.push('\n' + cyan(pad(meta.name, longest_task_name)), '  ', meta.mod.task.summary || '');
         }
-        log[print_intro ? 'info' : 'plain'](printed.join('') + '\n');
+        log[log_intro ? 'info' : 'plain'](logged.join('') + '\n');
     }
     else {
         log.info(`No tasks found in ${dir_label}.`);
     }
 };
+export const log_gro_package_tasks = async (input_path, task_root_paths, log) => {
+    const gro_dir_input_path = to_gro_input_path(input_path);
+    const gro_dir_find_modules_result = await find_modules([gro_dir_input_path], (id) => search_fs(id, { filter: (path) => is_task_path(path) }));
+    if (gro_dir_find_modules_result.ok) {
+        const gro_path_data = gro_dir_find_modules_result.source_id_path_data_by_input_path.get(gro_dir_input_path);
+        // Log the Gro matches.
+        await log_tasks(log, print_path_or_gro_path(gro_path_data.id), gro_dir_find_modules_result.source_ids_by_input_path, task_root_paths);
+    }
+    return gro_dir_find_modules_result;
+};
 export const log_error_reasons = (log, reasons) => {
     for (const reason of reasons) {
         log.error(red(reason));
     }
 };
 const ARGS_PROPERTY_NAME = '[...args]';
-export const print_task_help = (log, meta) => {
+export const log_task_help = (log, meta) => {
     const { name, mod: { task }, } = meta;
-    const printed = [];
-    printed.push(cyan(name), 'help', cyan(`\n\ngro ${name}`) + `: ${task.summary || '(no summary available)'}\n`);
+    const logged = [];
+    logged.push(cyan(name), 'help', cyan(`\n\ngro ${name}`) + `: ${task.summary || '(no summary available)'}\n`);
     if (task.Args) {
         const properties = to_arg_properties(task.Args._def, meta);
         // TODO hacky padding for some quick and dirty tables
@@ -47,13 +61,13 @@ export const print_task_help = (log, meta) => {
         const longest_default = to_max_length(properties, (p) => print_value(p.schema.default));
         for (const property of properties) {
             const name = property.name === '_' ? ARGS_PROPERTY_NAME : property.name;
-            printed.push(`\n${green(pad(name, longest_task_name))} `, gray(pad(property.schema.type, longest_type)) + ' ', pad(print_value(property.schema.default), longest_default) + ' ', property.schema.description || '(no description available)');
+            logged.push(`\n${green(pad(name, longest_task_name))} `, gray(pad(property.schema.type, longest_type)) + ' ', pad(print_value(property.schema.default), longest_default) + ' ', property.schema.description || '(no description available)');
         }
         if (!properties.length) {
-            printed.push('\n' + gray('this task has no args'));
+            logged.push('\n' + gray('this task has no args'));
         }
     }
-    log.info(...printed, '\n');
+    log.info(...logged, '\n');
 };
 const to_arg_properties = (def, meta) => {
     const type_name = to_type_name(def);

package/dist/task_module.d.ts

@@ -1,5 +1,6 @@
 import { load_modules, find_modules, type Module_Meta, type Load_Module_Result, type Find_Modules_Failure } from './modules.js';
 import { type Task } from './task.js';
+import { Input_Path } from './input_path.js';
 export interface Task_Module {
     task: Task;
 }
@@ -7,8 +8,8 @@ export interface Task_Module_Meta extends Module_Meta<Task_Module> {
     name: string;
 }
 export declare const validate_task_module: (mod: Record<string, any>) => mod is Task_Module;
-export declare const load_task_module: (id: string) => Promise<Load_Module_Result<Task_Module_Meta>>;
-export declare const find_task_modules: (input_paths?: string[], extensions?: string[], root_dirs?: string[]) => Promise<ReturnType<typeof find_modules>>;
-export declare const load_task_modules: (input_paths?: string[], extensions?: string[], root_dirs?: string[]) => Promise<ReturnType<typeof load_modules<Task_Module, Task_Module_Meta>> | ({
+export declare const load_task_module: (id: string, task_root_paths: string[]) => Promise<Load_Module_Result<Task_Module_Meta>>;
+export declare const find_task_modules: (input_paths: Input_Path[], task_root_paths: string[]) => Promise<ReturnType<typeof find_modules>>;
+export declare const load_task_modules: (input_paths: Input_Path[], task_root_paths: string[]) => Promise<ReturnType<typeof load_modules<Task_Module, Task_Module_Meta>> | ({
     ok: false;
 } & Find_Modules_Failure)>;

package/dist/task_module.js

@@ -1,19 +1,18 @@
-import { paths } from './paths.js';
 import { load_module, load_modules, find_modules, } from './modules.js';
 import { to_task_name, is_task_path, TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS, } from './task.js';
-import { get_possible_source_ids } from './input_path.js';
+import { Input_Path, get_possible_source_ids } from './input_path.js';
 import { search_fs } from './search_fs.js';
 export const validate_task_module = (mod) => !!mod.task && typeof mod.task.run === 'function';
-export const load_task_module = async (id) => {
+export const load_task_module = async (id, task_root_paths) => {
     const result = await load_module(id, validate_task_module);
     if (!result.ok)
         return result;
-    return { ...result, mod: { ...result.mod, name: to_task_name(id) } };
+    return { ...result, mod: { ...result.mod, name: to_task_name(id, task_root_paths) } }; // TODO this task name needs to use task root paths or cwd
 };
-export const find_task_modules = async (input_paths = [paths.lib], extensions = [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS], root_dirs) => find_modules(input_paths, (id) => search_fs(id, { filter: (path) => is_task_path(path) }), (input_path) => get_possible_source_ids(input_path, extensions, root_dirs));
-export const load_task_modules = async (input_paths, extensions, root_dirs) => {
-    const find_modules_result = await find_task_modules(input_paths, extensions, root_dirs);
+export const find_task_modules = async (input_paths, task_root_paths) => find_modules(input_paths, (id) => search_fs(id, { filter: (path) => is_task_path(path) }), (input_path) => get_possible_source_ids(input_path, [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS], task_root_paths));
+export const load_task_modules = async (input_paths, task_root_paths) => {
+    const find_modules_result = await find_task_modules(input_paths, task_root_paths);
     if (!find_modules_result.ok)
         return find_modules_result;
-    return load_modules(find_modules_result.source_ids_by_input_path, load_task_module);
+    return load_modules(find_modules_result.source_ids_by_input_path, (id) => load_task_module(id, task_root_paths));
 };

package/dist/task_module.test.js

@@ -21,7 +21,7 @@ const test__load_task_module = suite('load_task_module');
 test__load_task_module('basic behavior', async () => {
     const name = 'fixtures/test_task_module.task_fixture.js';
     const id = resolve('src/' + name);
-    const result = await load_task_module(id);
+    const result = await load_task_module(id, []);
     assert.ok(result.ok);
     assert.is(result.mod.id, id);
     assert.is(result.mod.id, id);
@@ -30,7 +30,7 @@ test__load_task_module('basic behavior', async () => {
 });
 test__load_task_module('invalid module', async () => {
     const id = resolve('src/fixtures/test_invalid_task_module.js');
-    const result = await load_task_module(id);
+    const result = await load_task_module(id, []);
     assert.ok(!result.ok);
     if (result.type === 'invalid') {
         assert.is(result.id, id);
@@ -43,7 +43,7 @@ test__load_task_module('invalid module', async () => {
 });
 test__load_task_module('failing module', async () => {
     const id = resolve('src/fixtures/test_failing_task_module.js');
-    const result = await load_task_module(id);
+    const result = await load_task_module(id, []);
     assert.ok(!result.ok);
     if (result.type === 'importFailed') {
         assert.is(result.id, id);
@@ -58,10 +58,7 @@ test__load_task_module.run();
 /* test__load_task_modules */
 const test__load_task_modules = suite('load_task_modules');
 test__load_task_modules('basic behavior', async () => {
-    const result = await load_task_modules([
-        resolve('src/lib/test'),
-        resolve('src/lib/test.task.ts'),
-    ]);
+    const result = await load_task_modules([resolve('src/lib/test'), resolve('src/lib/test.task.ts')], [resolve('src/lib')]);
     assert.ok(result.ok);
     assert.is(result.modules.length, 1);
     assert.is(result.modules[0].mod, actual_test_task_module);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.116.2",
+  "version": "0.118.0",
   "description": "task runner and toolkit extending SvelteKit",
   "motto": "generate, run, optimize",
   "icon": "🌰",
@@ -51,11 +51,11 @@
     "es-module-lexer": "^1.5.3",
     "kleur": "^4.1.5",
     "mri": "^1.2.0",
-    "prettier": "^3.2.5",
-    "prettier-plugin-svelte": "^3.2.3",
+    "prettier": "^3.3.2",
+    "prettier-plugin-svelte": "^3.2.4",
     "tiny-glob": "^0.2.9",
     "ts-morph": "^22.0.0",
-    "tslib": "^2.6.2",
+    "tslib": "^2.6.3",
     "zod": "^3.23.8"
   },
   "peerDependencies": {
@@ -66,21 +66,21 @@
     "@changesets/changelog-git": "^0.2.0",
     "@changesets/types": "^6.0.0",
     "@ryanatkn/eslint-config": "^0.1.2",
-    "@ryanatkn/fuz": "^0.101.4",
-    "@ryanatkn/moss": "^0.3.0",
-    "@sveltejs/adapter-static": "^3.0.1",
-    "@sveltejs/kit": "^2.5.10",
-    "@sveltejs/package": "^2.3.1",
-    "@sveltejs/vite-plugin-svelte": "^3.1.0",
+    "@ryanatkn/fuz": "^0.102.1",
+    "@ryanatkn/moss": "^0.4.0",
+    "@sveltejs/adapter-static": "^3.0.2",
+    "@sveltejs/kit": "^2.5.15",
+    "@sveltejs/package": "^2.3.2",
+    "@sveltejs/vite-plugin-svelte": "^3.1.1",
     "@types/fs-extra": "^11.0.4",
-    "@types/node": "^20.12.12",
-    "@typescript-eslint/eslint-plugin": "^7.10.0",
-    "@typescript-eslint/parser": "^7.10.0",
+    "@types/node": "^20.14.2",
+    "@typescript-eslint/eslint-plugin": "^7.13.0",
+    "@typescript-eslint/parser": "^7.13.0",
     "esbuild": "^0.20.2",
     "eslint": "^8.57.0",
-    "eslint-plugin-svelte": "^2.39.0",
-    "svelte": "^5.0.0-next.153",
-    "svelte-check": "^3.7.1",
+    "eslint-plugin-svelte": "^2.39.3",
+    "svelte": "^5.0.0-next.155",
+    "svelte-check": "^3.8.0",
     "typescript": "^5.4.5",
     "uvu": "^0.5.6"
   },
@@ -306,6 +306,10 @@
       "default": "./dist/package.js",
       "types": "./dist/package.d.ts"
     },
+    "./path_constants.js": {
+      "default": "./dist/path_constants.js",
+      "types": "./dist/path_constants.d.ts"
+    },
     "./path.js": {
       "default": "./dist/path.js",
       "types": "./dist/path.d.ts"
@@ -318,14 +322,14 @@
       "default": "./dist/plugin.js",
       "types": "./dist/plugin.d.ts"
     },
-    "./print_task.js": {
-      "default": "./dist/print_task.js",
-      "types": "./dist/print_task.d.ts"
-    },
     "./publish.task.js": {
       "default": "./dist/publish.task.js",
       "types": "./dist/publish.task.d.ts"
     },
+    "./register.js": {
+      "default": "./dist/register.js",
+      "types": "./dist/register.d.ts"
+    },
     "./release.task.js": {
       "default": "./dist/release.task.js",
       "types": "./dist/release.task.d.ts"
@@ -362,10 +366,18 @@
       "default": "./dist/svelte_helpers.js",
       "types": "./dist/svelte_helpers.d.ts"
     },
+    "./sveltekit_config_global.js": {
+      "default": "./dist/sveltekit_config_global.js",
+      "types": "./dist/sveltekit_config_global.d.ts"
+    },
     "./sveltekit_config.js": {
       "default": "./dist/sveltekit_config.js",
       "types": "./dist/sveltekit_config.d.ts"
     },
+    "./sveltekit_helpers.js": {
+      "default": "./dist/sveltekit_helpers.js",
+      "types": "./dist/sveltekit_helpers.d.ts"
+    },
     "./sveltekit_shim_app_environment.js": {
       "default": "./dist/sveltekit_shim_app_environment.js",
       "types": "./dist/sveltekit_shim_app_environment.d.ts"
@@ -398,6 +410,10 @@
       "default": "./dist/sync.task.js",
       "types": "./dist/sync.task.d.ts"
     },
+    "./task_logging.js": {
+      "default": "./dist/task_logging.js",
+      "types": "./dist/task_logging.d.ts"
+    },
     "./task_module.js": {
       "default": "./dist/task_module.js",
       "types": "./dist/task_module.d.ts"

package/dist/print_task.d.ts

@@ -1,4 +0,0 @@
-import { type Task_Module_Meta } from './task_module.js';
-export declare const log_available_tasks: (log: Logger, dir_label: string, source_ids_by_input_path: Map<string, string[]>, print_intro?: boolean) => Promise<void>;
-export declare const log_error_reasons: (log: Logger, reasons: string[]) => void;
-export declare const print_task_help: (log: Logger, meta: Task_Module_Meta) => void;