@ryanatkn/gro 0.154.0 → 0.156.0

package/dist/gro_config.js

@@ -1,8 +1,16 @@
+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 { join, resolve } from 'node:path';
 import { existsSync } from 'node:fs';
-import { GRO_DIST_DIR, IS_THIS_GRO, paths } from './paths.js';
-import { GRO_CONFIG_PATH, JS_CLI_DEFAULT, NODE_MODULES_DIRNAME, PM_CLI_DEFAULT, SERVER_DIST_PATH, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_DIST_DIRNAME, } from './constants.js';
-import create_default_config from './gro.config.default.js';
+import { GRO_DIST_DIR, IS_THIS_GRO, paths } from "./paths.js";
+import { GRO_CONFIG_PATH, JS_CLI_DEFAULT, NODE_MODULES_DIRNAME, PM_CLI_DEFAULT, SERVER_DIST_PATH, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_DIST_DIRNAME, } from "./constants.js";
+import create_default_config from "./gro.config.default.js";
 export const create_empty_gro_config = () => ({
     plugins: () => [],
     map_package_json: default_map_package_json,
@@ -66,7 +74,7 @@ export const load_gro_config = async (dir = paths.root) => {
         return default_config;
     }
     // Import the user's `gro.config.ts`.
-    const config_module = await import(config_path);
+    const config_module = await import(__rewriteRelativeImportExtension(config_path, true));
     validate_gro_config_module(config_module, config_path);
     return normalize_gro_config(typeof config_module.default === 'function'
         ? await config_module.default(default_config)

package/dist/gro_helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gro_helpers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAQ,KAAK,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAUnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,uBAAuB,GAAI,aAAS,KAAG,MAsBnD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAC7B,aAAa,MAAM,EACnB,aAAa,MAAM,EACnB,MAAM,KAAK,CAAC,MAAM,CAAC,EACnB,eAAuB,KACrB,OAAO,CAAC,YAAY,CAiBtB,CAAC"}
+{"version":3,"file":"gro_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gro_helpers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAQ,KAAK,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAUnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,uBAAuB,GAAI,aAAS,KAAG,MAsBnD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAC7B,aAAa,MAAM,EACnB,aAAa,MAAM,EACnB,MAAM,KAAK,CAAC,MAAM,CAAC,EACnB,eAAuB,KACrB,OAAO,CAAC,YAAY,CAoBtB,CAAC"}

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,QA0GlB,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 { 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 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?)
@@ -99,11 +95,15 @@ export const load = async (url, context, nextLoad) => {
         const transformed = compile(source, { ...svelte_compile_options, dev, filename });
         return { format: 'module', shortCircuit: true, source: transformed.js.code };
     }
-    else if (JSON_MATCHER.test(url)) {
-        // 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
+    else if (context.importAttributes.type === 'json') {
+        // json - any file extension
+        // 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?)
+        // TODO why is removing the importAttributes needed? can't pass no context either -
+        //   error: `Module "file:///home/user/dev/repo/foo.json" is not of type "json"`
+        const loaded = await nextLoad(url, { ...context, importAttributes: undefined });
+        const raw_source = loaded.source?.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
+        if (raw_source == null)
+            throw Error(`Failed to load ${url}`);
         const source = `export default ` + raw_source;
         return { format: 'module', shortCircuit: true, source };
     }
@@ -115,16 +115,38 @@ 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;
+            switch (context.importAttributes.virtual) {
+                case '$env/static/public': {
+                    mode = 'static';
+                    visibility = 'public';
+                    break;
+                }
+                case '$env/static/private': {
+                    mode = 'static';
+                    visibility = 'private';
+                    break;
+                }
+                case '$env/dynamic/public': {
+                    mode = 'dynamic';
+                    visibility = 'public';
+                    break;
+                }
+                case '$env/dynamic/private': {
+                    mode = 'dynamic';
+                    visibility = 'private';
+                    break;
+                }
+                default: {
+                    throw 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 };
         }
     }
     // fallback to default behavior
@@ -141,7 +163,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAswBD,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;