@ryanatkn/gro 0.117.0 → 0.118.0

package/README.md

@@ -35,8 +35,7 @@ It includes:
     [`@sveltejs/package`](https://kit.svelte.dev/docs/packaging) for the library
   - exposes all of its internals in `$lib`
   - uses [Changesets](https://github.com/changesets/changesets) for versioning and changelogs
-  - provides a [Node loader](/src/lib/loader.ts) and
-    [esbuild plugins for the server](/src/lib/gro_plugin_server.ts)
+  - provides a [Node loader](/src/lib/loader.ts) with a [register hook](/src/lib/register.ts)
     - supports importing TypeScript, JSON, and SSR'd Svelte files in tests and tasks
     - supports [SvelteKit module imports](https://kit.svelte.dev/docs/modules) for
       `$lib`, `$env`, and `$app` in tasks, tests, Node servers,
@@ -44,8 +43,10 @@ It includes:
       so you can use SvelteKit patterns everywhere
       (these are best-effort shims, not perfect)
     - supports running TypeScript files directly without a task via `gro run a.ts`
-  - [configurable plugins](/src/lib/docs/plugin.md)
-    to support SvelteKit, auto-restarting Node servers, and other external build processes
+      or `node --import @ryanatkn/gro/register.js a.ts`
+  - [configurable plugins](/src/lib/docs/plugin.md) to support SvelteKit,
+    [auto-restarting Node servers](/src/lib/gro_plugin_server.ts),
+    and other external build processes
     - see the [Gro config docs](/src/lib/docs/config.md) and
       [the default config](https://github.com/ryanatkn/gro/blob/main/src/lib/gro.config.default.ts)
     - see [`fuz_template`](https://github.com/fuz-dev/fuz_template)
@@ -126,17 +127,34 @@ typecheck  run tsc on the project without emitting any files
 upgrade    upgrade deps
 ```
 
-Gro matches your CLI input against its filesystem conventions.
+To run tasks, Gro matches your CLI input against its filesystem conventions.
 It tries to do the right thing, where right is helpful but not surprising,
 with some magic but not too much:
 
 ```bash
-gro # print all available tasks, those matching `src/lib/**/*.task.ts` and Gro's builtins
-gro some/dir # list all tasks inside `src/lib/some/dir`
-gro some/file # run `src/lib/some/file.task.ts`
+gro # displays all available tasks matching `src/lib/**/*.task.ts` and Gro's builtins
+gro a # tries to run `src/lib/a.task.ts`, then `./a.task.ts`, then Gro's builtin if one exists
+gro a --help # displays docs for the "a" task and its args, works for every task
+gro some/dir # lists all tasks inside `src/lib/some/dir`
+gro some/file # runs `src/lib/some/file.task.ts`
 gro some/file.task.ts # same as above
-gro a # run `src/lib/a.task.ts` if it exists, falling back to Gro's builtin
-gro a --help # print info about the "a" task; works for every task
+```
+
+Gro can also run non-task TypeScript files directly
+with [the `gro run` task](/src/lib/run.task.ts) or [register hook](/src/lib/register.ts):
+
+```bash
+gro run foo.ts
+node --import @ryanatkn/gro/register.js foo.ts
+```
+
+Or programmatically:
+
+```js
+// myfile.js
+import {register} from 'node:module';
+register('@ryanatkn/gro/loader.js', import.meta.url);
+await import('./foo.ts');
 ```
 
 Gro has a number of builtin tasks that you can run with the CLI.
@@ -200,19 +218,17 @@ To publish: (also see [`src/lib/docs/publish.md`](/src/lib/docs/publish.md))
 gro publish # flush changeset to changelog, bump version, publish to npm, and git push
 ```
 
-Etc:
+More:
 
 ```bash
 gro clean # delete all build artifacts from the filesystem
 gro clean --sveltekit --nodemodules --git # also deletes dirs and prunes git branches
 gro upgrade excluded-dep-1 excluded-dep-2 # npm updates to the latest everything
-```
-
-```bash
 gro --version # print the Gro version
 ```
 
-For more see [`src/lib/docs/task.md`](/src/lib/docs/task.md) and [`src/lib/docs`](/src/lib/docs).
+For more see [the tasks index](/src/lib/docs/tasks.md),
+[the task feature docs](/src/lib/docs/task.md), and [the docs index](/src/lib/docs/README.md).
 
 ## develop
 

package/dist/changeset.task.js

@@ -9,7 +9,7 @@ import { exists } from './fs.js';
 import { load_package_json } from './package_json.js';
 import { find_cli, spawn_cli } from './cli.js';
 import { Git_Origin, git_push_to_create } from './git.js';
-import { has_sveltekit_library } from './gro_plugin_sveltekit_library.js';
+import { has_sveltekit_library } from './sveltekit_helpers.js';
 const RESTRICTED_ACCESS = 'restricted';
 const PUBLIC_ACCESS = 'public';
 const CHANGESET_DIR = '.changeset';

package/dist/clean_fs.js

@@ -1,5 +1,6 @@
 import { rm, readdir } from 'node:fs/promises';
-import { NODE_MODULES_DIRNAME, paths, SVELTEKIT_DEV_DIRNAME, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_VITE_CACHE_PATH, GRO_DIST_PREFIX, SVELTEKIT_DIST_DIRNAME, } from './paths.js';
+import { paths } from './paths.js';
+import { NODE_MODULES_DIRNAME, GRO_DIST_PREFIX, SVELTEKIT_DEV_DIRNAME, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_VITE_CACHE_PATH, SVELTEKIT_DIST_DIRNAME, } from './path_constants.js';
 export const clean_fs = async ({ build = false, build_dev = false, build_dist = false, sveltekit = false, nodemodules = false, }, rm_options = { force: true, recursive: true }) => {
     const promises = [];
     if (build) {

package/dist/cli.js

@@ -1,7 +1,7 @@
 import { spawn, spawn_out } from '@ryanatkn/belt/process.js';
 import { join } from 'node:path';
 import { exists } from './fs.js';
-import { NODE_MODULES_DIRNAME } from './paths.js';
+import { NODE_MODULES_DIRNAME } from './path_constants.js';
 /**
  * Looks for the CLI `name`, first local to the cwd and then globally.
  */

package/dist/config.js

@@ -1,5 +1,6 @@
 import { join, resolve } from 'node:path';
-import { CONFIG_PATH, GRO_DIST_DIR, IS_THIS_GRO, paths } from './paths.js';
+import { GRO_DIST_DIR, IS_THIS_GRO, paths } from './paths.js';
+import { GRO_CONFIG_PATH } from './path_constants.js';
 import create_default_config from './gro.config.default.js';
 import { exists } from './fs.js';
 export const create_empty_config = () => ({
@@ -17,7 +18,7 @@ const default_map_package_json = async (package_json) => {
 export const DEFAULT_EXPORTS_EXCLUDER = /(\.md|\.(test|ignore)\.|\/(test|fixtures|ignore)\/)/u;
 export const load_config = async (dir = paths.root) => {
     const default_config = await create_default_config(create_empty_config());
-    const config_path = join(dir, CONFIG_PATH);
+    const config_path = join(dir, GRO_CONFIG_PATH);
     let config;
     if (await exists(config_path)) {
         const config_module = await import(config_path);

package/dist/deploy.task.js

@@ -5,7 +5,8 @@ import { z } from 'zod';
 import { cp, mkdir, readdir, rm } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { Task_Error } from './task.js';
-import { GIT_DIRNAME, GRO_DIRNAME, print_path, SVELTEKIT_BUILD_DIRNAME } from './paths.js';
+import { print_path } from './paths.js';
+import { GRO_DIRNAME, GIT_DIRNAME, SVELTEKIT_BUILD_DIRNAME } from './path_constants.js';
 import { empty_dir, exists } from './fs.js';
 import { git_check_clean_workspace, git_checkout, git_local_branch_exists, git_remote_branch_exists, Git_Origin, Git_Branch, git_delete_local_branch, git_push_to_create, git_reset_branch_to_first_commit, git_pull, git_fetch, git_check_setting_pull_rebase, git_clone_locally, git_current_branch_name, } from './git.js';
 // docs at ./docs/deploy.md
@@ -13,7 +14,7 @@ import { git_check_clean_workspace, git_checkout, git_local_branch_exists, git_r
 // terminal command for testing:
 // npm run build && rm -rf .gro && clear && gro deploy --source no-git-workspace --no-build --dry
 // TODO customize
-const cwd = process.cwd();
+const dir = process.cwd();
 const INITIAL_FILE_PATH = '.gitkeep';
 const INITIAL_FILE_CONTENTS = '';
 const DEPLOY_DIR = GRO_DIRNAME + '/deploy';
@@ -121,7 +122,7 @@ export const task = {
             if (!(await exists(resolved_deploy_dir))) {
                 const local_deploy_branch_exists = await git_local_branch_exists(target);
                 await git_fetch(origin, ('+' + target + ':' + target)); // fetch+merge and allow non-fastforward updates with the +
-                await git_clone_locally(origin, target, cwd, resolved_deploy_dir);
+                await git_clone_locally(origin, target, dir, resolved_deploy_dir);
                 // Clean up if we created the target branch in the cwd
                 if (!local_deploy_branch_exists) {
                     await git_delete_local_branch(target);
@@ -145,7 +146,7 @@ export const task = {
             }
             // Create the target branch locally and remotely.
             // This is more complex to avoid churning the cwd.
-            await git_clone_locally(origin, source, cwd, resolved_deploy_dir);
+            await git_clone_locally(origin, source, dir, resolved_deploy_dir);
             await spawn(`git checkout --orphan ${target} && ` +
                 // TODO there's definitely a better way to do this
                 `git rm -rf . && ` +

package/dist/docs/gen.md

@@ -91,6 +91,22 @@ Outputs `src/script.ts`:
 console.log('generated a string');
 ```
 
+### gen context
+
+The `Gen` function receives one argument, the `Gen_Context` object:
+
+```ts
+export interface Gen_Context {
+	config: Gro_Config;
+	/**
+	 * Same as `import.meta.url` but in path form.
+	 */
+	origin_id: string;
+	log: Logger;
+}
+// export const gen: Gen = ({config, origin_id, log}) => {
+```
+
 ### generate other filetypes
 
 Files with any extension can be generated without configuration.

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

@@ -14,14 +14,13 @@ import { log_error_reasons } from '../task_logging.js';
 // TODO display more info about each task, including a summary and params
 // 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([paths.lib]);
+export const gen = async ({ config, origin_id, log }) => {
+    const result = await load_task_modules([paths.lib], config.task_root_paths);
     if (!result.ok) {
         log_error_reasons(log, result.reasons);
         throw new Error(result.type);
     }
     const tasks = result.modules;
-    // TODO need to get this from project config or something
     const root_path = parse_path_segments(paths.root).at(-1);
     const origin_dir = dirname(origin_id);
     const origin_base = basename(origin_id);

package/dist/esbuild_plugin_external_worker.js

@@ -1,6 +1,5 @@
 import * as esbuild from 'esbuild';
 import { basename } from 'node:path';
-import { cwd } from 'node:process';
 import { print_build_result, to_define_import_meta_env } from './esbuild_helpers.js';
 import { resolve_specifier } from './resolve_specifier.js';
 import { esbuild_plugin_sveltekit_shim_alias } from './esbuild_plugin_sveltekit_shim_alias.js';
@@ -8,7 +7,7 @@ import { esbuild_plugin_sveltekit_shim_env } from './esbuild_plugin_sveltekit_sh
 import { esbuild_plugin_sveltekit_shim_app } from './esbuild_plugin_sveltekit_shim_app.js';
 import { esbuild_plugin_sveltekit_local_imports } from './esbuild_plugin_sveltekit_local_imports.js';
 import { esbuild_plugin_svelte } from './esbuild_plugin_svelte.js';
-export const esbuild_plugin_external_worker = ({ dev, build_options, dir = cwd(), svelte_compile_options, svelte_preprocessors, svelte_compile_module_options, alias, base_url, assets_url, public_prefix, private_prefix, env_dir, env_files, ambient_env, log, }) => ({
+export const esbuild_plugin_external_worker = ({ dev, build_options, dir = process.cwd(), svelte_compile_options, svelte_preprocessors, svelte_compile_module_options, alias, base_url, assets_url, public_prefix, private_prefix, env_dir, env_files, ambient_env, log, }) => ({
     name: 'external_worker',
     setup: (build) => {
         const builds = new Map();

package/dist/esbuild_plugin_svelte.js

@@ -1,10 +1,9 @@
 import { compile, compileModule, preprocess, } from 'svelte/compiler';
 import { readFile } from 'node:fs/promises';
 import { relative } from 'node:path';
-import { cwd } from 'node:process';
 import { SVELTE_MATCHER, SVELTE_RUNES_MATCHER } from './svelte_helpers.js';
 export const esbuild_plugin_svelte = (options = {}) => {
-    const { dir = cwd(), svelte_compile_options = {}, svelte_compile_module_options = {}, svelte_preprocessors, } = options;
+    const { dir = process.cwd(), svelte_compile_options = {}, svelte_compile_module_options = {}, svelte_preprocessors, } = options;
     return {
         name: 'svelte',
         setup: (build) => {

package/dist/esbuild_plugin_sveltekit_shim_alias.js

@@ -1,7 +1,6 @@
 import { escape_regexp } from '@ryanatkn/belt/regexp.js';
-import { cwd } from 'node:process';
 import { join } from 'node:path';
-export const esbuild_plugin_sveltekit_shim_alias = ({ dir = cwd(), alias, }) => ({
+export const esbuild_plugin_sveltekit_shim_alias = ({ dir = process.cwd(), alias, }) => ({
     name: 'sveltekit_shim_alias',
     setup: (build) => {
         const aliases = { $lib: 'src/lib', ...alias };

package/dist/format_directory.js

@@ -1,10 +1,11 @@
 import { spawn } from '@ryanatkn/belt/process.js';
-import { GITHUB_DIRNAME, paths, README_FILENAME, SVELTEKIT_CONFIG_FILENAME, VITE_CONFIG_FILENAME, TSCONFIG_FILENAME, CONFIG_PATH, } from './paths.js';
+import { paths } from './paths.js';
+import { GITHUB_DIRNAME, README_FILENAME, SVELTEKIT_CONFIG_FILENAME, VITE_CONFIG_FILENAME, TSCONFIG_FILENAME, GRO_CONFIG_PATH, } from './path_constants.js';
 import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
 const DEFAULT_EXTENSIONS = 'ts,js,json,svelte,html,css,md,yml';
 const DEFAULT_ROOT_PATHS = `${[
     README_FILENAME,
-    CONFIG_PATH,
+    GRO_CONFIG_PATH,
     SVELTEKIT_CONFIG_FILENAME,
     VITE_CONFIG_FILENAME,
     TSCONFIG_FILENAME,

package/dist/gen.d.ts

@@ -1,5 +1,6 @@
 import type { Logger } from '@ryanatkn/belt/log.js';
 import { z } from 'zod';
+import type { Gro_Config } from './config.js';
 export type Gen_Result = {
     origin_id: string;
     files: Gen_File[];
@@ -14,6 +15,10 @@ export interface Gen {
     (ctx: Gen_Context): Raw_Gen_Result | Promise<Raw_Gen_Result>;
 }
 export interface Gen_Context {
+    config: Gro_Config;
+    /**
+     * Same as `import.meta.url` but in path form.
+     */
     origin_id: string;
     log: Logger;
 }

package/dist/gen.task.js

@@ -25,7 +25,7 @@ export const Args = z
 export const task = {
     summary: 'run code generation scripts',
     Args,
-    run: async ({ args, log, timings }) => {
+    run: async ({ args, log, timings, config }) => {
         const { _: raw_input_paths, check } = args;
         const input_paths = raw_input_paths.length ? to_input_paths(raw_input_paths) : [paths.source];
         // load all of the gen modules
@@ -48,7 +48,7 @@ export const task = {
         }
         // run `gen` on each of the modules
         const timing_to_generate_code = timings.start('generate code'); // TODO this ignores `gen_results.elapsed` - should it return `Timings` instead?
-        const gen_results = await run_gen(load_modules_result.modules, log, timings, format_file);
+        const gen_results = await run_gen(load_modules_result.modules, config, log, timings, format_file);
         timing_to_generate_code();
         const fail_count = gen_results.failures.length;
         if (check) {

package/dist/gro.config.default.js

@@ -1,6 +1,7 @@
-import { has_sveltekit_library, gro_plugin_sveltekit_library, } from './gro_plugin_sveltekit_library.js';
+import { gro_plugin_sveltekit_library } from './gro_plugin_sveltekit_library.js';
 import { has_server, gro_plugin_server } from './gro_plugin_server.js';
-import { has_sveltekit_app, gro_plugin_sveltekit_app } from './gro_plugin_sveltekit_app.js';
+import { gro_plugin_sveltekit_app } from './gro_plugin_sveltekit_app.js';
+import { has_sveltekit_app, has_sveltekit_library } from './sveltekit_helpers.js';
 /**
  * This is the default config that's passed to `gro.config.ts`
  * if it exists in the current project, and if not, this is the final config.

package/dist/gro_helpers.js

@@ -3,7 +3,12 @@ import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from '@ryanatkn/belt/process.js';
 import { exists } from './fs.js';
-import { NODE_MODULES_DIRNAME } from './paths.js';
+import { NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME } from './path_constants.js';
+/*
+
+This module is intended to have minimal dependencies to avoid over-imports in the CLI.
+
+*/
 /**
  * Resolves a path to an internal Gro file.
  * Prefers any local installation of Gro and falls back to the current CLI context.
@@ -40,26 +45,22 @@ import { NODE_MODULES_DIRNAME } from './paths.js';
  */
 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)) {
-        // case 1
-        // Prefer any locally installed version of Gro.
         return join(await realpath(gro_bin_path), '..', path);
     }
-    else {
-        // 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.
-        const file_path = fileURLToPath(import.meta.url);
-        const base_path = 'dist';
-        if ((await exists(join(base_path, 'gro.js'))) && (await exists(join(base_path, path)))) {
-            return join(file_path, '../..', base_path, path);
-        }
-        else {
-            // case 3
-            // Fall back to the version associated with the running CLI.
-            return join(file_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)))) {
+        return resolve(SVELTEKIT_DIST_DIRNAME, path);
     }
+    // case 3
+    // Fall back to the version associated with the running CLI.
+    const file_path = fileURLToPath(import.meta.url);
+    return join(file_path, '..', path);
 };
 /**
  * Runs a file using the Gro loader.

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

@@ -26,7 +26,7 @@ export declare const to_input_paths: (raw_input_paths: Raw_Input_Path[], root_pa
  * 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: Flavored<string, "Input_Path">, extensions: string[], root_dirs?: string[]) => Source_Id[];
+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, checking the filesystem for the possibilities
  * and stopping at the first existing file or falling back to the first existing directory.

package/dist/input_path.js

@@ -59,7 +59,7 @@ export const get_possible_source_ids = (input_path, extensions, root_dirs) => {
     if (isAbsolute(input_path)) {
         add_possible_source_ids(input_path);
     }
-    else if (root_dirs?.length) {
+    else {
         for (const root_dir of root_dirs) {
             add_possible_source_ids(join(root_dir, input_path));
         }

package/dist/input_path.test.js

@@ -22,14 +22,14 @@ test('to_input_paths', () => {
 });
 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',
     ]);
 });
 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', () => {
     const input_path = resolve('src/foo/bar.baz.ts');
@@ -39,7 +39,7 @@ test('get_possible_source_ids does not repeat with the same root directory', ()
 });
 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('load_source_ids_by_input_path', async () => {
     const test_files = {

package/dist/invoke_task.js

@@ -39,14 +39,15 @@ export const invoke_task = async (task_name, args, config, timings = new Timings
     if (!task_name && (args.version || args.v)) {
         const gro_package_json = await load_gro_package_json();
         log.info(`${gray('v')}${cyan(gro_package_json.version)}`);
-        log.info(`🕒 ${print_ms(total_timing())}`);
+        finish();
         return;
     }
     // Resolve the input path for the provided task name.
     const input_path = to_input_path(task_name);
+    const { task_root_paths } = config;
     // Find the task or directory specified by the `input_path`.
     // Fall back to searching the Gro directory as well.
-    const find_modules_result = await find_task_modules([input_path], config.task_root_paths);
+    const find_modules_result = await find_task_modules([input_path], task_root_paths);
     if (!find_modules_result.ok) {
         if (find_modules_result.type === 'input_directories_with_no_files') {
             // The input path matched a directory, but it contains no matching files.
@@ -60,8 +61,7 @@ export const invoke_task = async (task_name, args, config, timings = new Timings
             else {
                 // If there's a matching directory in the current working directory,
                 // but it has no matching files, we still want to search Gro's directory.
-                const gro_dir_find_modules_result = await log_gro_package_tasks(input_path, log);
-                // TODO this doesn't seem to be working as commented, test this condition in another repo (maybe like "gro sync" when there's a "src/lib/sync" folder)
+                const gro_dir_find_modules_result = await log_gro_package_tasks(input_path, task_root_paths, log);
                 if (!gro_dir_find_modules_result.ok) {
                     // Log the original errors, not the Gro-specific ones.
                     log_error_reasons(log, find_modules_result.reasons);
@@ -83,7 +83,7 @@ export const invoke_task = async (task_name, args, config, timings = new Timings
     if (!path_data.isDirectory) {
         // The input path matches a file, so load and run it.
         // Try to load the task module.
-        const load_modules_result = await load_modules(find_modules_result.source_ids_by_input_path, load_task_module);
+        const load_modules_result = await load_modules(find_modules_result.source_ids_by_input_path, (id) => load_task_module(id, task_root_paths));
         if (load_modules_result.ok) {
             // We found a task module. Run it!
             // `path_data` is not a directory, so there's a single task module here.
@@ -110,21 +110,20 @@ export const invoke_task = async (task_name, args, config, timings = new Timings
         // The input path matches a directory. Log the tasks but don't run them.
         if (IS_THIS_GRO) {
             // Is the Gro directory the same as the cwd? Log the matching files.
-            await log_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path);
+            await log_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path, task_root_paths);
         }
         else if (is_gro_id(path_data.id)) {
-            // TODO delete this? merge behavior with the block above/below?
             // Does the Gro directory contain the matching files? Log them.
-            await log_tasks(log, print_path_or_gro_path(path_data.id), find_modules_result.source_ids_by_input_path);
+            await log_tasks(log, print_path_or_gro_path(path_data.id), find_modules_result.source_ids_by_input_path, task_root_paths);
         }
         else {
             // The Gro directory is not the same as the cwd and it doesn't contain the matching files.
             // Find all of the possible matches in both the current project and the Gro directory,
             // and log everything out.
             // Ignore any errors - the directory may not exist or have any files!
-            const gro_dir_find_modules_result = await log_gro_package_tasks(input_path, log);
+            const gro_dir_find_modules_result = await log_gro_package_tasks(input_path, task_root_paths, log);
             // Then log the current working directory matches.
-            await log_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path, !gro_dir_find_modules_result.ok);
+            await log_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path, task_root_paths, !gro_dir_find_modules_result.ok);
         }
     }
     finish();

package/dist/lint.task.js

@@ -2,7 +2,7 @@ import { print_spawn_result } from '@ryanatkn/belt/process.js';
 import { z } from 'zod';
 import { Task_Error } from './task.js';
 import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
-import { SOURCE_DIRNAME } from './paths.js';
+import { SOURCE_DIRNAME } from './path_constants.js';
 import { find_cli, spawn_cli } from './cli.js';
 export const Args = z
     .object({

package/dist/loader.js

@@ -5,21 +5,28 @@ import { dirname, join } from 'node:path';
 import { escape_regexp } from '@ryanatkn/belt/regexp.js';
 import { render_env_shim_module } from './sveltekit_shim_env.js';
 import { render_sveltekit_shim_app_environment, render_sveltekit_shim_app_paths, sveltekit_shim_app_environment_matcher, sveltekit_shim_app_paths_matcher, sveltekit_shim_app_specifiers, } from './sveltekit_shim_app.js';
-import { init_sveltekit_config } from './sveltekit_config.js';
+import { sveltekit_config_global } from './sveltekit_config_global.js';
 import { SVELTE_MATCHER, SVELTE_RUNES_MATCHER } from './svelte_helpers.js';
-import { paths, NODE_MODULES_DIRNAME } from './paths.js';
+import { paths } from './paths.js';
+import { NODE_MODULES_DIRNAME } from './path_constants.js';
 import { to_define_import_meta_env, ts_transform_options } from './esbuild_helpers.js';
 import { resolve_specifier } from './resolve_specifier.js';
 import { resolve_node_specifier } from './resolve_node_specifier.js';
 /*
 
+Usage via `$lib/register.ts`:
+
+```bash
+node --import @ryanatkn/gro/register.js foo.ts
+```
+
 Usage via `$lib/run.task.ts`:
 
 ```bash
 gro run foo.ts
 ```
 
-Direct usage (see also `$lib/gro.ts`):
+Direct usage without register (see also `$lib/gro.ts`):
 
 ```bash
 node --import 'data:text/javascript,import {register} from "node:module"; import {pathToFileURL} from "node:url"; register("@ryanatkn/gro/loader.js", pathToFileURL("./"));' --enable-source-maps' foo.ts
@@ -34,7 +41,7 @@ TODO how to improve that gnarly import line? was originally designed for the now
 // dev is always true in the loader
 const dev = true;
 const dir = paths.root;
-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(dir); // always load it to keep things simple ahead
+const { alias, base_url, assets_url, env_dir, private_prefix, public_prefix, svelte_compile_options, svelte_compile_module_options, svelte_preprocessors, } = sveltekit_config_global;
 const final_ts_transform_options = {
     ...ts_transform_options,
     define: to_define_import_meta_env(dev, base_url),