@ryanatkn/gro 0.116.2 → 0.118.0

package/dist/invoke_task.js

@@ -1,17 +1,15 @@
 import { cyan, red, gray } from 'kleur/colors';
-import { Logger, System_Logger, print_log_label } from '@ryanatkn/belt/log.js';
+import { System_Logger, print_log_label } from '@ryanatkn/belt/log.js';
 import { create_stopwatch, Timings } from '@ryanatkn/belt/timings.js';
 import { print_ms, print_timings } from '@ryanatkn/belt/print.js';
 import { to_forwarded_args } from './args.js';
 import { run_task } from './run_task.js';
-import { resolve_input_path } from './input_path.js';
-import { is_task_path } from './task.js';
-import { is_gro_id, is_this_project_gro, print_path, print_path_or_gro_path, gro_sveltekit_dist_dir, to_gro_input_path, } from './paths.js';
-import { find_modules, load_modules } from './modules.js';
+import { to_input_path, Raw_Input_Path } from './input_path.js';
+import { is_gro_id, IS_THIS_GRO, print_path, print_path_or_gro_path } from './paths.js';
+import { load_modules } from './modules.js';
 import { find_task_modules, load_task_module } from './task_module.js';
 import { load_gro_package_json } from './package_json.js';
-import { log_available_tasks, log_error_reasons } from './print_task.js';
-import { search_fs } from './search_fs.js';
+import { log_tasks, log_error_reasons, log_gro_package_tasks } from './task_logging.js';
 /**
  * Invokes Gro tasks by name using the filesystem as the source.
  *
@@ -33,108 +31,100 @@ export const invoke_task = async (task_name, args, config, timings = new Timings
     const log = new System_Logger(print_log_label(task_name || 'gro'));
     log.info('invoking', task_name ? cyan(task_name) : 'gro');
     const total_timing = create_stopwatch();
+    const finish = () => {
+        print_timings(timings, log);
+        log.info(`🕒 ${print_ms(total_timing())}`);
+    };
     // Check if the caller just wants to see the version.
     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 = resolve_input_path(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], undefined, [
-        gro_sveltekit_dist_dir,
-    ]);
-    if (find_modules_result.ok) {
-        // Found a match either in the current working directory or Gro's directory.
-        const path_data = find_modules_result.source_id_path_data_by_input_path.get(input_path); // this is null safe because result is ok
-        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);
-            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.
-                const task = load_modules_result.modules[0];
-                log.info(`→ ${cyan(task.name)} ${(task.mod.task.summary && gray(task.mod.task.summary)) || ''}`);
-                const timing_to_run_task = timings.start('run task ' + task_name);
-                const result = await run_task(task, { ...args, ...to_forwarded_args(`gro ${task.name}`) }, invoke_task, config, timings);
-                timing_to_run_task();
-                if (result.ok) {
-                    log.info(`✓ ${cyan(task.name)}`);
-                }
-                else {
-                    log.info(`${red('🞩')} ${cyan(task.name)}`);
-                    log_error_reasons(log, [result.reason]);
-                    throw result.error;
-                }
+    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.
+            if (IS_THIS_GRO ||
+                // this is null safe because of the failure type
+                is_gro_id(find_modules_result.source_id_path_data_by_input_path.get(input_path).id)) {
+                // If the directory is inside Gro, just log the errors.
+                log_error_reasons(log, find_modules_result.reasons);
+                process.exit(1);
             }
             else {
-                log_error_reasons(log, load_modules_result.reasons);
-                process.exit(1);
+                // 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, 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);
+                    process.exit(1);
+                }
+                finish();
+                return;
             }
         }
         else {
-            // The input path matches a directory. Log the tasks but don't run them.
-            if (is_this_project_gro) {
-                // Is the Gro directory the same as the cwd? Log the matching files.
-                await log_available_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path);
-            }
-            else if (is_gro_id(path_data.id)) {
-                // TODO delete this?
-                // Does the Gro directory contain the matching files? Log them.
-                await log_available_tasks(log, print_path_or_gro_path(path_data.id), find_modules_result.source_ids_by_input_path);
+            // Some unknown find modules result failure happened, so log it out.
+            // (currently, just "unmapped_input_paths")
+            log_error_reasons(log, find_modules_result.reasons);
+            process.exit(1);
+        }
+    }
+    // Found a match either in the current working directory or Gro's directory.
+    const path_data = find_modules_result.source_id_path_data_by_input_path.get(input_path); // this is null safe because result is ok
+    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, (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.
+            const task = load_modules_result.modules[0];
+            log.info(`→ ${cyan(task.name)} ${(task.mod.task.summary && gray(task.mod.task.summary)) || ''}`);
+            const timing_to_run_task = timings.start('run task ' + task_name);
+            const result = await run_task(task, { ...args, ...to_forwarded_args(`gro ${task.name}`) }, invoke_task, config, timings);
+            timing_to_run_task();
+            if (result.ok) {
+                log.info(`✓ ${cyan(task.name)}`);
             }
             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 the Gro directory as well,
-                // and log everything out.
-                // Ignore any errors - the directory may not exist or have any files!
-                const gro_dir_find_modules_result = await to_gro_dir_find_modules_result(input_path, log);
-                // Then log the current working directory matches.
-                await log_available_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path, !gro_dir_find_modules_result.ok);
+                log.info(`${red('🞩')} ${cyan(task.name)}`);
+                log_error_reasons(log, [result.reason]);
+                throw result.error;
             }
         }
-    }
-    else if (find_modules_result.type === 'input_directories_with_no_files') {
-        // The input path matched a directory, but it contains no matching files.
-        if (is_this_project_gro ||
-            // this is null safe because of the failure type
-            is_gro_id(find_modules_result.source_id_path_data_by_input_path.get(input_path).id)) {
-            // If the directory is inside Gro, just log the errors.
-            log_error_reasons(log, find_modules_result.reasons);
-            process.exit(1);
-        }
         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 to_gro_dir_find_modules_result(input_path, 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);
-                process.exit(1);
-            }
+            log_error_reasons(log, load_modules_result.reasons);
+            process.exit(1);
         }
     }
     else {
-        // Some other find modules result failure happened, so log it out.
-        // (currently, just "unmapped_input_paths")
-        log_error_reasons(log, find_modules_result.reasons);
-        process.exit(1);
-    }
-    print_timings(timings, log);
-    log.info(`🕒 ${print_ms(total_timing())}`);
-};
-const to_gro_dir_find_modules_result = async (input_path, 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_available_tasks(log, print_path_or_gro_path(gro_path_data.id), gro_dir_find_modules_result.source_ids_by_input_path);
+        // 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, task_root_paths);
+        }
+        else if (is_gro_id(path_data.id)) {
+            // 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, 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, 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, task_root_paths, !gro_dir_find_modules_result.ok);
+        }
     }
-    return gro_dir_find_modules_result;
+    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),

package/dist/module.d.ts

@@ -1,3 +1,3 @@
 export declare const MODULE_PATH_SRC_PREFIX: string;
-export declare const MODULE_PATH_LIB_PREFIX = "$lib/";
+export declare const MODULE_PATH_LIB_PREFIX: string;
 export declare const is_external_module: (module_name: string) => boolean;

package/dist/module.js

@@ -1,5 +1,5 @@
-// TODO refactor to be configurable, probably following Rollup's patterns
-import { SOURCE_DIR, SOURCE_DIRNAME, LIB_DIRNAME } from './paths.js';
+import { LIB_DIRNAME } from './paths.js';
+import { SOURCE_DIR, SOURCE_DIRNAME } from './path_constants.js';
 export const MODULE_PATH_SRC_PREFIX = SOURCE_DIR;
 export const MODULE_PATH_LIB_PREFIX = `$${LIB_DIRNAME}/`;
 const INTERNAL_MODULE_MATCHER = new RegExp(`^(\\.?\\.?|${SOURCE_DIRNAME}|\\$${LIB_DIRNAME})\\/`, 'u');

package/dist/modules.d.ts

@@ -1,4 +1,5 @@
 import type { Result } from '@ryanatkn/belt/result.js';
+import { Input_Path } from './input_path.js';
 import type { Path_Data } from './path.js';
 import { type Source_Id } from './paths.js';
 export interface Module_Meta<T_Module extends Record<string, any> = Record<string, any>> {
@@ -22,19 +23,19 @@ export type Load_Module_Failure = {
 };
 export declare const load_module: <T extends Record<string, any>>(id: string, validate?: (mod: Record<string, any>) => mod is T) => Promise<Load_Module_Result<Module_Meta<T>>>;
 export type Find_Modules_Result = Result<{
-    source_ids_by_input_path: Map<string, string[]>;
-    source_id_path_data_by_input_path: Map<string, Path_Data>;
+    source_ids_by_input_path: Map<Input_Path, Source_Id[]>;
+    source_id_path_data_by_input_path: Map<Input_Path, Path_Data>;
 }, Find_Modules_Failure>;
 export type Find_Modules_Failure = {
     type: 'unmapped_input_paths';
-    source_id_path_data_by_input_path: Map<string, Path_Data>;
-    unmapped_input_paths: string[];
+    source_id_path_data_by_input_path: Map<Input_Path, Path_Data>;
+    unmapped_input_paths: Input_Path[];
     reasons: string[];
 } | {
     type: 'input_directories_with_no_files';
-    source_ids_by_input_path: Map<string, string[]>;
-    source_id_path_data_by_input_path: Map<string, Path_Data>;
-    input_directories_with_no_files: string[];
+    source_ids_by_input_path: Map<Input_Path, Source_Id[]>;
+    source_id_path_data_by_input_path: Map<Input_Path, Path_Data>;
+    input_directories_with_no_files: Input_Path[];
     reasons: string[];
 };
 export type Load_Modules_Result<T_Module_Meta extends Module_Meta> = Result<{
@@ -45,5 +46,8 @@ export type Load_Modules_Result<T_Module_Meta extends Module_Meta> = Result<{
     reasons: string[];
     modules: T_Module_Meta[];
 }>;
-export declare const find_modules: (input_paths: string[], custom_search_fs?: (dir: string, options?: import("./search_fs.js").Search_Fs_Options) => Promise<Map<string, import("./path.js").Path_Stats>>, get_possible_source_ids?: (input_path: string) => string[], timings?: any) => Promise<Find_Modules_Result>;
-export declare const load_modules: <Module_Type extends Record<string, any>, T_Module_Meta extends Module_Meta<Module_Type>>(source_ids_by_input_path: Map<string, string[]>, load_module_by_id: (source_id: Source_Id) => Promise<Load_Module_Result<T_Module_Meta>>, timings?: any) => Promise<Load_Modules_Result<T_Module_Meta>>;
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export declare const find_modules: (input_paths: Input_Path[], custom_search_fs?: (dir: string, options?: import("./search_fs.js").Search_Fs_Options) => Promise<Map<string, import("./path.js").Path_Stats>>, get_possible_source_ids?: (input_path: Input_Path) => Source_Id[], timings?: any) => Promise<Find_Modules_Result>;
+export declare const load_modules: <Module_Type extends Record<string, any>, T_Module_Meta extends Module_Meta<Module_Type>>(source_ids_by_input_path: Map<Input_Path, Source_Id[]>, load_module_by_id: (source_id: Source_Id) => Promise<Load_Module_Result<T_Module_Meta>>, timings?: any) => Promise<Load_Modules_Result<T_Module_Meta>>;

package/dist/modules.js

@@ -1,7 +1,7 @@
 import { red } from 'kleur/colors';
 import { Unreachable_Error } from '@ryanatkn/belt/error.js';
 import { print_error } from '@ryanatkn/belt/print.js';
-import { load_source_path_data_by_input_path, load_source_ids_by_input_path } from './input_path.js';
+import { load_source_path_data_by_input_path, load_source_ids_by_input_path, Input_Path, } from './input_path.js';
 import { paths_from_id, print_path, print_path_or_gro_path } from './paths.js';
 import { search_fs } from './search_fs.js';
 export const load_module = async (id, validate) => {
@@ -17,11 +17,9 @@ export const load_module = async (id, validate) => {
     }
     return { ok: true, mod: { id, mod } };
 };
-/*
-
-Finds modules from input paths. (see `src/lib/input_path.ts` for more)
-
-*/
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
 export const find_modules = async (input_paths, custom_search_fs = search_fs, get_possible_source_ids, timings) => {
     // Check which extension variation works - if it's a directory, prefer others first!
     const timing_to_map_input_paths = timings?.start('map input paths');
@@ -53,13 +51,7 @@ export const find_modules = async (input_paths, custom_search_fs = search_fs, ge
         }
         : { ok: true, source_ids_by_input_path, source_id_path_data_by_input_path };
 };
