@fuzdev/gro 0.192.0

package/dist/invoke.js

@@ -0,0 +1,28 @@
+import { attach_process_error_handler } from '@fuzdev/fuz_util/process.js';
+import { configure_print_colors } from '@fuzdev/fuz_util/print.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.
+Tasks are the CLI's primary concept.
+To learn more about them, see `src/docs/task.md`.
+
+When the CLI is invoked it passes the first CLI arg as `task_name` to `invoke_task`,
+and the rest of the args are forwarded to the task's `run` function.
+
+*/
+// handle uncaught errors
+attach_process_error_handler({
+    to_error_label: (err) => (err.constructor.name === 'TaskError' ? 'TaskError' : null),
+    map_error_text: (err) => (err.constructor.name === 'SilentError' ? '' : null),
+});
+if (!process.env.NO_COLOR) {
+    const { styleText } = await import('node:util');
+    configure_print_colors(styleText);
+}
+await sveltekit_sync_if_obviously_needed();
+const { task_name, args } = to_task_args();
+await invoke_task(task_name, args, await load_gro_config());

package/dist/invoke_task.d.ts

@@ -0,0 +1,30 @@
+import type { Args } from '@fuzdev/fuz_util/args.js';
+import { Logger } from '@fuzdev/fuz_util/log.js';
+import { Timings } from '@fuzdev/fuz_util/timings.js';
+import { RawInputPath } from './input_path.ts';
+import type { GroConfig } from './gro_config.ts';
+import { Filer } from './filer.ts';
+/**
+ * Invokes Gro tasks by name using the filesystem as the source.
+ *
+ * When a task is invoked,
+ * Gro first searches for tasks in the current working directory.
+ * and falls back to searching Gro's directory, if the two are different.
+ * See `src/lib/input_path.ts` for info about what "task_name" can refer to.
+ * If it matches a directory, all of the tasks within it are logged,
+ * both in the current working directory and Gro.
+ *
+ * This code is particularly hairy because
+ * we're accepting a wide range of user input
+ * and trying to do the right thing.
+ * Precise error messages are especially difficult and
+ * there are some subtle differences in the complex logical branches.
+ * The comments describe each condition.
+ *
+ * @param task_name - The name of the task to invoke.
+ * @param args - The CLI args to pass to the task.
+ * @param config - The Gro configuration.
+ * @param initial_timings - The timings to use for the top-level task, `null` for composed tasks.
+ */
+export declare const invoke_task: (task_name: RawInputPath, args: Args | undefined, config: GroConfig, initial_filer?: Filer, initial_timings?: Timings | null, parent_log?: Logger) => Promise<void>;
+//# sourceMappingURL=invoke_task.d.ts.map

package/dist/invoke_task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoke_task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/invoke_task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAE/C,OAAO,EAAmB,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAKtE,OAAO,EAAgB,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAI5D,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,WAAW,GACvB,WAAW,YAAY,EACvB,MAAM,IAAI,GAAG,SAAS,EACtB,QAAQ,SAAS,EACjB,gBAAgB,KAAK,EACrB,kBAAkB,OAAO,GAAG,IAAI,EAChC,aAAa,MAAM,KACjB,OAAO,CAAC,IAAI,CA8Fd,CAAC"}

package/dist/invoke_task.js

