@ryanatkn/gro 0.119.1 → 0.120.0

package/dist/paths.js

@@ -1,8 +1,7 @@
 import { join, extname, relative, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { strip_end, strip_start } from '@ryanatkn/belt/string.js';
+import { strip_end } from '@ryanatkn/belt/string.js';
 import { gray } from 'kleur/colors';
-import { z } from 'zod';
 import { GRO_CONFIG_PATH, GRO_DEV_DIR, GRO_DIR, SOURCE_DIR, SVELTEKIT_DIST_DIRNAME, } from './path_constants.js';
 import { sveltekit_config_global } from './sveltekit_config_global.js';
 /*
@@ -15,9 +14,6 @@ export const LIB_DIRNAME = basename(sveltekit_config_global.lib_path);
 export const LIB_PATH = SOURCE_DIR + LIB_DIRNAME;
 export const LIB_DIR = LIB_PATH + '/';
 export const ROUTES_DIRNAME = basename(sveltekit_config_global.routes_path);
-// TODO probably rename to `Path_Id` from `Source_Id`?
-// TODO Flavored doesn't work when used in schemas, use Zod brand instead? problem is ergonomics
-export const Source_Id = z.string();
 export const create_paths = (root_dir) => {
     // TODO remove reliance on trailing slash towards windows support
     const root = strip_end(root_dir, '/') + '/';
@@ -30,39 +26,20 @@ export const create_paths = (root_dir) => {
         config: root + GRO_CONFIG_PATH,
     };
 };
-export const paths_from_id = (id) => (is_gro_id(id) ? gro_paths : paths);
-export const is_gro_id = (id) => id.startsWith(gro_paths.root);
-// TODO maybe infer `p` for the functions that take in ids using `paths_from_id`?
+export const infer_paths = (id) => (is_gro_id(id) ? gro_paths : paths);
+export const is_gro_id = (id) => id.startsWith(strip_end(gro_paths.root, '/')); // strip `/` in case we're looking at the Gro root without a trailing slash
 // '/home/me/app/src/foo/bar/baz.ts' → 'src/foo/bar/baz.ts'
-export const to_root_path = (id, p = paths) => strip_start(id, p.root);
+export const to_root_path = (id, p = infer_paths(id)) => relative(p.root, id) || './';
 // '/home/me/app/src/foo/bar/baz.ts' → 'foo/bar/baz.ts'
-export const source_id_to_base_path = (source_id, p = paths) => relative(p.source, source_id);
+export const path_id_to_base_path = (path_id, p = infer_paths(path_id)) => relative(p.source, path_id);
 // TODO base_path is an obsolete concept, it was a remnant from forcing `src/`
 // 'foo/bar/baz.ts' → '/home/me/app/src/foo/bar/baz.ts'
-export const base_path_to_source_id = (base_path, p = paths) => join(p.source, base_path);
-// An `import_id` can be a source_id in a project,
-// or a Gro source_id when running inside Gro,
-// or a `gro/dist/` file id in node_modules when inside another project.
-export const import_id_to_lib_path = (import_id, p = paths_from_id(import_id)) => {
-    if (p.root === gro_paths.root) {
-        const stripped = strip_start(strip_start(import_id, p.lib), GRO_DIST_DIR); // TODO hacky, needs more work to clarify related things
-        const lib_path = IS_THIS_GRO ? stripped : replace_extension(stripped, '.ts');
-        return lib_path;
-    }
-    else {
-        return strip_start(import_id, p.lib);
-    }
-};
-export const print_path = (path, p = paths, prefix = './') => {
-    const root_path = path === GRO_DIST_DIR ? 'gro' : to_root_path(path, p);
-    return gray(`${prefix}${root_path}`);
-};
-export const print_path_or_gro_path = (path, from_paths = paths) => {
-    const inferred_paths = paths_from_id(path);
-    if (from_paths === gro_paths || inferred_paths === from_paths) {
-        return print_path(path, inferred_paths, '');
-    }
-    return print_path(path, gro_paths, '');
+export const base_path_to_path_id = (base_path, p = infer_paths(base_path)) => join(p.source, base_path);
+export const print_path = (path, p = infer_paths(path)) => {
+    let final_path = strip_end(path, '/') === strip_end(GRO_DIST_DIR, '/') ? 'gro' : to_root_path(path, p);
+    final_path =
+        final_path === 'gro' ? final_path : final_path[0] === '.' ? final_path : './' + final_path;
+    return gray(final_path);
 };
 export const replace_extension = (path, new_extension) => {
     const { length } = extname(path);

package/dist/paths.test.js

@@ -1,7 +1,7 @@
 import { suite } from 'uvu';
 import * as assert from 'uvu/assert';
 import { resolve, join } from 'node:path';
-import { create_paths, paths, gro_paths, is_gro_id, to_root_path, source_id_to_base_path, base_path_to_source_id, } from './paths.js';
+import { create_paths, paths, gro_paths, is_gro_id, to_root_path, path_id_to_base_path, base_path_to_path_id, } from './paths.js';
 /* test__create_paths */
 const test__create_paths = suite('create_paths');
 test__create_paths('basic behavior', () => {
@@ -27,23 +27,25 @@ test__is_gro_id.run();
 const test__to_root_path = suite('to_root_path');
 test__to_root_path('basic behavior', () => {
     assert.is(to_root_path(resolve('foo/bar')), 'foo/bar');
+    assert.is(to_root_path(resolve('./')), './');
+    assert.is(to_root_path(resolve('./')), './');
 });
 test__to_root_path.run();
 /* test__to_root_path */
-/* test__source_id_to_base_path */
-const test__source_id_to_base_path = suite('source_id_to_base_path');
-test__source_id_to_base_path('basic behavior', () => {
-    assert.is(source_id_to_base_path(resolve('src/foo/bar/baz.ts')), 'foo/bar/baz.ts');
+/* test__path_id_to_base_path */
+const test__path_id_to_base_path = suite('path_id_to_base_path');
+test__path_id_to_base_path('basic behavior', () => {
+    assert.is(path_id_to_base_path(resolve('src/foo/bar/baz.ts')), 'foo/bar/baz.ts');
 });
-test__source_id_to_base_path.run();
-/* test__source_id_to_base_path */
-/* test__base_path_to_source_id */
-const test__base_path_to_source_id = suite('base_path_to_source_id');
-test__base_path_to_source_id('basic behavior', () => {
-    assert.is(base_path_to_source_id('foo/bar/baz.ts'), resolve('src/foo/bar/baz.ts'));
+test__path_id_to_base_path.run();
+/* test__path_id_to_base_path */
+/* test__base_path_to_path_id */
+const test__base_path_to_path_id = suite('base_path_to_path_id');
+test__base_path_to_path_id('basic behavior', () => {
+    assert.is(base_path_to_path_id('foo/bar/baz.ts'), resolve('src/foo/bar/baz.ts'));
 });
-test__base_path_to_source_id('does not change extension', () => {
-    assert.is(base_path_to_source_id('foo/bar/baz.js'), resolve('src/foo/bar/baz.js'));
+test__base_path_to_path_id('does not change extension', () => {
+    assert.is(base_path_to_path_id('foo/bar/baz.js'), resolve('src/foo/bar/baz.js'));
 });
-test__base_path_to_source_id.run();
-/* test__base_path_to_source_id */
+test__base_path_to_path_id.run();
+/* test__base_path_to_path_id */

package/dist/plugin.d.ts

@@ -33,4 +33,4 @@ export declare class Plugins<T_Plugin_Context extends Plugin_Context> {
  * @param name - @default new_plugin.name
  * @returns `plugins` with `new_plugin` at the index of the plugin with `name`
  */
-export declare const replace_plugin: <T_Plugins extends T_Plugin | (T_Plugin | null)[] | null, T_Plugin extends Plugin<Plugin_Context<object>>>(plugins: T_Plugins, new_plugin: Plugin, name?: string) => T_Plugin[];
+export declare const replace_plugin: <T_Plugins extends T_Plugin | null | Array<T_Plugin | null>, T_Plugin extends Plugin>(plugins: T_Plugins, new_plugin: Plugin, name?: string) => T_Plugin[];

package/dist/publish.task.js

@@ -1,10 +1,10 @@
 import { spawn } from '@ryanatkn/belt/process.js';
 import { z } from 'zod';
 import { green, cyan } from 'kleur/colors';
+import { existsSync } from 'node:fs';
 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_GRO } from './paths.js';
 import { has_sveltekit_library } from './sveltekit_helpers.js';
 import { update_changelog } from './changelog.js';
@@ -58,7 +58,7 @@ export const task = {
         if (IS_THIS_GRO) {
             await spawn('npm', ['run', 'build']);
         }
-        const changelog_exists = await exists(changelog);
+        const changelog_exists = existsSync(changelog);
         if (!(await find_cli('changeset'))) {
             throw new Task_Error('changeset command not found, install @changesets/cli locally or globally');
         }
@@ -132,7 +132,7 @@ export const task = {
         if (!npm_publish_result?.ok) {
             throw new Task_Error('changeset publish failed - revert the version tag or run it again manually');
         }
-        if (!changelog_exists && (await exists(changelog))) {
+        if (!changelog_exists && existsSync(changelog)) {
             await spawn('git', ['add', changelog]);
         }
         await spawn('git', ['commit', '-a', '-m', `publish v${version}`]);

package/dist/resolve.task.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { type Task } from './task.js';
+export declare const Args: z.ZodObject<{
+    _: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    _: string[];
+}, {
+    _?: string[] | undefined;
+}>;
+export type Args = z.infer<typeof Args>;
+export declare const task: Task<Args>;

package/dist/resolve.task.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { TASK_FILE_SUFFIXES } from './task.js';
+import { resolve_input_paths, to_input_paths } from './input_path.js';
+export const Args = z
+    .object({
+    _: z.array(z.string(), { description: 'the input paths to resolve' }).default(['']),
+})
+    .strict();
+export const task = {
+    summary: 'diagnostic that logs the info resolved from the filesystem for the given input paths',
+    Args,
+    run: async ({ args, config, log }) => {
+        const { _ } = args;
+        log.info('raw input paths:', _);
+        const input_paths = to_input_paths(_);
+        log.info('input paths:', input_paths);
+        const { task_root_dirs } = config;
+        log.info('task root paths:', task_root_dirs);
+        const { resolved_input_paths, possible_paths_by_input_path, unmapped_input_paths } = await resolve_input_paths(input_paths, task_root_dirs, TASK_FILE_SUFFIXES);
+        log.info('resolved_input_paths:', resolved_input_paths);
+        log.info('possible_paths_by_input_path:', possible_paths_by_input_path);
+        log.info('unmapped_input_paths:', unmapped_input_paths);
+    },
+};

package/dist/resolve_node_specifier.d.ts

@@ -1,6 +1,6 @@
 import { Package_Json } from './package_json.js';
-import { Source_Id } from './paths.js';
-export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_url?: string, cache?: Record<string, Package_Json>, exports_key?: string) => Promise<Source_Id>;
+import type { Path_Id } from './path.js';
+export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_url?: string, cache?: Record<string, Package_Json>, exports_key?: string) => Promise<Path_Id>;
 export interface Parsed_Node_Specifier {
     name: string;
     path: string;

package/dist/resolve_node_specifier.js

@@ -1,6 +1,6 @@
 import { join } from 'node:path';
 import { Package_Json, load_package_json } from './package_json.js';
-import { Source_Id, paths } from './paths.js';
+import { 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);
@@ -13,8 +13,8 @@ export const resolve_node_specifier = async (specifier, dir = paths.root, parent
         throw Error(`[ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath '${subpath}' is not defined by "exports" in ${package_dir}/package.json` +
             (parent_url ? ` imported from ${parent_url}` : ''));
     }
-    const source_id = join(package_dir, exported[exports_key]);
-    return source_id;
+    const path_id = join(package_dir, exported[exports_key]);
+    return path_id;
 };
 export const parse_node_specifier = (specifier) => {
     let idx;

package/dist/resolve_specifier.d.ts

@@ -1,6 +1,7 @@
+import type { Path_Id } from './path.js';
 export interface Resolved_Specifier {
     specifier: string;
-    source_id: string;
+    path_id: Path_Id;
     namespace: undefined | 'sveltekit_local_imports_ts' | 'sveltekit_local_imports_js';
 }
 /**

package/dist/resolve_specifier.js

@@ -1,6 +1,6 @@
-import { extname, join, relative } from 'node:path';
+import { extname, isAbsolute, join, relative } from 'node:path';
+import { existsSync } from 'node:fs';
 import { replace_extension } from './paths.js';
-import { exists } from './fs.js';
 /**
  * Maps a `path` import specifier relative to the `importer`,
  * and infer the correct extension following Vite conventions.
@@ -11,41 +11,41 @@ import { exists } from './fs.js';
  * @returns
  */
 export const resolve_specifier = async (path, dir) => {
-    const path_id = path[0] === '/' ? path : join(dir, path);
+    const absolute_path = isAbsolute(path) ? path : join(dir, path);
     let mapped_path;
-    let source_id;
+    let path_id;
     let namespace;
-    const ext = extname(path_id);
+    const ext = extname(absolute_path);
     const is_js = ext === '.js';
     const is_ts = ext === '.ts';
-    if (!is_js && !is_ts && (await exists(path_id))) {
+    if (!is_js && !is_ts && existsSync(absolute_path)) {
         // unrecognized extension and the file exists
-        mapped_path = path_id;
-        source_id = path_id;
+        mapped_path = absolute_path;
+        path_id = absolute_path;
     }
     else if (is_ts) {
         // explicitly ts
-        mapped_path = replace_extension(path_id, '.js');
-        source_id = path_id;
+        mapped_path = replace_extension(absolute_path, '.js');
+        path_id = absolute_path;
         namespace = 'sveltekit_local_imports_ts';
     }
     else {
         // extensionless, or js that points to ts, or just js
-        const js_id = is_js ? path_id : path_id + '.js';
-        const ts_id = is_js ? replace_extension(path_id, '.ts') : path_id + '.ts';
-        if (!(await exists(ts_id)) && (await exists(js_id))) {
+        const js_id = is_js ? absolute_path : absolute_path + '.js';
+        const ts_id = is_js ? replace_extension(absolute_path, '.ts') : absolute_path + '.ts';
+        if (!existsSync(ts_id) && existsSync(js_id)) {
             mapped_path = js_id;
-            source_id = js_id;
+            path_id = js_id;
             namespace = 'sveltekit_local_imports_js';
         }
         else {
             mapped_path = js_id;
-            source_id = ts_id;
+            path_id = ts_id;
             namespace = 'sveltekit_local_imports_ts';
         }
     }
     let specifier = relative(dir, mapped_path);
     if (specifier[0] !== '.')
         specifier = './' + specifier;
-    return { specifier, source_id, namespace };
+    return { specifier, path_id, namespace };
 };

package/dist/resolve_specifier.test.js

@@ -7,59 +7,59 @@ const dir = paths.source + 'fixtures/';
 test('resolves a specifier to a file that exists with an unknown file extension', async () => {
     assert.equal(await resolve_specifier(join(dir, 'test_file.other.ext'), dir), {
         specifier: './test_file.other.ext',
-        source_id: join(dir, 'test_file.other.ext'),
+        path_id: join(dir, 'test_file.other.ext'),
         namespace: undefined,
     });
 });
 test('resolves a ts specifier', async () => {
     assert.equal(await resolve_specifier(join(dir, 'test_ts.ts'), dir), {
         specifier: './test_ts.js',
-        source_id: join(dir, 'test_ts.ts'),
+        path_id: join(dir, 'test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
 test('resolves relative ts specifiers', async () => {
     assert.equal(await resolve_specifier('./test_ts.ts', dir), {
         specifier: './test_ts.js',
-        source_id: join(dir, 'test_ts.ts'),
+        path_id: join(dir, 'test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
     assert.equal(await resolve_specifier('./a/b/test_ts.ts', dir), {
         specifier: './a/b/test_ts.js',
-        source_id: join(dir, 'a/b/test_ts.ts'),
+        path_id: join(dir, 'a/b/test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
     assert.equal(await resolve_specifier('../../test_ts.ts', dir), {
         specifier: '../../test_ts.js',
-        source_id: join(dir, '../../test_ts.ts'),
+        path_id: join(dir, '../../test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
 test('resolves an extensionless specifier', async () => {
     assert.equal(await resolve_specifier(join(dir, 'test_ts'), dir), {
         specifier: './test_ts.js',
-        source_id: join(dir, 'test_ts.ts'),
+        path_id: join(dir, 'test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
 test('resolves a js specifier', async () => {
     assert.equal(await resolve_specifier(join(dir, 'test_js.js'), dir), {
         specifier: './test_js.js',
-        source_id: join(dir, 'test_js.js'),
+        path_id: join(dir, 'test_js.js'),
         namespace: 'sveltekit_local_imports_js',
     });
 });
 test('resolves a js specifier as ts for a file that does not exist', async () => {
     assert.equal(await resolve_specifier(join(dir, 'test_missing.js'), dir), {
         specifier: './test_missing.js',
-        source_id: join(dir, 'test_missing.ts'),
+        path_id: join(dir, 'test_missing.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
 test('resolves an extensionless specifier for a file that does not exist', async () => {
     assert.equal(await resolve_specifier(join(dir, 'test_missing'), dir), {
         specifier: './test_missing.js',
-        source_id: join(dir, 'test_missing.ts'),
+        path_id: join(dir, 'test_missing.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });

package/dist/run.task.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { green, cyan } from 'kleur/colors';
+import { existsSync } from 'node:fs';
 import { Task_Error } from './task.js';
-import { exists } from './fs.js';
 import { resolve_gro_module_path, spawn_with_loader } from './gro_helpers.js';
 export const Args = z
     .object({
@@ -19,7 +19,7 @@ export const task = {
             log.info(green('\n\nUsage: ') + cyan('gro run path/to/file.ts [...node_args]\n'));
             return;
         }
-        if (!(await exists(path))) {
+        if (!existsSync(path)) {
             throw new Task_Error('Cannot find file to run at path: ' + path);
         }
         const loader_path = await resolve_gro_module_path('loader.js');

package/dist/run_gen.d.ts

@@ -1,7 +1,7 @@
-import { type Gen_Module_Meta } from './gen_module.js';
-import { type Gen_Results } from './gen.js';
+import type { Timings } from '@ryanatkn/belt/timings.js';
+import type { Logger } from '@ryanatkn/belt/log.js';
+import { type Gen_Results, type Genfile_Module_Meta } 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[], 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;
+export declare const run_gen: (gen_modules: Genfile_Module_Meta[], config: Gro_Config, log: Logger, timings: Timings, format_file?: typeof base_format_file) => Promise<Gen_Results>;

package/dist/run_gen.js

@@ -1,10 +1,8 @@
 import { red } from 'kleur/colors';
 import { print_error } from '@ryanatkn/belt/print.js';
-import { Unreachable_Error } from '@ryanatkn/belt/error.js';
-import { strip_end } from '@ryanatkn/belt/string.js';
-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';
+import { print_path } from './paths.js';
+import { sveltekit_config_global } from './sveltekit_config_global.js';
 export const GEN_NO_PROD_MESSAGE = 'gen runs only during development';
 export const run_gen = async (gen_modules, config, log, timings, format_file) => {
     let input_count = 0;
@@ -15,18 +13,15 @@ export const run_gen = async (gen_modules, config, 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, config, log };
+        const gen_ctx = {
+            config,
+            sveltekit_config: sveltekit_config_global,
+            origin_id: id,
+            log,
+        };
         let raw_gen_result;
         try {
-            switch (module_meta.type) {
-                case 'basic': {
-                    raw_gen_result = await module_meta.mod.gen(gen_ctx);
-                    break;
-                }
-                default: {
-                    throw new Unreachable_Error(module_meta.type);
-                }
-            }
+            raw_gen_result = await module_meta.mod.gen(gen_ctx);
         }
         catch (err) {
             return {
@@ -70,5 +65,3 @@ export const run_gen = async (gen_modules, config, log, timings, format_file) =>
         elapsed: timing_for_run_gen(),
     };
 };
-// TODO configurable
-export const to_gen_import_path = (id) => '$' + strip_end(source_id_to_base_path(id), GEN_SCHEMA_PATH_SUFFIX);

package/dist/run_gen.test.js

@@ -9,18 +9,17 @@ const log = new Logger('test__gen'); // TODO test logger?
 /* test__gen */
 const test__gen = suite('gen');
 test__gen('basic behavior', async () => {
-    const source_id_a = resolve('src/foo.gen.ts');
-    const source_id_bc = resolve('src/bar/bc');
+    const path_id_a = resolve('src/foo.gen.ts');
+    const path_id_bc = resolve('src/bar/bc');
     let file_a;
     let file_b;
     let file_c1;
     let file_c2;
     const mod_a = {
-        type: 'basic',
-        id: source_id_a,
+        id: path_id_a,
         mod: {
             gen: async (ctx) => {
-                assert.is(ctx.origin_id, source_id_a);
+                assert.is(ctx.origin_id, path_id_a);
                 if (file_a)
                     throw Error('Already generated file_a');
                 file_a = {
@@ -32,8 +31,7 @@ test__gen('basic behavior', async () => {
         },
     };
     const mod_b = {
-        type: 'basic',
-        id: join(source_id_bc, 'mod_b.gen.ts'),
+        id: join(path_id_bc, 'mod_b.gen.ts'),
         mod: {
             gen: async (ctx) => {
                 assert.is(ctx.origin_id, mod_b.id);
@@ -48,8 +46,7 @@ test__gen('basic behavior', async () => {
         },
     };
     const mod_c = {
-        type: 'basic',
-        id: join(source_id_bc, 'mod_c.gen.ts'),
+        id: join(path_id_bc, 'mod_c.gen.ts'),
         mod: {
             gen: async (ctx) => {
                 assert.is(ctx.origin_id, mod_c.id);
@@ -121,15 +118,14 @@ test__gen('basic behavior', async () => {
     ]);
 });
 test__gen('failing gen function', async () => {
-    const source_id_a = resolve('src/foo.gen.ts');
-    const source_idB = resolve('src/bar/baz');
+    const path_id_a = resolve('src/foo.gen.ts');
+    const path_idB = resolve('src/bar/baz');
     let file_b; // no file_a because it's never generated
     let genError; // this error should be passed through to the result
     // This is the failing gen module.
     // It's ordered first to test that its failure doesn't cascade.
     const mod_a = {
-        type: 'basic',
-        id: source_id_a,
+        id: path_id_a,
         mod: {
             gen: async () => {
                 genError = Error('This fails for testing');
@@ -138,8 +134,7 @@ test__gen('failing gen function', async () => {
         },
     };
     const mod_b = {
-        type: 'basic',
-        id: join(source_idB, 'mod_b.gen.ts'),
+        id: join(path_idB, 'mod_b.gen.ts'),
         mod: {
             gen: async (ctx) => {
                 assert.is(ctx.origin_id, mod_b.id);

package/dist/run_task.d.ts

@@ -1,7 +1,8 @@
-import type { Task_Module_Meta } from './task_module.js';
+import type { Timings } from '@ryanatkn/belt/timings.js';
 import { type Args } from './args.js';
 import type { invoke_task as base_invoke_task } from './invoke_task.js';
 import type { Gro_Config } from './config.js';
+import { type Task_Module_Meta } from './task.js';
 export type Run_Task_Result = {
     ok: true;
     output: unknown;

package/dist/run_task.js

@@ -3,6 +3,7 @@ import { print_log_label, System_Logger } from '@ryanatkn/belt/log.js';
 import { parse_args } from './args.js';
 import { log_task_help } from './task_logging.js';
 import { Task_Error } from './task.js';
+import { sveltekit_config_global } from './sveltekit_config_global.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));
@@ -26,6 +27,7 @@ export const run_task = async (task_meta, unparsed_args, invoke_task, config, ti
         output = await task.run({
             args,
             config,
+            sveltekit_config: sveltekit_config_global,
             log,
             timings,
             invoke_task: (invoked_task_name, invoked_args, invoked_config) => invoke_task(invoked_task_name, invoked_args, invoked_config || config, timings),

package/dist/search_fs.d.ts

@@ -1,11 +1,24 @@
-import { compare_simple_map_entries } from '@ryanatkn/belt/map.js';
-import type { Path_Stats, Path_Filter } from './path.js';
+import type { File_Filter, Resolved_Path, Path_Filter } from './path.js';
 export interface Search_Fs_Options {
-    filter?: Path_Filter;
     /**
-     * Pass `null` to speed things up at the risk of volatile ordering.
+     * One or more filter functions, any of which can short-circuit the search by returning `false`.
      */
-    sort?: typeof compare_simple_map_entries | null;
-    files_only?: boolean;
+    filter?: Path_Filter | Path_Filter[] | null;
+    /**
+     * An array of file suffixes to include.
+     */
+    file_filter?: File_Filter | File_Filter[];
+    /**
+     * Pass `null` or `false` to speed things up at the cost of volatile ordering.
+     */
+    sort?: boolean | null | ((a: Resolved_Path, b: Resolved_Path) => number);
+    /**
+     * Set to `false` to include directories.
+     */
+    include_directories?: boolean;
+    /**
+     * Sets the cwd for `dir` unless it's an absolute path or `null`.
+     */
+    cwd?: string | null;
 }
-export declare const search_fs: (dir: string, options?: Search_Fs_Options) => Promise<Map<string, Path_Stats>>;
+export declare const search_fs: (dir: string, options?: Search_Fs_Options) => Promise<Resolved_Path[]>;