@ryanatkn/gro 0.119.1 → 0.120.1

package/dist/fs.js

@@ -1,19 +1,9 @@
-import { access, constants, readdir, rm } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
+import { readdirSync } from 'node:fs';
 import { join } from 'node:path';
-export const exists = async (path) => {
-    try {
-        await access(path, constants.F_OK);
-        return true;
-    }
-    catch (err) {
-        if (err.code === 'ENOENT')
-            return false;
-        throw err;
-    }
-};
 /**
  * Empties a directory with an optional `filter`.
  */
 export const empty_dir = async (dir, filter, options) => {
-    await Promise.all((await readdir(dir)).map((path) => filter && !filter(path) ? null : rm(join(dir, path), { ...options, recursive: true })));
+    await Promise.all(readdirSync(dir).map((path) => filter && !filter(path) ? null : rm(join(dir, path), { ...options, recursive: true })));
 };

package/dist/fs.test.js

@@ -1,16 +1,16 @@
 import { test } from 'uvu';
 import * as assert from 'uvu/assert';
-import { exists } from './fs.js';
+import { existsSync } from 'node:fs';
 test('file exists', async () => {
-    assert.ok(await exists('./src/lib/fs.ts'));
+    assert.ok(existsSync('./src/lib/fs.ts'));
 });
 test('file does not exist', async () => {
-    assert.ok(!(await exists('./src/lib/existsssss.ts')));
+    assert.ok(!existsSync('./src/lib/existsssss.ts'));
 });
 test('directory exists', async () => {
-    assert.ok(await exists('./src/lib'));
+    assert.ok(existsSync('./src/lib'));
 });
 test('directory does not exist', async () => {
-    assert.ok(!(await exists('./src/libbbbbbbb')));
+    assert.ok(!existsSync('./src/libbbbbbbb'));
 });
 test.run();

package/dist/gen.d.ts

@@ -1,14 +1,22 @@
 import type { Logger } from '@ryanatkn/belt/log.js';
 import { z } from 'zod';
+import type { Result } from '@ryanatkn/belt/result.js';
+import type { Path_Id } from './path.js';
 import type { Gro_Config } from './config.js';
