@ryanatkn/gro 0.154.0 → 0.155.0

package/dist/gro_helpers.js

@@ -2,7 +2,7 @@ import { realpathSync, existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from '@ryanatkn/belt/process.js';
-import { JS_CLI_DEFAULT, NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME } from './constants.js';
+import { JS_CLI_DEFAULT, NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME } from "./constants.js";
 /*
 
 This module is intended to have minimal dependencies to avoid over-imports in the CLI.
@@ -82,8 +82,11 @@ export const spawn_with_loader = (loader_path, invoke_path, argv, js_cli = JS_CL
 			import {register} from "node:module";
 			import {pathToFileURL} from "node:url";
 			register("${loader_path}", pathToFileURL("./"));`,
+        // @sync Node options to `$lib/gro.ts`
         '--experimental-import-meta-resolve', // for `import.meta.resolve`
-        '--enable-source-maps', // because TypeScript
+        '--experimental-strip-types',
+        '--disable-warning',
+        'ExperimentalWarning',
     ];
     // In almost all cases we want the exports condition to be `"development"`. Needed for `esm-env`.
     if (process.env.NODE_ENV !== 'production') {

package/dist/gro_plugin_gen.d.ts

@@ -1,5 +1,5 @@
-import type { Plugin } from './plugin.js';
-import type { Args } from './args.js';
+import type { Plugin } from './plugin.ts';
+import type { Args } from './args.ts';
 export interface Task_Args extends Args {
     watch?: boolean;
 }

package/dist/gro_plugin_gen.js

@@ -1,10 +1,10 @@
 import { EMPTY_OBJECT } from '@ryanatkn/belt/object.js';
 import { throttle } from '@ryanatkn/belt/throttle.js';
 import { Unreachable_Error } from '@ryanatkn/belt/error.js';
-import { paths } from './paths.js';
-import { find_genfiles, is_gen_path } from './gen.js';
-import { spawn_cli } from './cli.js';
-import { filter_dependents } from './filer.js';
+import { paths } from "./paths.js";
+import { find_genfiles, is_gen_path } from "./gen.js";
+import { spawn_cli } from "./cli.js";
+import { filter_dependents } from "./filer.js";
 const FLUSH_DEBOUNCE_DELAY = 500;
 export const gro_plugin_gen = ({ input_paths = [paths.source], root_dirs = [paths.source], flush_debounce_delay = FLUSH_DEBOUNCE_DELAY, } = EMPTY_OBJECT) => {
     let flushing_timeout;

package/dist/gro_plugin_server.d.ts

@@ -1,7 +1,7 @@
 import * as esbuild from 'esbuild';
 import type { Config as SvelteConfig } from '@sveltejs/kit';
 import type { Result } from '@ryanatkn/belt/result.js';
-import type { Plugin } from './plugin.js';
+import type { Plugin } from './plugin.ts';
 export declare const SERVER_SOURCE_ID: Flavored<string, "Path_Id">;
 export declare const has_server: (path?: Flavored<string, "Path_Id">) => Result<object, {
     message: string;

package/dist/gro_plugin_server.js

@@ -5,17 +5,17 @@ import { identity } from '@ryanatkn/belt/function.js';
 import { strip_before, strip_end } from '@ryanatkn/belt/string.js';
 import { existsSync } from 'node:fs';
 import { throttle } from '@ryanatkn/belt/throttle.js';
-import { base_path_to_path_id, LIB_DIRNAME, paths } from './paths.js';
-import { GRO_DEV_DIRNAME, SERVER_DIST_PATH } from './constants.js';
-import { watch_dir } from './watch_dir.js';
-import { parse_svelte_config, default_svelte_config } from './svelte_config.js';
-import { esbuild_plugin_sveltekit_shim_app } from './esbuild_plugin_sveltekit_shim_app.js';
-import { esbuild_plugin_sveltekit_shim_env } from './esbuild_plugin_sveltekit_shim_env.js';
-import { print_build_result, to_define_import_meta_env } from './esbuild_helpers.js';
-import { esbuild_plugin_sveltekit_shim_alias } from './esbuild_plugin_sveltekit_shim_alias.js';
-import { esbuild_plugin_external_worker } from './esbuild_plugin_external_worker.js';
-import { esbuild_plugin_sveltekit_local_imports } from './esbuild_plugin_sveltekit_local_imports.js';
-import { esbuild_plugin_svelte } from './esbuild_plugin_svelte.js';
+import { base_path_to_path_id, LIB_DIRNAME, paths } from "./paths.js";
+import { GRO_DEV_DIRNAME, SERVER_DIST_PATH } from "./constants.js";
+import { watch_dir } from "./watch_dir.js";
+import { parse_svelte_config, default_svelte_config } from "./svelte_config.js";
+import { esbuild_plugin_sveltekit_shim_app } from "./esbuild_plugin_sveltekit_shim_app.js";
+import { esbuild_plugin_sveltekit_shim_env } from "./esbuild_plugin_sveltekit_shim_env.js";
+import { print_build_result, to_define_import_meta_env } from "./esbuild_helpers.js";
+import { esbuild_plugin_sveltekit_shim_alias } from "./esbuild_plugin_sveltekit_shim_alias.js";
+import { esbuild_plugin_external_worker } from "./esbuild_plugin_external_worker.js";
+import { esbuild_plugin_sveltekit_local_imports } from "./esbuild_plugin_sveltekit_local_imports.js";
+import { esbuild_plugin_svelte } from "./esbuild_plugin_svelte.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_path_id(LIB_DIRNAME + '/server/server.ts');
 export const has_server = (path = SERVER_SOURCE_ID) => {

package/dist/gro_plugin_sveltekit_app.d.ts

@@ -1,6 +1,6 @@
-import type { Plugin } from './plugin.js';
-import { type Map_Package_Json } from './package_json.js';
-import { type Map_Src_Json } from './src_json.js';
+import type { Plugin } from './plugin.ts';
+import { type Map_Package_Json } from './package_json.ts';
+import { type Map_Src_Json } from './src_json.ts';
 export interface Gro_Plugin_Sveltekit_App_Options {
     /**
      * Used for finalizing a SvelteKit build like adding a `.nojekyll` file for GitHub Pages.

package/dist/gro_plugin_sveltekit_app.js

@@ -1,14 +1,14 @@
 import { cpSync, mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { serialize_args, to_forwarded_args } from './args.js';
-import { serialize_package_json, load_package_json } from './package_json.js';
-import { Task_Error } from './task.js';
-import { find_cli, spawn_cli, spawn_cli_process } from './cli.js';
-import { serialize_src_json, create_src_json } from './src_json.js';
-import { EXPORTS_EXCLUDER_DEFAULT } from './gro_config.js';
-import { default_svelte_config } from './svelte_config.js';
-import { SOURCE_DIRNAME } from './constants.js';
-import { VITE_CLI } from './sveltekit_helpers.js';
+import { serialize_args, to_forwarded_args } from "./args.js";
+import { serialize_package_json, load_package_json } from "./package_json.js";
+import { Task_Error } from "./task.js";
+import { find_cli, spawn_cli, spawn_cli_process } from "./cli.js";
+import { serialize_src_json, create_src_json } from "./src_json.js";
+import { EXPORTS_EXCLUDER_DEFAULT } from "./gro_config.js";
+import { default_svelte_config } from "./svelte_config.js";
+import { SOURCE_DIRNAME } from "./constants.js";
+import { VITE_CLI } from "./sveltekit_helpers.js";
 export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_known_package_json, well_known_src_json, well_known_src_files, vite_cli = VITE_CLI, } = {}) => {
     let sveltekit_process = undefined;
     return {
@@ -16,7 +16,7 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
         setup: async ({ dev, watch, log, config }) => {
             const found_vite_cli = find_cli(vite_cli);
             if (!found_vite_cli)
-                throw new Error(`Failed to find Vite CLI \`${vite_cli}\`, do you need to run \`${config.pm_cli} i\`?`);
+                throw Error(`Failed to find Vite CLI \`${vite_cli}\`, do you need to run \`${config.pm_cli} i\`?`);
             if (dev) {
                 // `vite dev` in development mode
                 if (watch) {

package/dist/gro_plugin_sveltekit_library.d.ts

@@ -1,5 +1,5 @@
-import type { Plugin } from './plugin.js';
-import { type Svelte_Package_Options } from './sveltekit_helpers.js';
+import type { Plugin } from './plugin.ts';
+import { type Svelte_Package_Options } from './sveltekit_helpers.ts';
 export interface Gro_Plugin_Sveltekit_Library_Options {
     /**
      * The options passed to the SvelteKit packaging CLI.

package/dist/gro_plugin_sveltekit_library.js

@@ -1,7 +1,7 @@
 import { print_spawn_result, spawn } from '@ryanatkn/belt/process.js';
-import { Task_Error } from './task.js';
-import { load_package_json } from './package_json.js';
-import { SVELTE_PACKAGE_CLI, run_svelte_package, } from './sveltekit_helpers.js';
+import { Task_Error } from "./task.js";
+import { load_package_json } from "./package_json.js";
+import { SVELTE_PACKAGE_CLI, run_svelte_package, } from "./sveltekit_helpers.js";
 export const gro_plugin_sveltekit_library = ({ svelte_package_options, svelte_package_cli = SVELTE_PACKAGE_CLI, } = {}) => {
     const package_json = load_package_json();
     return {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export type { Gro_Config, Create_Gro_Config, Raw_Gro_Config } from './gro_config.js';
-export { type Plugin, replace_plugin } from './plugin.js';
-export type { Gen, Gen_Context } from './gen.js';
-export { type Task, type Task_Context, Task_Error } from './task.js';
+export type { Gro_Config, Create_Gro_Config, Raw_Gro_Config } from './gro_config.ts';
+export { type Plugin, replace_plugin } from './plugin.ts';
+export type { Gen, Gen_Context } from './gen.ts';
+export { type Task, type Task_Context, Task_Error } from './task.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,2 +1,2 @@
-export { replace_plugin } from './plugin.js';
-export { Task_Error } from './task.js';
+export { replace_plugin } from "./plugin.js";
+export { Task_Error } from "./task.js";

package/dist/input_path.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { Flavored } from '@ryanatkn/belt/types.js';
-import type { Path_Id, Resolved_Path } from './path.js';
+import type { Path_Id, Resolved_Path } from './path.ts';
 export declare const Input_Path: z.ZodString;
 export type Input_Path = Flavored<z.infer<typeof Input_Path>, 'Input_Path'>;
 export declare const Raw_Input_Path: z.ZodString;

package/dist/input_path.js

@@ -2,9 +2,9 @@ import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { existsSync, statSync } from 'node:fs';
 import { strip_start } from '@ryanatkn/belt/string.js';
 import { z } from 'zod';
-import { GRO_PACKAGE_DIR, GRO_DIST_DIR } from './paths.js';
-import { search_fs } from './search_fs.js';
-import { TASK_FILE_SUFFIX_JS } from './task.js';
+import { GRO_PACKAGE_DIR, GRO_DIST_DIR } from "./paths.js";
+import { search_fs } from "./search_fs.js";
+import { TASK_FILE_SUFFIX_JS } from "./task.js";
 // TODO Flavored doesn't work when used in schemas, use Zod brand instead? problem is ergonomics
 export const Input_Path = z.string();
 export const Raw_Input_Path = z.string();

package/dist/invoke.js

@@ -2,10 +2,10 @@ import { attach_process_error_handlers } from '@ryanatkn/belt/process.js';
 import { configure_log_colors } from '@ryanatkn/belt/log.js';
 import { set_colors } from '@ryanatkn/belt/print.js';
 import { styleText } from 'node:util';
-import { invoke_task } from './invoke_task.js';
-import { to_task_args } from './args.js';
-import { load_gro_config } from './gro_config.js';
-import { sveltekit_sync_if_obviously_needed } from './sveltekit_helpers.js';
+import { invoke_task } from "./invoke_task.js";
+import { to_task_args } from "./args.js";
+import { load_gro_config } from "./gro_config.js";
+import { sveltekit_sync_if_obviously_needed } from "./sveltekit_helpers.js";
 /*
 
 This module invokes the Gro CLI which in turn invokes tasks.

package/dist/invoke_task.d.ts

@@ -1,8 +1,8 @@
 import { Timings } from '@ryanatkn/belt/timings.js';
-import { type Args } from './args.js';
-import { Raw_Input_Path } from './input_path.js';
-import type { Gro_Config } from './gro_config.js';
-import { Filer } from './filer.js';
+import { type Args } from './args.ts';
+import { Raw_Input_Path } from './input_path.ts';
+import type { Gro_Config } from './gro_config.ts';
+import { Filer } from './filer.ts';
 /**
  * Invokes Gro tasks by name using the filesystem as the source.
  *

package/dist/invoke_task.js

@@ -2,13 +2,13 @@ import { styleText as st } from 'node:util';
 import { System_Logger } from '@ryanatkn/belt/log.js';
 import { create_stopwatch, Timings } from '@ryanatkn/belt/timings.js';
 import { print_ms, print_timings, print_log_label } from '@ryanatkn/belt/print.js';
-import { to_forwarded_args } from './args.js';
-import { run_task } from './run_task.js';
-import { to_input_path, Raw_Input_Path } from './input_path.js';
-import { find_tasks, load_tasks, Silent_Error } from './task.js';
-import { load_gro_package_json } from './package_json.js';
-import { log_tasks, log_error_reasons } from './task_logging.js';
-import { Filer } from './filer.js';
+import { to_forwarded_args } from "./args.js";
+import { run_task } from "./run_task.js";
+import { to_input_path, Raw_Input_Path } from "./input_path.js";
+import { find_tasks, load_tasks, Silent_Error } from "./task.js";
+import { load_gro_package_json } from "./package_json.js";
+import { log_tasks, log_error_reasons } from "./task_logging.js";
+import { Filer } from "./filer.js";
 /**
  * Invokes Gro tasks by name using the filesystem as the source.
  *

package/dist/lint.task.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { type Task } from './task.js';
+import { type Task } from './task.ts';
 export declare const Args: z.ZodObject<{
     _: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     eslint_cli: z.ZodDefault<z.ZodString>;

package/dist/lint.task.js

@@ -1,8 +1,8 @@
 import { print_spawn_result } from '@ryanatkn/belt/process.js';
 import { z } from 'zod';
-import { Task_Error } from './task.js';
-import { serialize_args, to_forwarded_args } from './args.js';
-import { find_cli, spawn_cli } from './cli.js';
+import { Task_Error } from "./task.js";
+import { serialize_args, to_forwarded_args } from "./args.js";
+import { find_cli, spawn_cli } from "./cli.js";
 const ESLINT_CLI = 'eslint';
 export const Args = z
     .object({

package/dist/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAC,MAAM,aAAa,CAAC;AA8EvD,eAAO,MAAM,IAAI,EAAE,QAwFlB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WAoDrB,CAAC"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/loader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAC,MAAM,aAAa,CAAC;AAuEvD,eAAO,MAAM,IAAI,EAAE,QA+FlB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WAqDrB,CAAC"}

package/dist/loader.js

@@ -1,18 +1,17 @@
-import * as esbuild from 'esbuild';
 import { compile, compileModule, preprocess } from 'svelte/compiler';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, join } from 'node:path';
 import { escape_regexp } from '@ryanatkn/belt/regexp.js';
 import { readFileSync } from 'node:fs';
-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 { default_svelte_config } from './svelte_config.js';
-import { SVELTE_MATCHER, SVELTE_RUNES_MATCHER } from './svelte_helpers.js';
-import { IS_THIS_GRO, paths } from './paths.js';
-import { JSON_MATCHER, NODE_MODULES_DIRNAME, TS_MATCHER } from './constants.js';
-import { to_define_import_meta_env, default_ts_transform_options } from './esbuild_helpers.js';
-import { resolve_specifier } from './resolve_specifier.js';
-import { map_sveltekit_aliases } from './sveltekit_helpers.js';
+import ts_blank_space from 'ts-blank-space';
+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 { default_svelte_config } from "./svelte_config.js";
+import { SVELTE_MATCHER, SVELTE_RUNES_MATCHER } from "./svelte_helpers.js";
+import { IS_THIS_GRO, paths } from "./paths.js";
+import { JSON_MATCHER, NODE_MODULES_DIRNAME, TS_MATCHER } from "./constants.js";
+import { resolve_specifier } from "./resolve_specifier.js";
+import { map_sveltekit_aliases } from "./sveltekit_helpers.js";
 // TODO get out of the loader business, starting with https://nodejs.org/api/typescript.html#type-stripping
 /*
 
@@ -31,7 +30,7 @@ gro run foo.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("./"));' --experimental-import-meta-resolve --enable-source-maps' foo.ts
+node --import 'data:text/javascript,import {register} from "node:module"; import {pathToFileURL} from "node:url"; register("@ryanatkn/gro/loader.js", pathToFileURL("./"));' --experimental-import-meta-resolve --experimental-strip-types' foo.ts
 ```
 
 TODO how to improve that gnarly import line? was originally designed for the now-deprecated `--loader`
@@ -43,16 +42,11 @@ TODO how to improve that gnarly import line? was originally designed for the now
 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, } = default_svelte_config;
-const ts_transform_options = {
-    ...default_ts_transform_options,
-    define: to_define_import_meta_env(dev, base_url),
-    sourcemap: 'inline',
-};
 const aliases = Object.entries(alias);
 const RAW_MATCHER = /(%3Fraw|\.css|\.svg)$/; // TODO others? configurable?
-const ENV_MATCHER = /src\/lib\/\$env\/(static|dynamic)\/(public|private)$/;
 const NODE_MODULES_MATCHER = new RegExp(escape_regexp('/' + NODE_MODULES_DIRNAME + '/'), 'u');
 export const load = async (url, context, nextLoad) => {
+    // console.log(`url`, url);
     if (SVELTEKIT_SHIM_APP_PATHS_MATCHER.test(url)) {
         // SvelteKit `$app/paths` shim
         return {
@@ -70,26 +64,28 @@ export const load = async (url, context, nextLoad) => {
         };
     }
     else if (SVELTE_RUNES_MATCHER.test(url)) {
-        // Svelte runes in js/ts
-        const loaded = await nextLoad(url, context.format === 'module' ? context : { ...context, format: 'module' });
+        // Svelte runes in js/ts, `.svelte.ts`
         const filename = fileURLToPath(url);
-        const source = loaded.source.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
-        const js_source = TS_MATCHER.test(url)
-            ? (await esbuild.transform(source, { ...ts_transform_options, sourcefile: url })).code // TODO @many use warnings? handle not-inline sourcemaps?
-            : source;
-        const transformed = compileModule(js_source, { ...svelte_compile_module_options, dev, filename });
+        const loaded = await nextLoad(url, { ...context, format: 'module-typescript' });
+        const raw_source = loaded.source?.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
+        if (raw_source == null)
+            throw new Error(`Failed to load ${url}`);
+        // TODO should be nice if we could use Node's builtin amaro transform, but I couldn't find a way after digging into the source, AFAICT it's internal and not exposed
+        const source = ts_blank_space(raw_source); // TODO was using oxc-transform and probably should, but this doesn't require sourcemaps, and it's still alpha as of May 2025
+        const transformed = compileModule(source, {
+            ...svelte_compile_module_options,
+            dev,
+            filename,
+        });
         return { format: 'module', shortCircuit: true, source: transformed.js.code };
     }
     else if (TS_MATCHER.test(url)) {
-        // ts
-        const loaded = await nextLoad(url, context.format === 'module' ? context : { ...context, format: 'module' });
-        const source = loaded.source.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
-        const transformed = await esbuild.transform(source, { ...ts_transform_options, sourcefile: url }); // TODO @many use warnings? handle not-inline sourcemaps?
-        return { format: 'module', shortCircuit: true, source: transformed.code };
+        // ts but not `.svelte.ts`
+        return nextLoad(url, { ...context, format: 'module-typescript' });
     }
     else if (SVELTE_MATCHER.test(url)) {
-        // Svelte
-        const loaded = await nextLoad(url, context.format === 'module' ? context : { ...context, format: 'module' });
+        // Svelte, `.svelte`
+        const loaded = await nextLoad(url, { ...context, format: 'module' });
         const raw_source = loaded.source.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
         const filename = fileURLToPath(url);
         const preprocessed = svelte_preprocessors // TODO @many use sourcemaps (and diagnostics?)
@@ -100,10 +96,13 @@ export const load = async (url, context, nextLoad) => {
         return { format: 'module', shortCircuit: true, source: transformed.js.code };
     }
     else if (JSON_MATCHER.test(url)) {
+        // TODO probably require import attrs: `JSON_MATCHER.test(url) && context.importAttributes.type === 'json'`
         // json
-        // TODO probably follow esbuild and also export every top-level property for objects from the module - https://esbuild.github.io/content-types/#json (type generation?)
-        const loaded = await nextLoad(url);
-        const raw_source = loaded.source.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
+        // TODO probably follow esbuild and also export every top-level property for objects from the module for good treeshaking - https://esbuild.github.io/content-types/#json (type generation?)
+        const loaded = await nextLoad(url, context);
+        const raw_source = loaded.source?.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
+        if (raw_source == null)
+            throw new Error(`Failed to load ${url}`);
         const source = `export default ` + raw_source;
         return { format: 'module', shortCircuit: true, source };
     }
@@ -115,17 +114,33 @@ export const load = async (url, context, nextLoad) => {
         return { format: 'module', shortCircuit: true, source };
     }
     else {
-        const matched_env = ENV_MATCHER.exec(url);
-        if (matched_env) {
-            // SvelteKit `$env`
-            const mode = matched_env[1];
-            const visibility = matched_env[2];
-            return {
-                format: 'module',
-                shortCircuit: true,
-                source: render_env_shim_module(dev, mode, visibility, public_prefix, private_prefix, env_dir),
-            };
-        }
+        // SvelteKit `$env`
+        // TODO use `format` from the resolve hook to speed this up and make it simpler
+        if (context.format === 'sveltekit-env') {
+            let mode;
+            let visibility;
+            if (context.importAttributes.virtual === '$env/static/public') {
+                mode = 'static';
+                visibility = 'public';
+            }
+            else if (context.importAttributes.virtual === '$env/static/private') {
+                mode = 'static';
+                visibility = 'private';
+            }
+            else if (context.importAttributes.virtual === '$env/dynamic/public') {
+                mode = 'dynamic';
+                visibility = 'public';
+            }
+            else if (context.importAttributes.virtual === '$env/dynamic/private') {
+                mode = 'dynamic';
+                visibility = 'private';
+            }
+            else {
+                throw new Error(`Unknown $env import: ${context.importAttributes.virtual}`);
+            }
+            const source = render_env_shim_module(dev, mode, visibility, public_prefix, private_prefix, env_dir);
+            return { format: 'module', shortCircuit: true, source };
+        } // else fallback
     }
     // fallback to default behavior
     return nextLoad(url, context);
@@ -141,7 +156,8 @@ export const resolve = async (specifier, context, nextResolve) => {
         // so we need a slightly roundabout strategy to pass through the specifier for virtual files.
         return {
             url: pathToFileURL(join(dir, 'src/lib', s)).href,
-            format: 'module',
+            format: 'sveltekit-env',
+            importAttributes: { virtual: s }, // TODO idk I'm just making this up
             shortCircuit: true,
         };
     }

package/dist/module.js

@@ -1,5 +1,5 @@
-import { LIB_DIRNAME } from './paths.js';
-import { SOURCE_DIR, SOURCE_DIRNAME } from './constants.js';
+import { LIB_DIRNAME } from "./paths.js";
+import { SOURCE_DIR, SOURCE_DIRNAME } from "./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,7 +1,7 @@
 import type { Timings } from '@ryanatkn/belt/timings.js';
 import type { Result } from '@ryanatkn/belt/result.js';
-import type { Resolved_Input_File } from './input_path.js';
-import type { Path_Id } from './path.js';
+import type { Resolved_Input_File } from './input_path.ts';
+import type { Path_Id } from './path.ts';
 export interface Module_Meta<T_Module extends Record<string, any> = Record<string, any>> {
     id: Path_Id;
     mod: T_Module;

package/dist/modules.js

@@ -1,10 +1,18 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { Unreachable_Error } from '@ryanatkn/belt/error.js';
 import { print_error } from '@ryanatkn/belt/print.js';
-import { print_path } from './paths.js';
+import { print_path } from "./paths.js";
 export const load_module = async (id, validate) => {
     let mod;
     try {
-        mod = await import(id);
+        mod = await import(__rewriteRelativeImportExtension(id, true));
     }
     catch (err) {
         return { ok: false, type: 'failed_import', id, error: err };

package/dist/package.d.ts

@@ -47,6 +47,7 @@ export declare const package_json: {
         'oxc-parser': string;
         prettier: string;
         'prettier-plugin-svelte': string;
+        'ts-blank-space': string;
         'ts-morph': string;
         tslib: string;
         zod: string;

package/dist/package.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuwBD,CAAC"}
+{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuwBD,CAAC"}

package/dist/package.gen.d.ts

@@ -1,4 +1,4 @@
-import type { Gen } from './gen.js';
+import type { Gen } from './gen.ts';
 /**
  * A convenience `gen` file that outputs `$lib/package.ts`,
  * which mirrors `package.json` but in TypeScript,

package/dist/package.gen.js

@@ -1,6 +1,6 @@
-import { load_package_json } from './package_json.js';
-import { IS_THIS_GRO } from './paths.js';
-import { create_src_json } from './src_json.js';
+import { load_package_json } from "./package_json.js";
+import { IS_THIS_GRO } 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 = ({ origin_path }) => {
     return `
 // generated by ${origin_path}
 
-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'}';
+import type {Package_Json} from '${IS_THIS_GRO ? './package_json.ts' : '@ryanatkn/gro/package_json.js'}';
+import type {Src_Json} from '${IS_THIS_GRO ? './src_json.ts' : '@ryanatkn/gro/src_json.js'}';
 
 export const package_json = ${JSON.stringify(package_json)} satisfies Package_Json;
 

package/dist/package.js

@@ -1,7 +1,7 @@
 // generated by src/lib/package.gen.ts
 export const package_json = {
     name: '@ryanatkn/gro',
-    version: '0.154.0',
+    version: '0.155.0',
     description: 'task runner and toolkit extending SvelteKit',
     motto: 'generate, run, optimize',
     glyph: '🌰',
@@ -25,7 +25,7 @@ export const package_json = {
         deploy: 'gro deploy',
     },
     type: 'module',
-    engines: { node: '>=22.11' },
+    engines: { node: '>=22.15' },
     bin: { gro: 'dist/gro.js' },
     keywords: [
         'web',
@@ -47,6 +47,7 @@ export const package_json = {
         'oxc-parser': '^0.67.0',
         prettier: '^3.5.3',
         'prettier-plugin-svelte': '^3.3.3',
+        'ts-blank-space': '^0.6.1',
         'ts-morph': '^25.0.1',
         tslib: '^2.8.1',
         zod: '^3.24.3',
@@ -56,7 +57,7 @@ export const package_json = {
         '@changesets/changelog-git': '^0.2.1',
         '@changesets/types': '^6.1.0',
         '@ryanatkn/eslint-config': '^0.8.0',
-        '@ryanatkn/fuz': '^0.140.0',
+        '@ryanatkn/fuz': '^0.141.1',
         '@ryanatkn/moss': '^0.28.0',
         '@sveltejs/adapter-static': '^3.0.8',
         '@sveltejs/kit': '^2.20.8',
@@ -72,7 +73,7 @@ export const package_json = {
         'typescript-eslint': '^8.31.1',
         uvu: '^0.5.6',
     },
-    optionalDependencies: { '@ryanatkn/moss': '^0.28.0' },
+    optionalDependencies: { '@ryanatkn/moss': '>=0.27.0 <0.29.0' },
     prettier: {
         plugins: ['prettier-plugin-svelte'],
         useTabs: true,
@@ -257,7 +258,7 @@ export const package_json = {
 };
 export const src_json = {
     name: '@ryanatkn/gro',
-    version: '0.154.0',
+    version: '0.155.0',
     modules: {
         '.': {
             path: 'index.ts',

package/dist/package_json.js

@@ -3,11 +3,11 @@ import { join } from 'node:path';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { count_graphemes, plural, strip_end } from '@ryanatkn/belt/string.js';
 import { styleText as st } from 'node:util';
-import { paths, gro_paths, IS_THIS_GRO, replace_extension } from './paths.js';
-import { SVELTEKIT_DIST_DIRNAME } from './constants.js';
-import { search_fs } from './search_fs.js';
-import { has_sveltekit_library } from './sveltekit_helpers.js';
-import { GITHUB_REPO_MATCHER } from './github.js';
+import { paths, gro_paths, IS_THIS_GRO, replace_extension } from "./paths.js";
+import { SVELTEKIT_DIST_DIRNAME } from "./constants.js";
+import { search_fs } from "./search_fs.js";
+import { has_sveltekit_library } from "./sveltekit_helpers.js";
+import { GITHUB_REPO_MATCHER } from "./github.js";
 // TODO @many belongs elsewhere
 export const Url = z.string();
 // TODO @many belongs elsewhere