@fuzdev/gro 0.192.0

package/dist/github.d.ts

@@ -0,0 +1,19 @@
+import { FetchValueCache } from '@fuzdev/fuz_util/fetch.js';
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import { z } from 'zod';
+export declare const GITHUB_REPO_MATCHER: RegExp;
+export declare const GithubPullRequest: z.ZodObject<{
+    url: z.ZodString;
+    id: z.ZodNumber;
+    html_url: z.ZodString;
+    number: z.ZodNumber;
+    user: z.ZodObject<{
+        login: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type GithubPullRequest = z.infer<typeof GithubPullRequest>;
+/**
+ * @see https://docs.github.com/en/rest/commits/commits?apiVersion=2022-11-28#list-pull-requests-associated-with-a-commit
+ */
+export declare const github_fetch_commit_prs: (owner: string, repo: string, commit_sha: string, token?: string, log?: Logger, cache?: FetchValueCache, api_version?: string) => Promise<Array<GithubPullRequest> | null>;
+//# sourceMappingURL=github.d.ts.map

package/dist/github.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/github.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,eAAe,EAAc,MAAM,2BAA2B,CAAC;AACvE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,mBAAmB,QAA6B,CAAC;AAE9D,eAAO,MAAM,iBAAiB;;;;;;;;iBAQ5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,uBAAuB,GACnC,OAAO,MAAM,EACb,MAAM,MAAM,EACZ,YAAY,MAAM,EAClB,QAAQ,MAAM,EACd,MAAM,MAAM,EACZ,QAAQ,eAAe,EACvB,cAAc,MAAM,KAClB,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAazC,CAAC"}

package/dist/github.js

@@ -0,0 +1,33 @@
+// TODO if this grows at all, use `@octokit/request`,
+// for now it's just calling a single endpoint so we do it manually
+// and we specify just the types we need
+import { FetchValueCache, fetch_value } from '@fuzdev/fuz_util/fetch.js';
+import { z } from 'zod';
+export const GITHUB_REPO_MATCHER = /.+github.com\/(.+)\/(.+)/;
+export const GithubPullRequest = z.looseObject({
+    url: z.string(),
+    id: z.number(),
+    html_url: z.string(),
+    number: z.number(),
+    user: z.looseObject({
+        login: z.string(),
+    }),
+});
+/**
+ * @see https://docs.github.com/en/rest/commits/commits?apiVersion=2022-11-28#list-pull-requests-associated-with-a-commit
+ */
+export const github_fetch_commit_prs = async (owner, repo, commit_sha, token, log, cache, api_version) => {
+    const headers = api_version ? new Headers({ 'x-github-api-version': api_version }) : undefined;
+    const url = `https://api.github.com/repos/${owner}/${repo}/commits/${commit_sha}/pulls`;
+    const fetched = await fetch_value(url, {
+        request: { headers },
+        parse: (v) => v.map((p) => GithubPullRequest.parse(p)),
+        token,
+        cache,
+        return_early_from_cache: true,
+        log,
+    });
+    if (!fetched.ok)
+        return null;
+    return fetched.value;
+};

package/dist/gro.config.default.d.ts

@@ -0,0 +1,13 @@
+import type { CreateGroConfig } from './gro_config.ts';
+/**
+ * This is the default config that's passed to `gro.config.ts`
+ * if it exists in the current project, and if not, this is the final config.
+ * It looks at the SvelteKit config and filesystem and tries to do the right thing:
+ *
+ * - if `src/routes`, assumes a SvelteKit frontend - respects `KitConfig.kit.files.routes`
+ * - if `src/lib`, assumes a Node library - respects `KitConfig.kit.files.lib`
+ * - if `src/lib/server/server.ts`, assumes a Node server - needs config
+ */
+declare const config: CreateGroConfig;
+export default config;
+//# sourceMappingURL=gro.config.default.d.ts.map

package/dist/gro.config.default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gro.config.default.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gro.config.default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAC;AAUrD;;;;;;;;GAQG;AACH,QAAA,MAAM,MAAM,EAAE,eAoBb,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/gro.config.default.js

@@ -0,0 +1,33 @@
+import { gro_plugin_sveltekit_library } from "./gro_plugin_sveltekit_library.js";
+import { has_server, gro_plugin_server } from "./gro_plugin_server.js";
+import { gro_plugin_sveltekit_app } from "./gro_plugin_sveltekit_app.js";
+import { has_sveltekit_app, has_sveltekit_library } from "./sveltekit_helpers.js";
+import { gro_plugin_gen } from "./gro_plugin_gen.js";
+import { package_json_load } from "./package_json.js";
+// TODO hacky, maybe extract utils?
+/**
+ * This is the default config that's passed to `gro.config.ts`
+ * if it exists in the current project, and if not, this is the final config.
+ * It looks at the SvelteKit config and filesystem and tries to do the right thing:
+ *
+ * - if `src/routes`, assumes a SvelteKit frontend - respects `KitConfig.kit.files.routes`
+ * - if `src/lib`, assumes a Node library - respects `KitConfig.kit.files.lib`
+ * - if `src/lib/server/server.ts`, assumes a Node server - needs config
+ */
+const config = async (cfg, svelte_config) => {
+    const package_json = await package_json_load(); // TODO gets wastefully loaded by some plugins, maybe put in plugin/task context? how does that interact with `map_package_json`?
+    const [has_server_result, has_sveltekit_library_result, has_sveltekit_app_result] = await Promise.all([
+        has_server(),
+        has_sveltekit_library(package_json, svelte_config),
+        has_sveltekit_app(),
+    ]);
+    // put things that generate files before SvelteKit so it can see them
+    cfg.plugins = () => [
+        gro_plugin_gen(),
+        has_server_result.ok ? gro_plugin_server() : null,
+        has_sveltekit_library_result.ok ? gro_plugin_sveltekit_library() : null,
+        has_sveltekit_app_result.ok ? gro_plugin_sveltekit_app() : null,
+    ].filter((v) => v !== null);
+    return cfg;
+};
+export default config;

package/dist/gro.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env -S node --experimental-import-meta-resolve --experimental-strip-types --disable-warning=ExperimentalWarning
+export {};
+//# sourceMappingURL=gro.d.ts.map

package/dist/gro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gro.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gro.ts"],"names":[],"mappings":""}

package/dist/gro.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env -S node --experimental-import-meta-resolve --experimental-strip-types --disable-warning=ExperimentalWarning
+// @sync Node options to `$lib/gro_helpers.ts`
+import { join } from 'node:path';
+import { spawn_result_is_exited } from '@fuzdev/fuz_util/process.js';
+import { resolve_gro_module_path, spawn_with_loader } from "./gro_helpers.js";
+/*
+
+This file is a loader for the Gro CLI.
+Its only purpose is to import the `invoke.js` script in the correct directory.
+By using `resolve_gro_module_path` it lets the global Gro CLI defer
+to a local installation of Gro if one is available,
+and it also provides special handling for the case
+where we're running Gro inside Gro's own repo for development.
+
+*/
+const invoke_path = resolve_gro_module_path('invoke.js');
+const loader_path = join(invoke_path, '../loader.js');
+const spawned = await spawn_with_loader(loader_path, invoke_path, process.argv.slice(2));
+if (!spawned.ok) {
+    process.exitCode = spawn_result_is_exited(spawned) ? spawned.code : 1;
+}

package/dist/gro_config.d.ts

@@ -0,0 +1,115 @@
+import type { PathFilter, PathId } from '@fuzdev/fuz_util/path.js';
+import type { PluginsCreateConfig } from './plugin.ts';
+import type { PackageJsonMapper } from './package_json.ts';
+import type { ParsedSvelteConfig } from './svelte_config.ts';
+import type { FilerOptions } from './filer.ts';
+/**
+ * SHA-256 hash of empty string, used for configs without build_cache_config.
+ * This ensures consistent cache behavior when no custom config is provided.
+ */
+export declare const EMPTY_BUILD_CACHE_CONFIG_HASH = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+/**
+ * The config that users can extend via `gro.config.ts`.
+ * This is exposed to users in places like tasks and genfiles.
+ * @see https://github.com/fuzdev/gro/blob/main/src/docs/config.md
+ */
+export interface GroConfig extends RawGroConfig {
+    /**
+     * @see https://github.com/fuzdev/gro/blob/main/src/docs/plugin.md
+     */
+    plugins: PluginsCreateConfig;
+    /**
+     * Maps the project's `package.json` before writing it to the filesystem.
+     * The `package_json` argument may be mutated, but the return value is what's used by the caller.
+     * Returning `null` is a no-op for the caller.
+     */
+    map_package_json: PackageJsonMapper | null;
+    /**
+     * The root directories to search for tasks given implicit relative input paths.
+     * Defaults to `./src/lib`, then the cwd, then the Gro package dist.
+     */
+    task_root_dirs: Array<PathId>;
+    /**
+     * When searching the filsystem for tasks and genfiles,
+     * directories and files are included if they pass all of these filters.
+     */
+    search_filters: Array<PathFilter>;
+    /**
+     * The CLI to use that's compatible with `node`.
+     */
+    js_cli: string;
+    /**
+     * The CLI to use that's compatible with `npm install` and `npm link`. Defaults to `'npm'`.
+     */
+    pm_cli: string;
+    /** @default SVELTE_CONFIG_FILENAME */
+    svelte_config_filename?: string;
+    /**
+     * SHA-256 hash of the user's `build_cache_config` from `gro.config.ts`.
+     * This is computed during config normalization and the raw value is immediately deleted.
+     * If no `build_cache_config` was provided, this is the hash of an empty string.
+     * @see RawGroConfig.build_cache_config
+     */
+    build_cache_config_hash: string;
+    /**
+     * Options passed to the `Filer` for file watching and import resolution.
+     * @see FilerOptions
+     */
+    filer_options: Partial<FilerOptions> | null;
+}
+/**
+ * The relaxed variant of `GroConfig` that users can provide via `gro.config.ts`.
+ * Superset of `GroConfig`.
+ * @see https://github.com/fuzdev/gro/blob/main/src/docs/config.md
+ */
+export interface RawGroConfig {
+    plugins?: PluginsCreateConfig;
+    map_package_json?: PackageJsonMapper | null;
+    task_root_dirs?: Array<string>;
+    search_filters?: PathFilter | Array<PathFilter> | null;
+    js_cli?: string;
+    pm_cli?: string;
+    /**
+     * Optional object defining custom build inputs for cache invalidation.
+     * This value is hashed during config normalization and used to detect
+     * when builds need to be regenerated due to non-source changes.
+     *
+     * Use cases:
+     * - Environment variables baked into build: `{api_url: process.env.PUBLIC_API_URL}`
+     * - External data files: `{data: fs.readFileSync('data.json', 'utf-8')}`
+     * - Build feature flags: `{enable_analytics: true}`
+     *
+     * Can be a static object or an async function that returns an object.
+     *
+     * IMPORTANT: It's safe to include secrets here because they are hashed and `delete`d
+     * during config normalization. The raw value is never logged or persisted.
+     */
+    build_cache_config?: Record<string, unknown> | (() => Record<string, unknown> | Promise<Record<string, unknown>>);
+    /**
+     * Options passed to the `Filer` for file watching and import resolution.
+     * @see FilerOptions
+     */
+    filer_options?: Partial<FilerOptions> | null;
+}
+export type CreateGroConfig = (base_config: GroConfig, svelte_config?: ParsedSvelteConfig) => RawGroConfig | Promise<RawGroConfig>;
+export declare const create_empty_gro_config: () => GroConfig;
+/**
+ * The regexp used by default to exclude directories and files
+ * when searching the filesystem for tasks and genfiles.
+ * Customize via `search_filters` in the `GroConfig`.
+ * See the test cases for the exact behavior.
+ */
+export declare const SEARCH_EXCLUDER_DEFAULT: RegExp;
+export declare const EXPORTS_EXCLUDER_DEFAULT: RegExp;
+/**
+ * Transforms a `RawGroConfig` to the more strict `GroConfig`.
+ * This allows users to provide a more relaxed config.
+ * Hashes the `build_cache_config` and deletes the raw value for security.
+ */
+export declare const cook_gro_config: (raw_config: RawGroConfig) => Promise<GroConfig>;
+export interface GroConfigModule {
+    readonly default: RawGroConfig | CreateGroConfig;
+}
+export declare const load_gro_config: (dir?: string) => Promise<GroConfig>;
+export declare const validate_gro_config_module: (config_module: any, config_path: string) => asserts config_module is GroConfigModule;
+//# sourceMappingURL=gro_config.d.ts.map

package/dist/gro_config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gro_config.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gro_config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,UAAU,EAAE,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAejE,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,YAAY,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,6BAA6B,qEACyB,CAAC;AAEpE;;;;GAIG;AACH,MAAM,WAAW,SAAU,SAAQ,YAAY;IAC9C;;OAEG;IACH,OAAO,EAAE,mBAAmB,CAAC;IAC7B;;;;OAIG;IACH,gBAAgB,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC3C;;;OAGG;IACH,cAAc,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC9B;;;OAGG;IACH,cAAc,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IAClC;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;OAKG;IACH,uBAAuB,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,aAAa,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;CAC5C;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B,gBAAgB,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC5C,cAAc,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC/B,cAAc,CAAC,EAAE,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IACvD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;OAcG;IACH,kBAAkB,CAAC,EAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvB,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACtE;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;CAC7C;AAED,MAAM,MAAM,eAAe,GAAG,CAC7B,WAAW,EAAE,SAAS,EACtB,aAAa,CAAC,EAAE,kBAAkB,KAC9B,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAE1C,eAAO,MAAM,uBAAuB,QAAO,SAczC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,QAYnC,CAAC;AAEF,eAAO,MAAM,wBAAwB,QAA+C,CAAC;AAErF;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAU,YAAY,YAAY,KAAG,OAAO,CAAC,SAAS,CA+CjF,CAAC;AAEF,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,eAAe,CAAC;CACjD;AAED,eAAO,MAAM,eAAe,GAAU,YAAgB,KAAG,OAAO,CAAC,SAAS,CAqBzE,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,CACxC,aAAa,EAAE,GAAG,EAClB,WAAW,EAAE,MAAM,KACf,OAAO,CAAC,aAAa,IAAI,eAS7B,CAAC"}

package/dist/gro_config.js

@@ -0,0 +1,114 @@
+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 { fs_exists } from '@fuzdev/fuz_util/fs.js';
+import { identity } from '@fuzdev/fuz_util/function.js';
+import { json_stringify_deterministic } from '@fuzdev/fuz_util/json.js';
+import { hash_secure } from '@fuzdev/fuz_util/hash.js';
+import { GRO_DIST_DIR, IS_THIS_GRO, paths } from "./paths.js";
+import { GRO_CONFIG_FILENAME, 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";
+/**
+ * SHA-256 hash of empty string, used for configs without build_cache_config.
+ * This ensures consistent cache behavior when no custom config is provided.
+ */
+export const EMPTY_BUILD_CACHE_CONFIG_HASH = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';
+export const create_empty_gro_config = () => ({
+    plugins: () => [],
+    map_package_json: identity,
+    task_root_dirs: [
+        // TODO maybe disable if no SvelteKit `lib` directory? or other detection to improve defaults
+        paths.lib,
+        IS_THIS_GRO ? null : paths.root,
+        IS_THIS_GRO ? null : GRO_DIST_DIR,
+    ].filter((v) => v !== null),
+    search_filters: [(id) => !SEARCH_EXCLUDER_DEFAULT.test(id)],
+    js_cli: JS_CLI_DEFAULT,
+    pm_cli: PM_CLI_DEFAULT,
+    build_cache_config_hash: EMPTY_BUILD_CACHE_CONFIG_HASH,
+    filer_options: null,
+});
+/**
+ * The regexp used by default to exclude directories and files
+ * when searching the filesystem for tasks and genfiles.
+ * Customize via `search_filters` in the `GroConfig`.
+ * See the test cases for the exact behavior.
+ */
+export const SEARCH_EXCLUDER_DEFAULT = new RegExp(`(${'(^|/)\\.[^/]+' + // exclude all `.`-prefixed directories
+    // TODO probably change to `pkg.name` instead of this catch-all (also `gro` below)
+    `|(^|/)${NODE_MODULES_DIRNAME}(?!/(@[^/]+/)?gro/${SVELTEKIT_DIST_DIRNAME})` + // exclude `node_modules` unless it's to the Gro directory
+    `|(^|/)${SVELTEKIT_BUILD_DIRNAME}` + // exclude the SvelteKit build directory
+    `|(^|/)(?<!(^|/)gro/)${SVELTEKIT_DIST_DIRNAME}` + // exclude the SvelteKit dist directory unless it's in the Gro directory
+    `|(^|/)${SERVER_DIST_PATH}` + // exclude the Gro server plugin dist directory
+    '|(^|/)test' + // exclude test directories
+    '|(^|/)benchmark' // exclude benchmark directories
+})($|/)`, 'u');
+export const EXPORTS_EXCLUDER_DEFAULT = /(\.md|\.(test|ignore)\.|\/(test|ignore)\/)/;
+/**
+ * Transforms a `RawGroConfig` to the more strict `GroConfig`.
+ * This allows users to provide a more relaxed config.
+ * Hashes the `build_cache_config` and deletes the raw value for security.
+ */
+export const cook_gro_config = async (raw_config) => {
+    const empty_config = create_empty_gro_config();
+    // All of the raw config properties are optional,
+    // so fall back to the empty values when `undefined`.
+    const { plugins = empty_config.plugins, map_package_json = empty_config.map_package_json, task_root_dirs = empty_config.task_root_dirs, search_filters = empty_config.search_filters, js_cli = empty_config.js_cli, pm_cli = empty_config.pm_cli, build_cache_config, filer_options = empty_config.filer_options, } = raw_config;
+    // Hash build_cache_config and delete the raw value
+    // IMPORTANT: Raw value may contain secrets - hash it and delete immediately
+    let build_cache_config_hash;
+    if (!build_cache_config) {
+        build_cache_config_hash = EMPTY_BUILD_CACHE_CONFIG_HASH;
+    }
+    else {
+        // Resolve if it's a function
+        const resolved = typeof build_cache_config === 'function' ? await build_cache_config() : build_cache_config;
+        // Hash the JSON representation with deterministic key ordering
+        build_cache_config_hash = await hash_secure(json_stringify_deterministic(resolved));
+    }
+    // Delete the raw value to ensure it doesn't persist in memory
+    delete raw_config.build_cache_config;
+    return {
+        plugins,
+        map_package_json,
+        task_root_dirs: task_root_dirs.map((p) => resolve(p)),
+        search_filters: Array.isArray(search_filters)
+            ? search_filters
+            : search_filters
+                ? [search_filters]
+                : [],
+        js_cli,
+        pm_cli,
+        build_cache_config_hash,
+        filer_options: filer_options ?? null,
+    };
+};
+export const load_gro_config = async (dir = paths.root) => {
+    const default_config = await cook_gro_config(await create_default_config(create_empty_gro_config()));
+    const config_path = join(dir, GRO_CONFIG_FILENAME);
+    if (!(await fs_exists(config_path))) {
+        // No user config file found, so return the default.
+        return default_config;
+    }
+    // Import the user's `gro.config.ts`.
+    const config_module = await import(__rewriteRelativeImportExtension(config_path, true));
+    validate_gro_config_module(config_module, config_path);
+    return await cook_gro_config(typeof config_module.default === 'function'
+        ? await config_module.default(default_config)
+        : config_module.default);
+};
+export const validate_gro_config_module = (config_module, config_path) => {
+    const config = config_module.default;
+    if (!config) {
+        throw Error(`Invalid Gro config module at ${config_path}: expected a default export`);
+    }
+    else if (!(typeof config === 'function' || typeof config === 'object')) {
+        throw Error(`Invalid Gro config module at ${config_path}: the default export must be a function or object`);
+    }
+};

package/dist/gro_helpers.d.ts

@@ -0,0 +1,49 @@
+import { type SpawnResult } from '@fuzdev/fuz_util/process.js';
+/**
+ * Resolves a path to an internal Gro file.
+ * Prefers any local installation of Gro and falls back to the current CLI context.
+ *
+ * Uses heuristics to find `path`, so may fail in some rare corner cases.
+ * Currently looks for `gro.js` as a sibling to the `path` arg for detection.
+ * If this fails for your usecases, rename `gro.js` or open an issue/PR!
+ *
+ * Used by the CLI and `gro run`.
+ *
+ * case 1:
+ *
+ * We're in a directory that has a local installation of Gro at `node_modules/.bin/gro`.
+ * Use this local version instead of the global.
+ *
+ * case 2:
+ *
+ * We're running Gro inside the Gro repo itself.
+ *
+ * In this case, we use the build directory instead of dist.
+ * There's a paradox here for using Gro inside itself -
+ * ideally we use the dist directory because that's what's shipped,
+ * but the build directory has all of the tests,
+ * and loading two instances of its modules causes problems
+ * like `instanceof` checks failing.
+ * For now we'll just run from build and see if it causes any problems.
+ * There's probably a better design in here somewhere.
+ *
+ * case 3:
+ *
+ * Fall back to invoking Gro from wherever the CLI is being executed.
+ * When using the global CLI, this uses the global Gro installation.
+ *
+ */
+export declare const resolve_gro_module_path: (path?: string) => string;
+/**
+ * Runs a file using the Gro loader.
+ *
+ * Uses conditional exports to correctly set up `esm-env` as development by default,
+ * so if you want production set `NODE_ENV=production`.
+ *
+ * @see https://nodejs.org/api/packages.html#conditional-exports
+ *
+ * @param loader_path path to loader
+ * @param invoke_path path to file to spawn with `node`
+ */
+export declare const spawn_with_loader: (loader_path: string, invoke_path: string, argv: Array<string>, js_cli?: string) => Promise<SpawnResult>;
+//# sourceMappingURL=gro_helpers.d.ts.map

package/dist/gro_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gro_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gro_helpers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAQ,KAAK,WAAW,EAAC,MAAM,6BAA6B,CAAC;AAUpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,WAAW,CAoBrB,CAAC"}

package/dist/gro_helpers.js

@@ -0,0 +1,97 @@
+import { realpathSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from '@fuzdev/fuz_util/process.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.
+
+*/
+/**
+ * Resolves a path to an internal Gro file.
+ * Prefers any local installation of Gro and falls back to the current CLI context.
+ *
+ * Uses heuristics to find `path`, so may fail in some rare corner cases.
+ * Currently looks for `gro.js` as a sibling to the `path` arg for detection.
+ * If this fails for your usecases, rename `gro.js` or open an issue/PR!
+ *
+ * Used by the CLI and `gro run`.
+ *
+ * case 1:
+ *
+ * We're in a directory that has a local installation of Gro at `node_modules/.bin/gro`.
+ * Use this local version instead of the global.
+ *
+ * case 2:
+ *
+ * We're running Gro inside the Gro repo itself.
+ *
+ * In this case, we use the build directory instead of dist.
+ * There's a paradox here for using Gro inside itself -
+ * ideally we use the dist directory because that's what's shipped,
+ * but the build directory has all of the tests,
+ * and loading two instances of its modules causes problems
+ * like `instanceof` checks failing.
+ * For now we'll just run from build and see if it causes any problems.
+ * There's probably a better design in here somewhere.
+ *
+ * case 3:
+ *
+ * Fall back to invoking Gro from wherever the CLI is being executed.
+ * When using the global CLI, this uses the global Gro installation.
+ *
+ */
+export const resolve_gro_module_path = (path = '') => {
+    const gro_bin_path = resolve(NODE_MODULES_DIRNAME, '.bin/gro');
+    // case 1
+    // Prefer any locally installed version of Gro.
+    // This is really confusing if Gro is installed inside Gro itself,
+    // so avoid that when developing Gro.
+    if (existsSync(gro_bin_path)) {
+        return join(realpathSync(gro_bin_path), '..', path);
+    }
+    // case 2
+    // If running Gro inside its own repo, require the local dist.
+    // If the local dist is not yet built it will fall back to the global.
+    if (existsSync(join(SVELTEKIT_DIST_DIRNAME, 'gro.js')) &&
+        existsSync(join(SVELTEKIT_DIST_DIRNAME, path))) {
+        return resolve(SVELTEKIT_DIST_DIRNAME, path);
+    }
+    // case 3
+    // Fall back to the version associated with the running CLI.
+    const file_path = fileURLToPath(import.meta.url);
+    return join(file_path, '..', path);
+};
+/**
+ * Runs a file using the Gro loader.
+ *
+ * Uses conditional exports to correctly set up `esm-env` as development by default,
+ * so if you want production set `NODE_ENV=production`.
+ *
+ * @see https://nodejs.org/api/packages.html#conditional-exports
+ *
+ * @param loader_path path to loader
+ * @param invoke_path path to file to spawn with `node`
+ */
+export const spawn_with_loader = (loader_path, invoke_path, argv, js_cli = JS_CLI_DEFAULT) => {
+    const args = [
+        '--import',
+        // This does the same as `$lib/register.ts` but without the cost of importing another file.
+        `data:text/javascript,
+			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`
+        '--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') {
+        args.push('-C', 'development'); // same as `--conditions`
+    }
+    args.push(invoke_path, ...argv);
+    return spawn(js_cli, args);
+};

package/dist/gro_plugin_gen.d.ts

@@ -0,0 +1,12 @@
+import type { Args } from '@fuzdev/fuz_util/args.js';
+import type { Plugin } from './plugin.ts';
+export interface TaskArgs extends Args {
+    watch?: boolean;
+}
+export interface GroPluginGenOptions {
+    input_paths?: Array<string>;
+    root_dirs?: Array<string>;
+    flush_debounce_delay?: number;
+}
+export declare const gro_plugin_gen: ({ input_paths, root_dirs, flush_debounce_delay, }?: GroPluginGenOptions) => Plugin;
+//# sourceMappingURL=gro_plugin_gen.d.ts.map

package/dist/gro_plugin_gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gro_plugin_gen.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gro_plugin_gen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,0BAA0B,CAAC;AAKnD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAaxC,MAAM,WAAW,QAAS,SAAQ,IAAI;IACrC,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IACnC,WAAW,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC5B,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,cAAc,GAAI,oDAI5B,mBAAkC,KAAG,MAoHvC,CAAC"}

package/dist/gro_plugin_gen.js

@@ -0,0 +1,101 @@
+import { UnreachableError } from '@fuzdev/fuz_util/error.js';
+import { EMPTY_OBJECT } from '@fuzdev/fuz_util/object.js';
+import { throttle } from '@fuzdev/fuz_util/throttle.js';
+import { paths } from "./paths.js";
+import { find_genfiles, is_gen_path } from "./gen.js";
+import { filter_dependents } from "./filer.js";
+import { should_trigger_gen } from "./gen_helpers.js";
+import { spawn_cli } from "./cli.js";
+const FLUSH_DEBOUNCE_DELAY = 500;
+// TODO is cache busting a good idea here to speed up and run in-process?
+// 	await invoke_task('gen', {_: files, bust_cache: true});
+const gen = (files = []) => spawn_cli('gro', ['gen', ...files]);
+export const gro_plugin_gen = ({ input_paths = [paths.source], root_dirs = [paths.source], flush_debounce_delay = FLUSH_DEBOUNCE_DELAY, } = EMPTY_OBJECT) => {
+    const queued_files = new Set();
+    let cleanup_watch;
+    return {
+        name: 'gro_plugin_gen',
+        setup: async ({ watch, dev, log, config, filer, invoke_task, timings }) => {
+            // For production builds, we assume `gen` is already fresh,
+            // which should be checked by CI via `gro check` which calls `gro gen --check`.
+            if (!dev)
+                return;
+            // Do we need to just generate everything once and exit?
+            if (!watch) {
+                // Run `gen`, first checking if there are any modules to avoid a console error.
+                // Some parts of the build may have already happened,
+                // making us miss `build` events for gen dependencies,
+                // so we run a full `gen` here even if it's usually wasteful.
+                const found = await find_genfiles(input_paths, root_dirs, config);
+                if (found.ok && found.value.resolved_input_files.length > 0) {
+                    await gen();
+                }
+                return;
+            }
+            const queue_gen = (gen_file_id) => {
+                queued_files.add(gen_file_id);
+                void flush_gen_queue();
+            };
+            const flush_gen_queue = throttle(async () => {
+                const files = Array.from(queued_files);
+                log.info(files.length === 0
+                    ? '[gen] generating all files'
+                    : `[gen] generating ${files.length} file${files.length === 1 ? '' : 's'}`);
+                queued_files.clear();
+                await gen(files);
+                // run again?
+                if (queued_files.size > 0) {
+                    log.info(`[gen] re-running for ${queued_files.size} more queued file${queued_files.size === 1 ? '' : 's'}`);
+                    setTimeout(flush_gen_queue); // setTimeout is needed bc of throttle behavior
+                }
+                else {
+                    log.info('[gen] queue empty, done');
+                }
+            }, { delay: flush_debounce_delay, when: 'trailing' });
+            // When a file builds, check it and its tree of dependents
+            // for any `.gen.` files that need to run.
+            cleanup_watch = await filer.watch(async (change, source_file) => {
+                if (source_file.external)
+                    return;
+                switch (change.type) {
+                    case 'add':
+                    case 'update': {
+                        // Queue the gen file itself if it changed
+                        if (is_gen_path(source_file.id)) {
+                            queue_gen(source_file.id);
+                        }
+                        // Find all current gen files and check their dependencies
+                        const gen_files = filer.filter((d) => !d.external && is_gen_path(d.id));
+                        if (gen_files) {
+                            for (const gen_file of gen_files) {
+                                // eslint-disable-next-line no-await-in-loop
+                                const should_trigger = await should_trigger_gen(gen_file.id, source_file.id, config, filer, log, timings, invoke_task);
+                                if (should_trigger) {
+                                    queue_gen(gen_file.id);
+                                }
+                            }
+                        }
+                        // Check import-based dependents
+                        const dependent_gen_file_ids = filter_dependents(source_file, filer.get_by_id, is_gen_path, undefined, undefined, log);
+                        for (const dependent_gen_file_id of dependent_gen_file_ids) {
+                            queue_gen(dependent_gen_file_id);
+                        }
+                        break;
+                    }
+                    case 'delete': {
+                        // I think for the gen plugin this is best as a no-op? avoids broken attempts
+                        break;
+                    }
+                    default:
+                        throw new UnreachableError(change.type);
+                }
+            });
+        },
+        teardown: () => {
+            if (cleanup_watch) {
+                cleanup_watch();
+                cleanup_watch = undefined;
+            }
+        },
+    };
+};