-/*
-
-Load modules by source id.
-
-TODO parallelize, originally it needed to be serial for a specific usecase we no longer have
-
-*/
+// TODO parallelize, originally it needed to be serial for a specific usecase we no longer have
 export const load_modules = async (source_ids_by_input_path, // TODO maybe make this a flat array and remove `input_path`?
 load_module_by_id, timings) => {
     const timing_to_load_modules = timings?.start('load modules');

package/dist/modules.test.js

@@ -69,7 +69,7 @@ test__find_modules('with and without extension', async () => {
     const path1 = resolve('src/fixtures/test1');
     const id1 = resolve('src/fixtures/test1.foo.ts');
     const id2 = resolve('src/fixtures/test2.foo.ts');
-    const result = await find_modules([path1, id2], (id) => search_fs(id, { files_only: false }), (input_path) => get_possible_source_ids(input_path, ['.foo.ts']));
+    const result = await find_modules([path1, id2], (id) => search_fs(id, { files_only: false }), (input_path) => get_possible_source_ids(input_path, ['.foo.ts'], []));
     assert.ok(result.ok);
     assert.equal(result.source_ids_by_input_path, new Map([
         [path1, [id1]],
@@ -93,7 +93,7 @@ test__find_modules('fail with unmapped_input_paths', async () => {
         resolve('src/fixtures/failme1'),
         resolve('src/fixtures/bar2'),
         resolve('src/fixtures/failme2'),
-    ], (id) => search_fs(id, { files_only: false }), (input_path) => get_possible_source_ids(input_path, ['.foo.ts']));
+    ], (id) => search_fs(id, { files_only: false }), (input_path) => get_possible_source_ids(input_path, ['.foo.ts'], []));
     assert.ok(!result.ok);
     assert.ok(result.reasons.length);
     if (result.type === 'unmapped_input_paths') {

package/dist/package.d.ts

@@ -290,6 +290,10 @@ export declare const package_json: {
             default: string;
             types: string;
         };
+        './path_constants.js': {
+            default: string;
+            types: string;
+        };
         './path.js': {
             default: string;
             types: string;
@@ -302,11 +306,11 @@ export declare const package_json: {
             default: string;
             types: string;
         };
-        './print_task.js': {
+        './publish.task.js': {
             default: string;
             types: string;
         };
-        './publish.task.js': {
+        './register.js': {
             default: string;
             types: string;
         };
@@ -346,10 +350,18 @@ export declare const package_json: {
             default: string;
             types: string;
         };
+        './sveltekit_config_global.js': {
+            default: string;
+            types: string;
+        };
         './sveltekit_config.js': {
             default: string;
             types: string;
         };
+        './sveltekit_helpers.js': {
+            default: string;
+            types: string;
+        };
         './sveltekit_shim_app_environment.js': {
             default: string;
             types: string;
@@ -382,6 +394,10 @@ export declare const package_json: {
             default: string;
             types: string;
         };
+        './task_logging.js': {
+            default: string;
+            types: string;
+        };
         './task_module.js': {
             default: string;
             types: string;
@@ -754,28 +770,28 @@ export declare const src_json: {
                 kind: string;
             }[];
         };
-        './path.js': {
+        './path_constants.js': {
             path: string;
             declarations: {
                 name: string;
                 kind: string;
             }[];
         };
-        './paths.js': {
+        './path.js': {
             path: string;
             declarations: {
                 name: string;
                 kind: string;
             }[];
         };
-        './plugin.js': {
+        './paths.js': {
             path: string;
             declarations: {
                 name: string;
                 kind: string;
             }[];
         };
-        './print_task.js': {
+        './plugin.js': {
             path: string;
             declarations: {
                 name: string;
@@ -789,6 +805,10 @@ export declare const src_json: {
                 kind: string;
             }[];
         };
+        './register.js': {
+            path: string;
+            declarations: never[];
+        };
         './release.task.js': {
             path: string;
             declarations: {
@@ -852,6 +872,13 @@ export declare const src_json: {
                 kind: string;
             }[];
         };
+        './sveltekit_config_global.js': {
+            path: string;
+            declarations: {
+                name: string;
+                kind: string;
+            }[];
+        };
         './sveltekit_config.js': {
             path: string;
             declarations: {
@@ -859,6 +886,13 @@ export declare const src_json: {
                 kind: string;
             }[];
         };
+        './sveltekit_helpers.js': {
+            path: string;
+            declarations: {
+                name: string;
+                kind: string;
+            }[];
+        };
         './sveltekit_shim_app_environment.js': {
             path: string;
             declarations: {
@@ -915,6 +949,13 @@ export declare const src_json: {
                 kind: string;
             }[];
         };
+        './task_logging.js': {
+            path: string;
+            declarations: {
+                name: string;
+                kind: string;
+            }[];
+        };
         './task_module.js': {
             path: string;
             declarations: never[];

package/dist/package.gen.js

@@ -1,5 +1,5 @@
 import { load_package_json } from './package_json.js';
-import { is_this_project_gro, to_root_path } from './paths.js';
+import { IS_THIS_GRO, to_root_path } from './paths.js';
 import { create_src_json } from './src_json.js';
 // TODO rename? `Package_Json + Src_Json = package.ts` currently, idk
 // TODO consider an api that uses magic imports like SvelteKit's `$app`, like `$repo/package.json`
@@ -14,8 +14,8 @@ export const gen = async ({ origin_id }) => {
     return `
 // generated by ${to_root_path(origin_id)}
 
-import type {Package_Json} from '${is_this_project_gro ? './package_json.js' : '@ryanatkn/gro/package_json.js'}';
-import type {Src_Json} from '${is_this_project_gro ? './src_json.js' : '@ryanatkn/gro/src_json.js'}';
+import type {Package_Json} from '${IS_THIS_GRO ? './package_json.js' : '@ryanatkn/gro/package_json.js'}';
+import type {Src_Json} from '${IS_THIS_GRO ? './src_json.js' : '@ryanatkn/gro/src_json.js'}';
 
 export const package_json = ${JSON.stringify(package_json)} satisfies Package_Json;