@@ -0,0 +1,104 @@
+import { Logger } from '@fuzdev/fuz_util/log.js';
+import { print_ms, print_timings } from '@fuzdev/fuz_util/print.js';
+import { create_stopwatch, Timings } from '@fuzdev/fuz_util/timings.js';
+import { styleText as st } from 'node:util';
+import { to_forwarded_args } from "./args.js";
+import { run_task } from "./run_task.js";
+import { to_input_path, RawInputPath } from "./input_path.js";
+import { find_tasks, load_tasks, SilentError } from "./task.js";
+import { package_json_load_for_gro } 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.
+ *
+ * When a task is invoked,
+ * Gro first searches for tasks in the current working directory.
+ * and falls back to searching Gro's directory, if the two are different.
+ * See `src/lib/input_path.ts` for info about what "task_name" can refer to.
+ * If it matches a directory, all of the tasks within it are logged,
+ * both in the current working directory and Gro.
+ *
+ * This code is particularly hairy because
+ * we're accepting a wide range of user input
+ * and trying to do the right thing.
+ * Precise error messages are especially difficult and
+ * there are some subtle differences in the complex logical branches.
+ * The comments describe each condition.
+ *
+ * @param task_name - The name of the task to invoke.
+ * @param args - The CLI args to pass to the task.
+ * @param config - The Gro configuration.
+ * @param initial_timings - The timings to use for the top-level task, `null` for composed tasks.
+ */
+export const invoke_task = async (task_name, args, config, initial_filer, initial_timings, parent_log) => {
+    // Create child logger if parent exists, otherwise root logger
+    const log_label = task_name || 'gro';
+    const log = parent_log ? parent_log.child(log_label) : new Logger(log_label);
+    log.info('invoking', task_name ? st('cyan', task_name) : 'gro');
+    // track if we created the filer
+    const owns_filer = !initial_filer;
+    const filer = initial_filer ?? new Filer({ log: log.child('filer'), ...config.filer_options });
+    const owns_timings = !initial_timings;
+    const timings = initial_timings ?? new Timings();
+    const total_timing = create_stopwatch();
+    const finish = async () => {
+        // cleanup filer only if we created it and it was initialized
+        if (owns_filer && filer.inited) {
+            await filer.close();
+        }
+        if (owns_timings)
+            return; // kinda weird, print timings only for the top-level task
+        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 package_json_load_for_gro();
+        log.info(`${st('gray', 'v')}${st('cyan', gro_package_json.version)}`);
+        await finish();
+        return;
+    }
+    // Resolve the input path for the provided task name.
+    const input_path = to_input_path(task_name);
+    const { task_root_dirs } = config;
+    // Find the task or directory specified by the `input_path`.
+    // Fall back to searching the Gro directory as well.
+    const found = await find_tasks([input_path], task_root_dirs, config);
+    if (!found.ok) {
+        log_error_reasons(log, found.reasons);
+        throw new SilentError();
+    }
+    // Found a match either in the current working directory or Gro's directory.
+    const found_tasks = found.value;
+    const { resolved_input_files } = found_tasks;
+    // Load the task module.
+    const loaded = await load_tasks(found_tasks);
+    if (!loaded.ok) {
+        log_error_reasons(log, loaded.reasons);
+        throw new SilentError();
+    }
+    const loaded_tasks = loaded.value;
+    if (resolved_input_files.length > 1 ||
+        resolved_input_files[0].resolved_input_path.is_directory) {
+        // The input path matches a directory. Log the tasks but don't run them.
+        log_tasks(log, loaded_tasks);
+        await finish();
+        return;
+    }
+    // The input path matches a file that's presumable a task, so load and run it.
+    if (loaded_tasks.modules.length !== 1)
+        throw Error('expected one loaded task'); // run only one task at a time
+    const task = loaded_tasks.modules[0];
+    log.info(`→ ${st('cyan', task.name)} ${(task.mod.task.summary && st('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, filer, log, timings);
+    timing_to_run_task();
+    if (!result.ok) {
+        log.info(`${st('red', '🞩')} ${st('cyan', task.name)}`);
+        log_error_reasons(log, [result.reason]);
+        throw result.error;
+    }
+    log.info(`✓ ${st('cyan', task.name)}`);
+    await finish();
+};

package/dist/lint.task.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { type Task } from './task.ts';
+/** @nodocs */
+export declare const Args: z.ZodObject<{
+    _: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    eslint_cli: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=lint.task.d.ts.map

package/dist/lint.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/lint.task.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,OAAO,EAAY,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAI/C,cAAc;AACd,eAAO,MAAM,IAAI;;;kBAGf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAoB3B,CAAC"}

package/dist/lint.task.js

@@ -0,0 +1,32 @@
+import { args_serialize } from '@fuzdev/fuz_util/args.js';
+import { print_spawn_result } from '@fuzdev/fuz_util/process.js';
+import { z } from 'zod';
+import { to_forwarded_args } from "./args.js";
+import { find_cli, spawn_cli } from "./cli.js";
+import { TaskError } from "./task.js";
+const ESLINT_CLI = 'eslint';
+/** @nodocs */
+export const Args = z.strictObject({
+    _: z.array(z.string()).meta({ description: 'paths to serve' }).default([]),
+    eslint_cli: z.string().meta({ description: 'the ESLint CLI to use' }).default(ESLINT_CLI),
+});
+/** @nodocs */
+export const task = {
+    summary: 'run eslint',
+    Args,
+    run: async ({ log, args }) => {
+        const { _, eslint_cli } = args;
+        const found_eslint_cli = await find_cli(eslint_cli);
+        if (!found_eslint_cli) {
+            // TODO maybe make this an option?
+            log.info('ESLint is not installed; skipping linting');
+            return;
+        }
+        const forwarded_args = { _, 'max-warnings': 0, ...to_forwarded_args(eslint_cli) };
+        const serialized_args = args_serialize(forwarded_args);
+        const eslintResult = await spawn_cli(found_eslint_cli, serialized_args, log);
+        if (!eslintResult?.ok) {
+            throw new TaskError(`ESLint found some problems. ${print_spawn_result(eslintResult)}`);
+        }
+    },
+};

package/dist/loader.d.ts

@@ -0,0 +1,6 @@
+import type { LoadHook, ResolveHook } from 'node:module';
+/** @nodocs */
+export declare const load: LoadHook;
+/** @nodocs */
+export declare const resolve: ResolveHook;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"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;AAoEvD,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,QA0GlB,CAAC;AAEF,cAAc;AACd,eAAO,MAAM,OAAO,EAAE,WA+CrB,CAAC"}

package/dist/loader.js

@@ -0,0 +1,192 @@
+import { compile, compileModule, preprocess } from 'svelte/compiler';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { dirname, join } from 'node:path';
+import { readFileSync } from 'node:fs';
+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 { paths } from "./paths.js";
+import { TS_MATCHER, SVELTE_MATCHER, SVELTE_RUNES_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
+/*
+
+Usage via `$lib/register.ts`:
+
+```bash
+node --import @fuzdev/gro/register.js foo.ts
+```
+
+Usage via `$lib/run.task.ts`:
+
+```bash
+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("@fuzdev/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`
+
+*/
+// TODO sourcemaps for the svelte preprocessors
+// TODO `import.meta.resolve` wasn't available in loaders when this was first implemented, but might be 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, } = default_svelte_config;
+const aliases = Object.entries(alias);
+const RAW_MATCHER = /(%3Fraw|\.css|\.svg)$/; // TODO others? configurable?
+/** @nodocs */
+export const load = async (url, context, nextLoad) => {
+    // console.log(`url`, url);
+    if (SVELTEKIT_SHIM_APP_PATHS_MATCHER.test(url)) {
+        // SvelteKit `$app/paths` shim
+        return {
+            format: 'module',
+            shortCircuit: true,
+            source: render_sveltekit_shim_app_paths(base_url, assets_url),
+        };
+    }
+    else if (SVELTEKIT_SHIM_APP_ENVIRONMENT_MATCHER.test(url)) {
+        // SvelteKit `$app/environment` shim
+        return {
+            format: 'module',
+            shortCircuit: true,
+            source: render_sveltekit_shim_app_environment(dev),
+        };
+    }
+    else if (SVELTE_RUNES_MATCHER.test(url)) {
+        // Svelte runes in js/ts, `.svelte.ts`
+        const filename = fileURLToPath(url);
+        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 but not `.svelte.ts`
+        return nextLoad(url, { ...context, format: 'module-typescript' });
+    }
+    else if (SVELTE_MATCHER.test(url)) {
+        // 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?)
+            ? await preprocess(raw_source, svelte_preprocessors, { filename })
+            : null;
+        const source = preprocessed?.code ?? raw_source;
+        const transformed = compile(source, { ...svelte_compile_options, dev, filename });
+        return { format: 'module', shortCircuit: true, source: transformed.js.code };
+    }
+    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 };
+    }
+    else if (RAW_MATCHER.test(url)) {
+        // raw text imports like `?raw`, `.css`, `.svg`
+        const filename = fileURLToPath(url.endsWith('%3Fraw') ? url.substring(0, url.length - 6) : url);
+        const raw_source = readFileSync(filename, 'utf8');
+        const source = 'export default `' + raw_source.replaceAll('\\', '\\\\').replaceAll('`', '\\`') + '`;';
+        return { format: 'module', shortCircuit: true, source };
+    }
+    else {
+        // 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
+    return nextLoad(url, context);
+};
+/** @nodocs */
+export const resolve = async (specifier, context, nextResolve) => {
+    let s = specifier;
+    // Support SvelteKit `$env` imports
+    if (s === '$env/static/public' ||
+        s === '$env/static/private' ||
+        s === '$env/dynamic/public' ||
+        s === '$env/dynamic/private') {
+        // The returned `url` is validated before `load` is called,
+        // 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: 'sveltekit-env',
+            importAttributes: { virtual: s }, // TODO idk I'm just making this up
+            shortCircuit: true,
+        };
+    }
+    // Support SvelteKit `$app` imports, including from node_modules
+    const shimmed = sveltekit_shim_app_specifiers.get(s);
+    if (shimmed !== undefined) {
+        return nextResolve(shimmed, context);
+    }
+    // Apply SvelteKit aliases (handles self-referencing packages like @fuzdev/fuz_util -> src/lib)
+    s = map_sveltekit_aliases(s, aliases);
+    // Bare specifiers (not starting with . or /) use Node's default resolution
+    if (s[0] !== '.' && s[0] !== '/') {
+        return nextResolve(s, context);
+    }
+    // Resolve paths using Vite conventions
+    const parent_url = context.parentURL;
+    if (!parent_url) {
+        return nextResolve(s, context);
+    }
+    const resolved = await resolve_specifier(s, dirname(fileURLToPath(parent_url)));
+    return {
+        url: pathToFileURL(resolved.path_id_with_querystring).href,
+        format: 'module',
+        shortCircuit: true,
+    };
+};

package/dist/module.d.ts

@@ -0,0 +1,4 @@
+export declare const MODULE_PATH_SRC_PREFIX: string;
+export declare const MODULE_PATH_LIB_PREFIX: string;
+export declare const is_external_module: (module_name: string) => boolean;
+//# sourceMappingURL=module.d.ts.map

package/dist/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/module.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,sBAAsB,QAAa,CAAC;AACjD,eAAO,MAAM,sBAAsB,QAAqB,CAAC;AAOzD,eAAO,MAAM,kBAAkB,GAAI,aAAa,MAAM,KAAG,OACd,CAAC"}

package/dist/module.js

@@ -0,0 +1,6 @@
+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');
+export const is_external_module = (module_name) => !INTERNAL_MODULE_MATCHER.test(module_name);

package/dist/modules.d.ts

@@ -0,0 +1,36 @@
+import type { Timings } from '@fuzdev/fuz_util/timings.js';
+import type { Result } from '@fuzdev/fuz_util/result.js';
+import type { PathId } from '@fuzdev/fuz_util/path.js';
+import type { ResolvedInputFile } from './input_path.ts';
+export interface ModuleMeta<TModule extends Record<string, any> = Record<string, any>> {
+    id: PathId;
+    mod: TModule;
+}
+export type LoadModuleResult<TModule> = Result<{
+    id: PathId;
+    mod: TModule;
+}, LoadModuleFailure>;
+export type LoadModuleFailure = {
+    ok: false;
+    type: 'failed_import';
+    id: PathId;
+    error: Error;
+} | {
+    ok: false;
+    type: 'failed_validation';
+    id: PathId;
+    mod: Record<string, any>;
+    validation: string;
+};
+export declare const load_module: <TModule extends Record<string, any>>(id: PathId, validate?: (mod: Record<string, any>) => mod is TModule, bust_cache?: boolean) => Promise<LoadModuleResult<TModule>>;
+export interface LoadModulesFailure<TModuleMeta extends ModuleMeta> {
+    type: 'load_module_failures';
+    load_module_failures: Array<LoadModuleFailure>;
+    reasons: Array<string>;
+    modules: Array<TModuleMeta>;
+}
+export type LoadModulesResult<TModuleMeta extends ModuleMeta> = Result<{
+    modules: Array<TModuleMeta>;
+}, LoadModulesFailure<TModuleMeta>>;
+export declare const load_modules: <TModule extends Record<string, any>, TModuleMeta extends ModuleMeta<TModule>>(resolved_input_files: Array<ResolvedInputFile>, validate: (mod: any) => mod is TModule, map_module_meta: (resolved_input_file: ResolvedInputFile, mod: TModule) => TModuleMeta, timings?: Timings) => Promise<LoadModulesResult<TModuleMeta>>;
+//# sourceMappingURL=modules.d.ts.map

package/dist/modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAEzD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,4BAA4B,CAAC;AAGvD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAErD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AAGvD,MAAM,WAAW,UAAU,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IACpF,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,OAAO,CAAC;CACb;AAED,MAAM,MAAM,gBAAgB,CAAC,OAAO,IAAI,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAC,EAAE,iBAAiB,CAAC,CAAC;AAC9F,MAAM,MAAM,iBAAiB,GAC1B;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,eAAe,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAC,GAC5D;IACA,EAAE,EAAE,KAAK,CAAC;IACV,IAAI,EAAE,mBAAmB,CAAC;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CAClB,CAAC;AAEL,eAAO,MAAM,WAAW,GAAU,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACpE,IAAI,MAAM,EACV,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,GAAG,IAAI,OAAO,EACvD,aAAa,OAAO,KAClB,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAiBnC,CAAC;AAEF,MAAM,WAAW,kBAAkB,CAAC,WAAW,SAAS,UAAU;IACjE,IAAI,EAAE,sBAAsB,CAAC;IAC7B,oBAAoB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAC/C,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAEvB,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;CAC5B;AAED,MAAM,MAAM,iBAAiB,CAAC,WAAW,SAAS,UAAU,IAAI,MAAM,CACrE;IACC,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;CAC5B,EACD,kBAAkB,CAAC,WAAW,CAAC,CAC/B,CAAC;AAGF,eAAO,MAAM,YAAY,GACxB,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACnC,WAAW,SAAS,UAAU,CAAC,OAAO,CAAC,EAEvC,sBAAsB,KAAK,CAAC,iBAAiB,CAAC,EAC9C,UAAU,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,IAAI,OAAO,EACtC,iBAAiB,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,GAAG,EAAE,OAAO,KAAK,WAAW,EACtF,UAAU,OAAO,KACf,OAAO,CAAC,iBAAiB,CAAC,WAAW,CAAC,CA2CxC,CAAC"}

package/dist/modules.js

@@ -0,0 +1,71 @@
+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 { UnreachableError } from '@fuzdev/fuz_util/error.js';
+import { print_error } from '@fuzdev/fuz_util/print.js';
+import { pathToFileURL } from 'node:url';
+import { print_path } from "./paths.js";
+export const load_module = async (id, validate, bust_cache) => {
+    let mod;
+    try {
+        let import_path = id;
+        if (bust_cache) {
+            const url = pathToFileURL(id);
+            url.searchParams.set('t', Date.now().toString());
+            import_path = url.href;
+        }
+        mod = await import(__rewriteRelativeImportExtension(import_path, true));
+    }
+    catch (error) {
+        return { ok: false, type: 'failed_import', id, error };
+    }
+    if (validate && !validate(mod)) {
+        return { ok: false, type: 'failed_validation', id, mod, validation: validate.name };
+    }
+    return { ok: true, id, mod };
+};
+// TODO parallelize and sort afterwards
+export const load_modules = async (resolved_input_files, validate, map_module_meta, timings) => {
+    const timing_to_load_modules = timings?.start('load modules');
+    const modules = [];
+    const load_module_failures = [];
+    const reasons = [];
+    for (const resolved_input_file of resolved_input_files.values()) {
+        const { id, input_path } = resolved_input_file;
+        const result = await load_module(id, validate); // eslint-disable-line no-await-in-loop
+        if (result.ok) {
+            modules.push(map_module_meta(resolved_input_file, result.mod));
+        }
+        else {
+            load_module_failures.push(result);
+            switch (result.type) {
+                case 'failed_import': {
+                    reasons.push(`Module import ${print_path(id)} failed from input ${print_path(input_path)}: ${print_error(result.error)}`);
+                    break;
+                }
+                case 'failed_validation': {
+                    reasons.push(`Module ${print_path(id)} failed validation '${result.validation}'.`);
+                    break;
+                }
+                default:
+                    throw new UnreachableError(result);
+            }
+        }
+    }
+    timing_to_load_modules?.();
+    if (load_module_failures.length) {
+        return {
+            ok: false,
+            type: 'load_module_failures',
+            load_module_failures,
+            reasons,
+            modules,
+        };
+    }
+    return { ok: true, modules };
+};

package/dist/package_json.d.ts

@@ -0,0 +1,32 @@
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import { PackageJson, PackageJsonExports } from '@fuzdev/fuz_util/package_json.js';
+export type PackageJsonMapper = (package_json: PackageJson) => PackageJson | null | Promise<PackageJson | null>;
+export declare const PACKAGE_JSON_EMPTY: PackageJson;
+export declare const package_json_load: (dir?: string, cache?: Record<string, PackageJson>, parse?: boolean, // TODO pass `false` here in more places, especially anything perf-sensitive like work on startup
+log?: Logger) => Promise<PackageJson>;
+export declare const package_json_sync: (map_package_json: PackageJsonMapper, log: Logger, write?: boolean, dir?: string, exports_dir?: string) => Promise<{
+    package_json: PackageJson | null;
+    changed: boolean;
+}>;
+export declare const package_json_load_for_gro: () => Promise<PackageJson>;
+export declare const package_json_write: (serialized_package_json: string) => Promise<void>;
+export declare const package_json_serialize: (package_json: PackageJson) => string;
+/**
+ * Updates package.json. Writes to the filesystem only when contents change.
+ */
+export declare const package_json_update: (update: (package_json: PackageJson) => PackageJson | null | Promise<PackageJson | null>, dir?: string, write?: boolean) => Promise<{
+    package_json: PackageJson | null;
+    changed: boolean;
+}>;
+export declare const package_json_to_exports: (paths: Array<string>) => PackageJsonExports;
+export declare const package_json_parse_repo_url: (package_json: PackageJson) => {
+    owner: string;
+    repo: string;
+} | undefined;
+export declare const package_json_has_dependency: (dep_name: string, package_json: PackageJson) => boolean;
+export interface PackageJsonDep {
+    name: string;
+    version: string;
+}
+export declare const package_json_extract_dependencies: (package_json: PackageJson) => Array<PackageJsonDep>;
+//# sourceMappingURL=package_json.d.ts.map

package/dist/package_json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package_json.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/package_json.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAEpD,OAAO,EAAC,WAAW,EAAE,kBAAkB,EAAC,MAAM,kCAAkC,CAAC;AAgBjF,MAAM,MAAM,iBAAiB,GAAG,CAC/B,YAAY,EAAE,WAAW,KACrB,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;AAEtD,eAAO,MAAM,kBAAkB,EAAE,WAAqC,CAAC;AAEvE,eAAO,MAAM,iBAAiB,GAC7B,YAA+C,EAC/C,QAAQ,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EACnC,eAAY,EAAE,iGAAiG;AAC/G,MAAM,MAAM,KACV,OAAO,CAAC,WAAW,CAkBrB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC7B,kBAAkB,iBAAiB,EACnC,KAAK,MAAM,EACX,eAAY,EACZ,YAAgB,EAChB,oBAAuB,KACrB,OAAO,CAAC;IAAC,YAAY,EAAE,WAAW,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,CA0B9D,CAAC;AAEF,eAAO,MAAM,yBAAyB,QAAO,OAAO,CAAC,WAAW,CAC9B,CAAC;AAMnC,eAAO,MAAM,kBAAkB,GAAI,yBAAyB,MAAM,KAAG,OAAO,CAAC,IAAI,CACL,CAAC;AAE7E,eAAO,MAAM,sBAAsB,GAAI,cAAc,WAAW,KAAG,MACW,CAAC;AAE/E;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAC/B,QAAQ,CAAC,YAAY,EAAE,WAAW,KAAK,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,EACvF,YAAgB,EAChB,eAAY,KACV,OAAO,CAAC;IAAC,YAAY,EAAE,WAAW,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,CAa9D,CAAC;AAIF,eAAO,MAAM,uBAAuB,GAAI,OAAO,KAAK,CAAC,MAAM,CAAC,KAAG,kBAmD9D,CAAC;AAIF,eAAO,MAAM,2BAA2B,GACvC,cAAc,WAAW,KACvB;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAG,SAgBlC,CAAC;AA8BF,eAAO,MAAM,2BAA2B,GAAI,UAAU,MAAM,EAAE,cAAc,WAAW,KAAG,OAG9C,CAAC;AAE7C,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,iCAAiC,GAC7C,cAAc,WAAW,KACvB,KAAK,CAAC,cAAc,CAetB,CAAC"}