+import type { Parsed_Sveltekit_Config } from './sveltekit_config.js';
+import { type Load_Modules_Failure, type Module_Meta } from './modules.js';
+import { Input_Path, type Resolved_Input_File, type Resolved_Input_Path } from './input_path.js';
+export declare const GEN_FILE_PATTERN_TEXT = "gen";
+export declare const GEN_FILE_PATTERN: string;
+export declare const is_gen_path: (path: string) => boolean;
 export type Gen_Result = {
-    origin_id: string;
+    origin_id: Path_Id;
     files: Gen_File[];
 };
 export interface Gen_File {
-    id: string;
+    id: Path_Id;
     content: string;
-    origin_id: string;
+    origin_id: Path_Id;
     format: boolean;
 }
 export interface Gen {
@@ -16,10 +24,11 @@ export interface Gen {
 }
 export interface Gen_Context {
     config: Gro_Config;
+    sveltekit_config: Parsed_Sveltekit_Config;
     /**
      * Same as `import.meta.url` but in path form.
      */
-    origin_id: string;
+    origin_id: Path_Id;
     log: Logger;
 }
 export type Raw_Gen_Result = string | Raw_Gen_File | null | Raw_Gen_Result[];
@@ -37,28 +46,28 @@ export declare const Gen_Config: z.ZodObject<{
 }>;
 export type Gen_Config = z.infer<typeof Gen_Config>;
 export type Gen_Results = {
-    results: Gen_Module_Result[];
-    successes: Gen_Module_Result_Success[];
-    failures: Gen_Module_Result_Failure[];
+    results: Genfile_Module_Result[];
+    successes: Genfile_Module_Result_Success[];
+    failures: Genfile_Module_Result_Failure[];
     input_count: number;
     output_count: number;
     elapsed: number;
 };
-export type Gen_Module_Result = Gen_Module_Result_Success | Gen_Module_Result_Failure;
-export type Gen_Module_Result_Success = {
+export type Genfile_Module_Result = Genfile_Module_Result_Success | Genfile_Module_Result_Failure;
+export type Genfile_Module_Result_Success = {
     ok: true;
-    id: string;
+    id: Path_Id;
     files: Gen_File[];
     elapsed: number;
 };
-export type Gen_Module_Result_Failure = {
+export type Genfile_Module_Result_Failure = {
     ok: false;
-    id: string;
+    id: Path_Id;
     reason: string;
     error: Error;
     elapsed: number;
 };
-export declare const to_gen_result: (origin_id: Flavored<string, "Source_Id">, raw_result: Raw_Gen_Result) => Gen_Result;
+export declare const to_gen_result: (origin_id: Path_Id, raw_result: Raw_Gen_Result) => Gen_Result;
 export declare const to_output_file_name: (filename: string) => string;
 export type Analyzed_Gen_Result = {
     file: Gen_File;
@@ -74,3 +83,47 @@ export type Analyzed_Gen_Result = {
 export declare const analyze_gen_results: (gen_results: Gen_Results) => Promise<Analyzed_Gen_Result[]>;
 export declare const analyze_gen_result: (file: Gen_File) => Promise<Analyzed_Gen_Result>;
 export declare const write_gen_results: (gen_results: Gen_Results, analyzed_gen_results: Analyzed_Gen_Result[], log: Logger) => Promise<void>;
+export interface Found_Genfiles {
+    resolved_input_files: Resolved_Input_File[];
+    resolved_input_files_by_input_path: Map<Input_Path, Resolved_Input_File[]>;
+    resolved_input_files_by_root_dir: Map<Path_Id, Resolved_Input_File[]>;
+    resolved_input_paths: Resolved_Input_Path[];
+    resolved_input_paths_by_input_path: Map<Input_Path, Resolved_Input_Path[]>;
+}
+export type Find_Genfiles_Result = Result<{
+    value: Found_Genfiles;
+}, Find_Genfiles_Failure>;
+export type Find_Genfiles_Failure = {
+    type: 'unmapped_input_paths';
+    unmapped_input_paths: Input_Path[];
+    resolved_input_paths: Resolved_Input_Path[];
+    resolved_input_paths_by_input_path: Map<Input_Path, Resolved_Input_Path[]>;
+    reasons: string[];
+} | {
+    type: 'input_directories_with_no_files';
+    input_directories_with_no_files: Resolved_Input_Path[];
+    resolved_input_files: Resolved_Input_File[];
+    resolved_input_files_by_input_path: Map<Input_Path, Resolved_Input_File[]>;
+    resolved_input_files_by_root_dir: Map<Path_Id, Resolved_Input_File[]>;
+    resolved_input_paths: Resolved_Input_Path[];
+    resolved_input_paths_by_input_path: Map<Input_Path, Resolved_Input_Path[]>;
+    reasons: string[];
+};
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export declare const find_genfiles: (input_paths: Input_Path[], root_dirs: Path_Id[], config: Gro_Config, timings?: any) => Promise<Find_Genfiles_Result>;
+export interface Genfile_Module {
+    gen: Gen;
+}
+export type Genfile_Module_Meta = Module_Meta<Genfile_Module>;
+export interface Loaded_Genfiles {
+    modules: Genfile_Module_Meta[];
+    found_genfiles: Found_Genfiles;
+}
+export type Load_Genfiles_Result = Result<{
+    value: Loaded_Genfiles;
+}, Load_Genfiles_Failure>;
+export type Load_Genfiles_Failure = Load_Modules_Failure<Genfile_Module_Meta>;
+export declare const load_genfiles: (found_genfiles: Found_Genfiles, timings?: any) => Promise<Load_Genfiles_Result>;
+export declare const validate_gen_module: (mod: Record<string, any>) => mod is Genfile_Module;

package/dist/gen.js

@@ -1,9 +1,15 @@
 import { join, basename, dirname, isAbsolute } from 'node:path';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { z } from 'zod';
-import { gen_module_meta, to_gen_module_type } from './gen_module.js';
+import { red } from 'kleur/colors';
+import { existsSync } from 'node:fs';
 import { print_path } from './paths.js';
-import { exists } from './fs.js';
+import { load_modules } from './modules.js';
+import { Input_Path, resolve_input_files, resolve_input_paths, } from './input_path.js';
+import { search_fs } from './search_fs.js';
+export const GEN_FILE_PATTERN_TEXT = 'gen';
+export const GEN_FILE_PATTERN = '.' + GEN_FILE_PATTERN_TEXT + '.';
+export const is_gen_path = (path) => path.includes(GEN_FILE_PATTERN);
 export const Gen_Config = z.object({
     imports: z.record(z.string(), z.string()).default({}),
 });
@@ -47,19 +53,18 @@ const to_output_file_id = (origin_id, raw_file_name) => {
     return output_file_id;
 };
 export const to_output_file_name = (filename) => {
-    const { pattern, text } = gen_module_meta[to_gen_module_type(filename)];
     const parts = filename.split('.');
-    const gen_pattern_index = parts.indexOf(text);
+    const gen_pattern_index = parts.indexOf(GEN_FILE_PATTERN_TEXT);
     if (gen_pattern_index === -1) {
-        throw Error(`Invalid gen file name - '${text}' not found in '${filename}'`);
+        throw Error(`Invalid gen file name - '${GEN_FILE_PATTERN_TEXT}' not found in '${filename}'`);
     }
-    if (gen_pattern_index !== parts.lastIndexOf(text)) {
-        throw Error(`Invalid gen file name - multiple instances of '${text}' found in '${filename}'`);
+    if (gen_pattern_index !== parts.lastIndexOf(GEN_FILE_PATTERN_TEXT)) {
+        throw Error(`Invalid gen file name - multiple instances of '${GEN_FILE_PATTERN_TEXT}' found in '${filename}'`);
     }
     if (gen_pattern_index < parts.length - 3) {
         // This check is technically unneccessary,
         // but ensures a consistent file naming convention.
-        throw Error(`Invalid gen file name - only one additional extension is allowed to follow '${pattern}' in '${filename}'`);
+        throw Error(`Invalid gen file name - only one additional extension is allowed to follow '${GEN_FILE_PATTERN}' in '${filename}'`);
     }
     const final_parts = [];
     const has_different_ext = gen_pattern_index === parts.length - 3;
@@ -86,7 +91,7 @@ export const analyze_gen_results = (gen_results) => Promise.all(gen_results.succ
     .map((result) => result.files.map((file) => analyze_gen_result(file)))
     .flat());
 export const analyze_gen_result = async (file) => {
-    if (!(await exists(file.id))) {
+    if (!existsSync(file.id)) {
         return {
             file,
             existing_content: null,
@@ -124,3 +129,67 @@ export const write_gen_results = async (gen_results, analyzed_gen_results, log)
     }))
         .flat());
 };
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export const find_genfiles = async (input_paths, root_dirs, config, timings) => {
+    const extensions = [GEN_FILE_PATTERN];
+    // Check which extension variation works - if it's a directory, prefer others first!
+    const timing_to_resolve_input_paths = timings?.start('resolve input paths');
+    const { resolved_input_paths, resolved_input_paths_by_input_path, unmapped_input_paths } = await resolve_input_paths(input_paths, root_dirs, extensions);
+    timing_to_resolve_input_paths?.();
+    // Error if any input path could not be mapped.
+    if (unmapped_input_paths.length) {
+        return {
+            ok: false,
+            type: 'unmapped_input_paths',
+            unmapped_input_paths,
+            resolved_input_paths,
+            resolved_input_paths_by_input_path,
+            reasons: unmapped_input_paths.map((input_path) => red(`Input path ${print_path(input_path)} cannot be mapped to a file or directory.`)),
+        };
+    }
+    // Find all of the files for any directories.
+    const timing_to_search_fs = timings?.start('find files');
+    const { resolved_input_files, resolved_input_files_by_input_path, resolved_input_files_by_root_dir, input_directories_with_no_files, } = await resolve_input_files(resolved_input_paths, (id, options) => search_fs(id, {
+        ...options,
+        filter: config.search_filters,
+        file_filter: (p) => extensions.some((e) => p.includes(e)),
+    }));
+    timing_to_search_fs?.();
+    // Error if any input path has no files. (means we have an empty directory)
+    if (input_directories_with_no_files.length) {
+        return {
+            ok: false,
+            type: 'input_directories_with_no_files',
+            input_directories_with_no_files,
+            resolved_input_files,
+            resolved_input_files_by_input_path,
+            resolved_input_files_by_root_dir,
+            resolved_input_paths,
+            resolved_input_paths_by_input_path,
+            reasons: input_directories_with_no_files.map(({ input_path }) => red(`Input directory contains no matching files: ${print_path(input_path)}`)),
+        };
+    }
+    return {
+        ok: true,
+        value: {
+            resolved_input_files,
+            resolved_input_files_by_input_path,
+            resolved_input_files_by_root_dir,
+            resolved_input_paths,
+            resolved_input_paths_by_input_path,
+        },
+    };
+};
+export const load_genfiles = async (found_genfiles, timings) => {
+    const loaded_modules = await load_modules(found_genfiles.resolved_input_files, validate_gen_module, (resolved_input_file, mod) => ({ id: resolved_input_file.id, mod }), timings);
+    if (!loaded_modules.ok) {
+        return loaded_modules;
+    }
+    return {
+        ok: true,
+        value: { modules: loaded_modules.modules, found_genfiles },
+    };
+};
+export const validate_gen_module = (mod) => typeof mod?.gen === 'function';

package/dist/gen.task.d.ts

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

package/dist/gen.task.js

@@ -4,16 +4,18 @@ import { plural } from '@ryanatkn/belt/string.js';
 import { z } from 'zod';
 import { Task_Error } from './task.js';
 import { run_gen } from './run_gen.js';
-import { load_gen_module, find_gen_modules } from './gen_module.js';
 import { Raw_Input_Path, to_input_paths } from './input_path.js';
-import { load_modules } from './modules.js';
 import { format_file } from './format_file.js';
-import { paths, print_path } from './paths.js';
+import { print_path } from './paths.js';
 import { log_error_reasons } from './task_logging.js';
-import { write_gen_results, analyze_gen_results } from './gen.js';
+import { write_gen_results, analyze_gen_results, find_genfiles, load_genfiles } from './gen.js';
+import { SOURCE_DIRNAME } from './path_constants.js';
 export const Args = z
     .object({
-    _: z.array(Raw_Input_Path, { description: 'paths to generate' }).default([]),
+    _: z.array(Raw_Input_Path, { description: 'input paths to generate' }).default([SOURCE_DIRNAME]),
+    root_dirs: z
+        .array(z.string(), { description: 'root directories to resolve input paths against' }) // TODO `Path_Id` schema
+        .default([process.cwd()]),
     check: z
         .boolean({ description: 'exit with a nonzero code if any files need to be generated' })
         .default(false),
@@ -25,29 +27,32 @@ export const task = {
     summary: 'run code generation scripts',
     Args,
     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];
+        const { _: raw_input_paths, root_dirs, check } = args;
+        const input_paths = to_input_paths(raw_input_paths);
         // load all of the gen modules
-        const find_modules_result = await find_gen_modules(input_paths);
-        if (!find_modules_result.ok) {
-            if (find_modules_result.type === 'input_directories_with_no_files') {
-                log.info('no gen modules found');
+        const found = await find_genfiles(input_paths, root_dirs, config, timings);
+        if (!found.ok) {
+            if (found.type === 'input_directories_with_no_files') {
+                // TODO maybe let this error like the normal case, but only call `gro gen` if we find gen files? problem is the args would need to be hoisted to callers like `gro sync`
+                log.info('no gen modules found in ' + input_paths.join(', '));
                 return;
             }
             else {
-                log_error_reasons(log, find_modules_result.reasons);
+                log_error_reasons(log, found.reasons);
                 throw new Task_Error('Failed to find gen modules.');
             }
         }
-        log.info('gen files', Array.from(find_modules_result.source_ids_by_input_path.values()).flat());
-        const load_modules_result = await load_modules(find_modules_result.source_ids_by_input_path, load_gen_module);
-        if (!load_modules_result.ok) {
-            log_error_reasons(log, load_modules_result.reasons);
+        const found_genfiles = found.value;
+        log.info('gen files', found_genfiles.resolved_input_files.map((f) => f.id));
+        const loaded = await load_genfiles(found_genfiles, timings);
+        if (!loaded.ok) {
+            log_error_reasons(log, loaded.reasons);
             throw new Task_Error('Failed to load gen modules.');
         }
+        const loaded_genfiles = loaded.value;
         // 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, config, log, timings, format_file);
+        const gen_results = await run_gen(loaded_genfiles.modules, config, log, timings, format_file);
         timing_to_generate_code();
         const fail_count = gen_results.failures.length;
         const analyzed_gen_results = await analyze_gen_results(gen_results);
@@ -82,11 +87,11 @@ export const task = {
         // TODO these final printed results could be improved showing a breakdown per file id
         const new_count = analyzed_gen_results.filter((r) => r.is_new).length;
         const changed_count = analyzed_gen_results.filter((r) => r.has_changed).length;
-        const skipped_count = analyzed_gen_results.filter((r) => !r.is_new && !r.has_changed).length;
+        const unchanged_count = analyzed_gen_results.filter((r) => !r.is_new && !r.has_changed).length;
         let log_result = green('gen results:');
         log_result += `\n\t${new_count} ` + gray('new');
         log_result += `\n\t${changed_count} ` + gray('changed');
-        log_result += `\n\t${skipped_count} ` + gray('skipped');
+        log_result += `\n\t${unchanged_count} ` + gray('unchanged');
         for (const result of gen_results.results) {
             log_result += `\n\t${result.ok ? green('✓') : red('🞩')}  ${result.ok ? result.files.length : 0} ${gray('in')} ${print_ms(result.elapsed)} ${gray('←')} ${print_path(result.id)}`;
         }

package/dist/gen.test.js

@@ -1,32 +1,32 @@
-import { suite } from 'uvu';
+import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { resolve } from 'node:path';
-import { to_gen_result } from './gen.js';
+import { to_gen_result, find_genfiles, validate_gen_module } from './gen.js';
+import { paths } from './paths.js';
+import { create_empty_config } from './config.js';
 const origin_id = resolve('src/foo.gen.ts');
-/* test__to_gen_result */
-const test__to_gen_result = suite('to_gen_result');
-test__to_gen_result('plain string', () => {
+test('to_gen_result plain string', () => {
     assert.equal(to_gen_result(origin_id, '/**/'), {
         origin_id,
         files: [{ id: resolve('src/foo.ts'), content: '/**/', origin_id, format: true }],
     });
 });
-test__to_gen_result('object with a content string', () => {
+test('to_gen_result object with a content string', () => {
     assert.equal(to_gen_result(origin_id, { content: '/**/' }), {
         origin_id,
         files: [{ id: resolve('src/foo.ts'), content: '/**/', origin_id, format: true }],
     });
 });
-test__to_gen_result('fail with an unresolved id', () => {
+test('to_gen_result fail with an unresolved id', () => {
     assert.throws(() => to_gen_result('src/foo.ts', { content: '/**/' }));
 });
-test__to_gen_result('fail with a build id', () => {
+test('to_gen_result fail with a build id', () => {
     assert.throws(() => to_gen_result(resolve('.gro/foo.js'), { content: '/**/' }));
 });
-test__to_gen_result('fail with an empty id', () => {
+test('to_gen_result fail with an empty id', () => {
     assert.throws(() => to_gen_result('', { content: '/**/' }));
 });
-test__to_gen_result('custom file name', () => {
+test('to_gen_result custom file name', () => {
     assert.equal(to_gen_result(origin_id, {
         filename: 'fooz.ts',
         content: '/**/',
@@ -35,7 +35,7 @@ test__to_gen_result('custom file name', () => {
         files: [{ id: resolve('src/fooz.ts'), content: '/**/', origin_id, format: true }],
     });
 });
-test__to_gen_result('custom file name that matches the default file name', () => {
+test('to_gen_result custom file name that matches the default file name', () => {
     assert.equal(to_gen_result(origin_id, {
         filename: 'foo.ts',
         content: '/**/',
@@ -44,7 +44,7 @@ test__to_gen_result('custom file name that matches the default file name', () =>
         files: [{ id: resolve('src/foo.ts'), content: '/**/', origin_id, format: true }],
     });
 });
-test__to_gen_result('fail when custom file name explicitly matches the origin', () => {
+test('to_gen_result fail when custom file name explicitly matches the origin', () => {
     assert.throws(() => {
         to_gen_result(origin_id, {
             filename: 'foo.gen.ts',
@@ -52,15 +52,15 @@ test__to_gen_result('fail when custom file name explicitly matches the origin',
         });
     });
 });
-test__to_gen_result('fail when file name implicitly matches the origin', () => {
+test('to_gen_result fail when file name implicitly matches the origin', () => {
     assert.throws(() => {
         to_gen_result(resolve('src/foo.ts'), { content: '/**/' });
     });
 });
-test__to_gen_result('fail with an empty file name', () => {
+test('to_gen_result fail with an empty file name', () => {
     assert.throws(() => to_gen_result(origin_id, { filename: '', content: '/**/' }));
 });
-test__to_gen_result('additional file name parts', () => {
+test('to_gen_result additional file name parts', () => {
     assert.equal(to_gen_result(resolve('src/foo.bar.gen.ts'), { content: '/**/' }), {
         origin_id: resolve('src/foo.bar.gen.ts'),
         files: [
@@ -73,7 +73,7 @@ test__to_gen_result('additional file name parts', () => {
         ],
     });
 });
-test__to_gen_result('js', () => {
+test('to_gen_result js', () => {
     assert.equal(to_gen_result(origin_id, {
         filename: 'foo.js',
         content: '/**/',
@@ -82,7 +82,7 @@ test__to_gen_result('js', () => {
         files: [{ id: resolve('src/foo.js'), content: '/**/', origin_id, format: true }],
     });
 });
-test__to_gen_result('implicit custom file extension', () => {
+test('to_gen_result implicit custom file extension', () => {
     assert.equal(to_gen_result(resolve('src/foo.gen.json.ts'), '[/**/]'), {
         origin_id: resolve('src/foo.gen.json.ts'),
         files: [
@@ -95,7 +95,7 @@ test__to_gen_result('implicit custom file extension', () => {
         ],
     });
 });
-test__to_gen_result('implicit empty file extension', () => {
+test('to_gen_result implicit empty file extension', () => {
     assert.equal(to_gen_result(resolve('src/foo.gen..ts'), '[/**/]'), {
         origin_id: resolve('src/foo.gen..ts'),
         files: [
@@ -108,7 +108,7 @@ test__to_gen_result('implicit empty file extension', () => {
         ],
     });
 });
-test__to_gen_result('implicit custom file extension with additional file name parts', () => {
+test('to_gen_result implicit custom file extension with additional file name parts', () => {
     assert.equal(to_gen_result(resolve('src/foo.bar.gen.json.ts'), { content: '[/**/]' }), {
         origin_id: resolve('src/foo.bar.gen.json.ts'),
         files: [
@@ -121,7 +121,7 @@ test__to_gen_result('implicit custom file extension with additional file name pa
         ],
     });
 });
-test__to_gen_result('implicit custom file extension with many dots in between', () => {
+test('to_gen_result implicit custom file extension with many dots in between', () => {
     assert.equal(to_gen_result(resolve('src/foo...gen.ts'), '[/**/]'), {
         origin_id: resolve('src/foo...gen.ts'),
         files: [
@@ -134,36 +134,36 @@ test__to_gen_result('implicit custom file extension with many dots in between',
         ],
     });
 });
-test__to_gen_result('fail with two parts following the .gen. pattern in the file name', () => {
+test('to_gen_result fail with two parts following the .gen. pattern in the file name', () => {
     // This just ensures consistent file names - maybe loosen the restriction?
     // You can still implicitly name files like this,
     // but you have to move ".bar" before ".gen".
     assert.throws(() => to_gen_result(resolve('src/foo.gen.bar.json.ts'), '/**/'));
 });
-test__to_gen_result('fail implicit file extension ending with a dot', () => {
+test('to_gen_result fail implicit file extension ending with a dot', () => {
     // This just ensures consistent file names - maybe loosen the restriction?
     // This one is more restrictive than the above,
     // because to have a file ending with a dot
     // you have to use an explicit file name.
     assert.throws(() => to_gen_result(resolve('src/foo.gen...ts'), '[/**/]'));
 });
-test__to_gen_result('fail without a .gen. pattern in the file name', () => {
+test('to_gen_result fail without a .gen. pattern in the file name', () => {
     assert.throws(() => {
         to_gen_result(resolve('src/foo.ts'), '/**/');
     });
 });
-test__to_gen_result('fail without a .gen. pattern in a file name that has multiple other patterns', () => {
+test('to_gen_result fail without a .gen. pattern in a file name that has multiple other patterns', () => {
     assert.throws(() => {
         to_gen_result(resolve('src/foo.bar.baz.ts'), '/**/');
     });
 });
-test__to_gen_result('fail with two .gen. patterns in the file name', () => {
+test('to_gen_result fail with two .gen. patterns in the file name', () => {
     assert.throws(() => to_gen_result(resolve('src/lib/gen.gen.ts'), '/**/'));
     assert.throws(() => to_gen_result(resolve('src/foo.gen.gen.ts'), '/**/'));
     assert.throws(() => to_gen_result(resolve('src/foo.gen.bar.gen.ts'), '/**/'));
     assert.throws(() => to_gen_result(resolve('src/foo.gen.bar.gen.baz.ts'), '/**/'));
 });
-test__to_gen_result('explicit custom file extension', () => {
+test('to_gen_result explicit custom file extension', () => {
     assert.equal(to_gen_result(origin_id, {
         filename: 'foo.json',
         content: '[/**/]',
@@ -172,7 +172,7 @@ test__to_gen_result('explicit custom file extension', () => {
         files: [{ id: resolve('src/foo.json'), content: '[/**/]', origin_id, format: true }],
     });
 });
-test__to_gen_result('explicit custom empty file extension', () => {
+test('to_gen_result explicit custom empty file extension', () => {
     assert.equal(to_gen_result(origin_id, {
         filename: 'foo',
         content: '[/**/]',
@@ -181,7 +181,7 @@ test__to_gen_result('explicit custom empty file extension', () => {
         files: [{ id: resolve('src/foo'), content: '[/**/]', origin_id, format: true }],
     });
 });
-test__to_gen_result('explicit custom file extension ending with a dot', () => {
+test('to_gen_result explicit custom file extension ending with a dot', () => {
     assert.equal(to_gen_result(origin_id, {
         filename: 'foo.',
         content: '[/**/]',
@@ -190,7 +190,7 @@ test__to_gen_result('explicit custom file extension ending with a dot', () => {
         files: [{ id: resolve('src/foo.'), content: '[/**/]', origin_id, format: true }],
     });
 });
-test__to_gen_result('simple array of raw files', () => {
+test('to_gen_result simple array of raw files', () => {
     assert.equal(to_gen_result(origin_id, [{ content: '/*1*/' }, { filename: 'foo2.ts', content: '/*2*/' }]), {
         origin_id,
         files: [
@@ -199,7 +199,7 @@ test__to_gen_result('simple array of raw files', () => {
         ],
     });
 });
-test__to_gen_result('complex array of raw files', () => {
+test('to_gen_result complex array of raw files', () => {
     assert.equal(to_gen_result(origin_id, [
         { content: '/*1*/' },
         { filename: 'foo2.ts', content: '/*2*/' },
@@ -217,12 +217,12 @@ test__to_gen_result('complex array of raw files', () => {
         ],
     });
 });
-test__to_gen_result('fail with duplicate names because of omissions', () => {
+test('to_gen_result fail with duplicate names because of omissions', () => {
     assert.throws(() => {
         to_gen_result(origin_id, [{ content: '/*1*/' }, { content: '/*2*/' }]);
     });
 });
-test__to_gen_result('fail with duplicate explicit names', () => {
+test('to_gen_result fail with duplicate explicit names', () => {
     assert.throws(() => {
         to_gen_result(origin_id, [
             { filename: 'foo.ts', content: '/*1*/' },
@@ -230,10 +230,23 @@ test__to_gen_result('fail with duplicate explicit names', () => {
         ]);
     });
 });
-test__to_gen_result('fail with duplicate explicit and implicit names', () => {
+test('to_gen_result fail with duplicate explicit and implicit names', () => {
     assert.throws(() => {
         to_gen_result(origin_id, [{ content: '/*1*/' }, { filename: 'foo.ts', content: '/*2*/' }]);
     });
 });
-test__to_gen_result.run();
-/* test__to_gen_result */
+test('validate_gen_module basic behavior', () => {
+    assert.ok(validate_gen_module({ gen: Function.prototype }));
+    assert.ok(!validate_gen_module({ gen: {} }));
+    assert.ok(!validate_gen_module({ task: { run: {} } }));
+    assert.ok(!validate_gen_module(undefined));
+    assert.ok(!validate_gen_module(null));
+    assert.ok(!validate_gen_module(false));
+});
+test('find_genfiles_result finds gen modules in a directory', async () => {
+    const find_genfiles_result = await find_genfiles(['docs'], [paths.lib], create_empty_config());
+    assert.ok(find_genfiles_result.ok);
+    assert.ok(find_genfiles_result.value.resolved_input_paths.length);
+    assert.ok(find_genfiles_result.value.resolved_input_paths_by_input_path.size);
+});
+test.run();

package/dist/git.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { SpawnOptions } from 'child_process';
 import { z } from 'zod';
 export declare const Git_Origin: z.ZodBranded<z.ZodString, "Git_Origin">;