@ryanatkn/gro 0.117.0 → 0.119.0

package/README.md

@@ -4,11 +4,12 @@
 
 > task runner and toolkit extending SvelteKit 🌰 generate, run, optimize
 
-[gro.ryanatkn.com](https://gro.ryanatkn.com/)
-
 [`npm i -D @ryanatkn/gro`](https://www.npmjs.com/package/@ryanatkn/gro)
 
-[Windows won't be supported](https://github.com/ryanatkn/gro/issues/319), I chose Bash instead
+[Windows won't be supported](https://github.com/ryanatkn/gro/issues/319), I chose Bash instead.
+
+Feel free to open issues with anything you'd like to discuss or report.
+I also run [a Discord community](https://discord.gg/YU5tyeK72X) that includes channels for Gro.
 
 ## about
 
@@ -35,8 +36,7 @@ It includes:
     [`@sveltejs/package`](https://kit.svelte.dev/docs/packaging) for the library
   - exposes all of its internals in `$lib`
   - uses [Changesets](https://github.com/changesets/changesets) for versioning and changelogs
-  - provides a [Node loader](/src/lib/loader.ts) and
-    [esbuild plugins for the server](/src/lib/gro_plugin_server.ts)
+  - provides a [Node loader](/src/lib/loader.ts) with a [register hook](/src/lib/register.ts)
     - supports importing TypeScript, JSON, and SSR'd Svelte files in tests and tasks
     - supports [SvelteKit module imports](https://kit.svelte.dev/docs/modules) for
       `$lib`, `$env`, and `$app` in tasks, tests, Node servers,
@@ -44,8 +44,10 @@ It includes:
       so you can use SvelteKit patterns everywhere
       (these are best-effort shims, not perfect)
     - supports running TypeScript files directly without a task via `gro run a.ts`
-  - [configurable plugins](/src/lib/docs/plugin.md)
-    to support SvelteKit, auto-restarting Node servers, and other external build processes
+      or `node --import @ryanatkn/gro/register.js a.ts`
+  - [configurable plugins](/src/lib/docs/plugin.md) to support SvelteKit,
+    [auto-restarting Node servers](/src/lib/gro_plugin_server.ts),
+    and other external build processes
     - see the [Gro config docs](/src/lib/docs/config.md) and
       [the default config](https://github.com/ryanatkn/gro/blob/main/src/lib/gro.config.default.ts)
     - see [`fuz_template`](https://github.com/fuz-dev/fuz_template)
@@ -105,7 +107,7 @@ gro # prints available tasks - defers to any local gro installation
 Run a task: gro [name]
 View help:  gro [name] --help
 
-17 tasks in gro:
+18 tasks in gro:
 
 build      build the project
 changeset  call changeset with gro patterns
@@ -118,6 +120,7 @@ format     format source files
 gen        run code generation scripts
 lint       run eslint
 publish    bump version, publish to npm, and git push
+reinstall  refreshes package-lock.json with the latest and cleanest deps
 release    publish and deploy
 run        execute a file with the loader, like `node` but works for TypeScript
 sync       run `gro gen`, update `package.json`, and optionally `npm i` to sync up
@@ -126,17 +129,34 @@ typecheck  run tsc on the project without emitting any files
 upgrade    upgrade deps
 ```
 
-Gro matches your CLI input against its filesystem conventions.
+To run tasks, Gro matches your CLI input against its filesystem conventions.
 It tries to do the right thing, where right is helpful but not surprising,
 with some magic but not too much:
 
 ```bash
-gro # print all available tasks, those matching `src/lib/**/*.task.ts` and Gro's builtins
-gro some/dir # list all tasks inside `src/lib/some/dir`
-gro some/file # run `src/lib/some/file.task.ts`
+gro # displays all available tasks matching `src/lib/**/*.task.ts` and Gro's builtins
+gro a # tries to run `src/lib/a.task.ts`, then `./a.task.ts`, then Gro's builtin if one exists
+gro a --help # displays docs for the "a" task and its args, works for every task
+gro some/dir # lists all tasks inside `src/lib/some/dir`
+gro some/file # runs `src/lib/some/file.task.ts`
 gro some/file.task.ts # same as above
-gro a # run `src/lib/a.task.ts` if it exists, falling back to Gro's builtin
-gro a --help # print info about the "a" task; works for every task
+```
+
+Gro can also run non-task TypeScript files directly
+with [the `gro run` task](/src/lib/run.task.ts) or [register hook](/src/lib/register.ts):
+
+```bash
+gro run foo.ts
+node --import @ryanatkn/gro/register.js foo.ts
+```
+
+Or programmatically:
+
+```js
+// myfile.js
+import {register} from 'node:module';
+register('@ryanatkn/gro/loader.js', import.meta.url);
+await import('./foo.ts');
 ```
 
 Gro has a number of builtin tasks that you can run with the CLI.
@@ -200,19 +220,17 @@ To publish: (also see [`src/lib/docs/publish.md`](/src/lib/docs/publish.md))
 gro publish # flush changeset to changelog, bump version, publish to npm, and git push
 ```
 
-Etc:
+More:
 
 ```bash
 gro clean # delete all build artifacts from the filesystem
 gro clean --sveltekit --nodemodules --git # also deletes dirs and prunes git branches
 gro upgrade excluded-dep-1 excluded-dep-2 # npm updates to the latest everything
-```
-
-```bash
 gro --version # print the Gro version
 ```
 
-For more see [`src/lib/docs/task.md`](/src/lib/docs/task.md) and [`src/lib/docs`](/src/lib/docs).
+For more see [the tasks index](/src/lib/docs/tasks.md),
+[the task feature docs](/src/lib/docs/task.md), and [the docs index](/src/lib/docs/README.md).
 
 ## develop
 

package/dist/build.task.d.ts

@@ -2,10 +2,13 @@ import { z } from 'zod';
 import type { Task } from './task.js';
 export declare const Args: z.ZodObject<{
     install: z.ZodDefault<z.ZodBoolean>;
+    'no-install': z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     install: boolean;
+    'no-install': boolean;
 }, {
     install?: boolean | undefined;
+    'no-install'?: boolean | undefined;
 }>;
 export type Args = z.infer<typeof Args>;
 export declare const task: Task<Args>;

package/dist/build.task.js

@@ -3,7 +3,10 @@ import { Plugins } from './plugin.js';
 import { clean_fs } from './clean_fs.js';
 export const Args = z
     .object({
-    install: z.boolean({ description: 'run npm install before building' }).default(false),
+    install: z.boolean({ description: 'dual of no-install' }).default(true),
+    'no-install': z
+        .boolean({ description: 'opt out of npm installing before building' })
+        .default(false),
 })
     .strict();
 export const task = {
@@ -12,6 +15,7 @@ export const task = {
     run: async (ctx) => {
         const { args, invoke_task } = ctx;
         const { install } = args;
+        // By default `gro build` installs, opposite of `gro sync`, so that arg needs special handling.
         await invoke_task('sync', { install });
         // TODO possibly detect if the git workspace is clean, and ask for confirmation if not,
         // because we're not doing things like `gro gen` here because that's a dev/CI concern

package/dist/changeset.task.d.ts

@@ -19,22 +19,22 @@ export declare const Args: z.ZodObject<{
     _: string[];
     dir: string;
     install: boolean;
+    'no-install': boolean;
     origin: string & z.BRAND<"Git_Origin">;
     minor: boolean;
     major: boolean;
     changelog: string;
-    'no-install': boolean;
     access?: "public" | "restricted" | undefined;
 }, {
     _?: string[] | undefined;
     dir?: string | undefined;
     install?: boolean | undefined;
+    'no-install'?: boolean | undefined;
     origin?: string | undefined;
     minor?: boolean | undefined;
     major?: boolean | undefined;
     access?: "public" | "restricted" | undefined;
     changelog?: string | undefined;
-    'no-install'?: boolean | undefined;
 }>;
 export type Args = z.infer<typeof Args>;
 /**

package/dist/changeset.task.js

@@ -8,8 +8,8 @@ import { Task_Error } from './task.js';
 import { exists } from './fs.js';
 import { load_package_json } from './package_json.js';
 import { find_cli, spawn_cli } from './cli.js';
-import { Git_Origin, git_push_to_create } from './git.js';
-import { has_sveltekit_library } from './gro_plugin_sveltekit_library.js';
+import { Git_Origin, git_check_fully_staged_workspace, git_push_to_create } from './git.js';
+import { has_sveltekit_library } from './sveltekit_helpers.js';
 const RESTRICTED_ACCESS = 'restricted';
 const PUBLIC_ACCESS = 'public';
 const CHANGESET_DIR = '.changeset';
@@ -62,8 +62,9 @@ export const task = {
             throw new Task_Error('changeset command not found: install @changesets/cli locally or globally');
         }
         const package_json = await load_package_json();
-        if (!(await has_sveltekit_library(package_json))) {
-            throw new Task_Error('no SvelteKit library detected');
+        const has_sveltekit_library_result = await has_sveltekit_library(package_json);
+        if (!has_sveltekit_library_result.ok) {
+            throw new Task_Error('Failed to find SvelteKit library: ' + has_sveltekit_library_result.message);
         }
         const path = join(dir, 'config.json');
         const inited = await exists(path);
@@ -85,14 +86,17 @@ export const task = {
                 await spawn('npm', ['i', '-D', changelog]);
             }
         }
+        // TODO small problem here where generated files don't get committed
         await invoke_task('sync'); // after the `npm i` above, and in all cases
         if (message) {
             // TODO see the helper below, simplify this to CLI flags when support is added to Changesets
             const changeset_adder = await create_changeset_adder(package_json.name, dir, message, bump);
             await spawn_cli('changeset', ['add', '--empty']);
             await changeset_adder();
-            await spawn('git', ['commit', '-m', message]);
-            await git_push_to_create(origin);
+            if (!(await git_check_fully_staged_workspace())) {
+                await spawn('git', ['commit', '-m', message]);
+                await git_push_to_create(origin);
+            }
         }
         else {
             await spawn_cli('changeset');

package/dist/check.task.js

@@ -68,7 +68,7 @@ export const task = {
             if (error_message) {
                 log.error(red('git status'));
                 await spawn('git', ['status']);
-                throw new Task_Error('failed check for git_check_clean_workspace:' +
+                throw new Task_Error('Failed check for git_check_clean_workspace:' +
                     error_message +
                     ' - do you need to run `gro sync` or commit some files?');
             }

package/dist/clean_fs.js

@@ -1,5 +1,6 @@
 import { rm, readdir } from 'node:fs/promises';
-import { NODE_MODULES_DIRNAME, paths, SVELTEKIT_DEV_DIRNAME, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_VITE_CACHE_PATH, GRO_DIST_PREFIX, SVELTEKIT_DIST_DIRNAME, } from './paths.js';
+import { paths } from './paths.js';
+import { NODE_MODULES_DIRNAME, GRO_DIST_PREFIX, SVELTEKIT_DEV_DIRNAME, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_VITE_CACHE_PATH, SVELTEKIT_DIST_DIRNAME, } from './path_constants.js';
 export const clean_fs = async ({ build = false, build_dev = false, build_dist = false, sveltekit = false, nodemodules = false, }, rm_options = { force: true, recursive: true }) => {
     const promises = [];
     if (build) {

package/dist/cli.js

@@ -1,7 +1,7 @@
 import { spawn, spawn_out } from '@ryanatkn/belt/process.js';
 import { join } from 'node:path';
 import { exists } from './fs.js';
-import { NODE_MODULES_DIRNAME } from './paths.js';
+import { NODE_MODULES_DIRNAME } from './path_constants.js';
 /**
  * Looks for the CLI `name`, first local to the cwd and then globally.
  */

package/dist/config.js

@@ -1,5 +1,6 @@
 import { join, resolve } from 'node:path';
-import { CONFIG_PATH, GRO_DIST_DIR, IS_THIS_GRO, paths } from './paths.js';
+import { GRO_DIST_DIR, IS_THIS_GRO, paths } from './paths.js';
+import { GRO_CONFIG_PATH } from './path_constants.js';
 import create_default_config from './gro.config.default.js';
 import { exists } from './fs.js';
 export const create_empty_config = () => ({
@@ -17,7 +18,7 @@ const default_map_package_json = async (package_json) => {
 export const DEFAULT_EXPORTS_EXCLUDER = /(\.md|\.(test|ignore)\.|\/(test|fixtures|ignore)\/)/u;
 export const load_config = async (dir = paths.root) => {
     const default_config = await create_default_config(create_empty_config());
-    const config_path = join(dir, CONFIG_PATH);
+    const config_path = join(dir, GRO_CONFIG_PATH);
     let config;
     if (await exists(config_path)) {
         const config_module = await import(config_path);

package/dist/deploy.task.d.ts

@@ -10,17 +10,13 @@ export declare const Args: z.ZodObject<{
     force: z.ZodDefault<z.ZodBoolean>;
     dangerous: z.ZodDefault<z.ZodBoolean>;
     reset: z.ZodDefault<z.ZodBoolean>;
-    install: z.ZodDefault<z.ZodBoolean>;
-    'no-install': z.ZodDefault<z.ZodBoolean>;
     build: z.ZodDefault<z.ZodBoolean>;
     'no-build': z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     build: boolean;
     target: string & z.BRAND<"Git_Branch">;
-    install: boolean;
     origin: string & z.BRAND<"Git_Origin">;
     reset: boolean;
-    'no-install': boolean;
     source: string & z.BRAND<"Git_Branch">;
     deploy_dir: string;
     build_dir: string;
@@ -31,10 +27,8 @@ export declare const Args: z.ZodObject<{
 }, {
     build?: boolean | undefined;
     target?: string | undefined;
-    install?: boolean | undefined;
     origin?: string | undefined;
     reset?: boolean | undefined;
-    'no-install'?: boolean | undefined;
     source?: string | undefined;
     deploy_dir?: string | undefined;
     build_dir?: string | undefined;

package/dist/deploy.task.js

@@ -5,15 +5,15 @@ import { z } from 'zod';
 import { cp, mkdir, readdir, rm } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { Task_Error } from './task.js';
-import { GIT_DIRNAME, GRO_DIRNAME, print_path, SVELTEKIT_BUILD_DIRNAME } from './paths.js';
+import { print_path } from './paths.js';
+import { GRO_DIRNAME, GIT_DIRNAME, SVELTEKIT_BUILD_DIRNAME } from './path_constants.js';
 import { empty_dir, exists } from './fs.js';
 import { git_check_clean_workspace, git_checkout, git_local_branch_exists, git_remote_branch_exists, Git_Origin, Git_Branch, git_delete_local_branch, git_push_to_create, git_reset_branch_to_first_commit, git_pull, git_fetch, git_check_setting_pull_rebase, git_clone_locally, git_current_branch_name, } from './git.js';
 // docs at ./docs/deploy.md
-// TODO use `to_forwarded_args` and the `gro deploy -- gro build --no-install` pattern to remove the `install`/`no-install` args (also needs testing, maybe a custom override for `gro ` prefixes)
 // terminal command for testing:
 // npm run build && rm -rf .gro && clear && gro deploy --source no-git-workspace --no-build --dry
 // TODO customize
-const cwd = process.cwd();
+const dir = process.cwd();
 const INITIAL_FILE_PATH = '.gitkeep';
 const INITIAL_FILE_CONTENTS = '';
 const DEPLOY_DIR = GRO_DIRNAME + '/deploy';
@@ -45,10 +45,6 @@ export const Args = z
         description: 'if true, resets the target branch back to the first commit before deploying',
     })
         .default(false),
-    install: z.boolean({ description: 'dual of no-install' }).default(true),
-    'no-install': z
-        .boolean({ description: 'opt out of npm installing before building' })
-        .default(false),
     build: z.boolean({ description: 'dual of no-build' }).default(true),
     'no-build': z.boolean({ description: 'opt out of building' }).default(false),
 })
@@ -57,7 +53,7 @@ export const task = {
     summary: 'deploy to a branch',
     Args,
     run: async ({ args, log, invoke_task }) => {
-        const { source, target, origin, build_dir, deploy_dir, dry, force, dangerous, reset, install, build, } = args;
+        const { source, target, origin, build_dir, deploy_dir, dry, force, dangerous, reset, build } = args;
         // Checks
         if (!force && target !== TARGET_BRANCH) {
             throw new Task_Error(`Warning! You are deploying to a custom target branch '${target}',` +
@@ -121,7 +117,7 @@ export const task = {
             if (!(await exists(resolved_deploy_dir))) {
                 const local_deploy_branch_exists = await git_local_branch_exists(target);
                 await git_fetch(origin, ('+' + target + ':' + target)); // fetch+merge and allow non-fastforward updates with the +
-                await git_clone_locally(origin, target, cwd, resolved_deploy_dir);
+                await git_clone_locally(origin, target, dir, resolved_deploy_dir);
                 // Clean up if we created the target branch in the cwd
                 if (!local_deploy_branch_exists) {
                     await git_delete_local_branch(target);
@@ -145,7 +141,7 @@ export const task = {
             }
             // Create the target branch locally and remotely.
             // This is more complex to avoid churning the cwd.
-            await git_clone_locally(origin, source, cwd, resolved_deploy_dir);
+            await git_clone_locally(origin, source, dir, resolved_deploy_dir);
             await spawn(`git checkout --orphan ${target} && ` +
                 // TODO there's definitely a better way to do this
                 `git rm -rf . && ` +
@@ -162,7 +158,7 @@ export const task = {
         // Build
         try {
             if (build) {
-                await invoke_task('build', { install });
+                await invoke_task('build');
             }
             if (!(await exists(build_dir))) {
                 log.error(red('directory to deploy does not exist after building:'), build_dir);

package/dist/dev.task.d.ts

@@ -7,13 +7,13 @@ export declare const Args: z.ZodObject<{
     sync: z.ZodDefault<z.ZodBoolean>;
     'no-sync': z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    watch: boolean;
     sync: boolean;
+    watch: boolean;
     'no-watch': boolean;
     'no-sync': boolean;
 }, {
-    watch?: boolean | undefined;
     sync?: boolean | undefined;
+    watch?: boolean | undefined;
     'no-watch'?: boolean | undefined;
     'no-sync'?: boolean | undefined;
 }>;

package/dist/docs/gen.md

@@ -52,6 +52,17 @@ There's no support for sourcemaps yet, and I have no plans for them.
 (I would accept contributions, but I think it's a hard problem to do well,
 and I don't know what the payoffs would be)
 
+> ⚠️ Generated files should never be edited directly,
+> because the next time `gro gen` or `gro sync` runs,
+> any uncommitted changes will be lost!
+> I considered making `gen` only write to files that have no uncommitted changes,
+> but that would impede many workflows,
+> and I don't want to nudge users towards a habit of always adding an override flag.
+> I can see one possible improvement that lets the user
+> opt into making gen write only to unchanged files for those workflows that don't mind it,
+> so if you would like to see that or something similar,
+> please open an issue or [share your thoughts on Discord](https://discord.gg/YU5tyeK72X).
+
 Inspirations include Lisp macros, the
 [Svelte](https://github.com/sveltejs/svelte) compiler,
 and [Zig](https://github.com/ziglang/zig)'s comptime.
@@ -91,6 +102,22 @@ Outputs `src/script.ts`:
 console.log('generated a string');
 ```
 
+### gen context
+
+The `Gen` function receives one argument, the `Gen_Context` object:
+
+```ts
+export interface Gen_Context {
+	config: Gro_Config;
+	/**
+	 * Same as `import.meta.url` but in path form.
+	 */
+	origin_id: string;
+	log: Logger;
+}
+// export const gen: Gen = ({config, origin_id, log}) => {
+```
+
 ### generate other filetypes
 
 Files with any extension can be generated without configuration.

package/dist/docs/publish.md

@@ -52,14 +52,7 @@ a changeset to an already-inited repo, use `gro changeset`:
 
 ```bash
 gro changeset # inits or adds a changeset
-gro changeset --help # prints:
-gro changeset: call changeset with gro patterns
-
-[...args]   string[]                 []                           the commands to pass to changeset
-path        string                   './.changeset/config.json'   changeset config file path
-access      'restricted' | 'public'  undefined                    changeset 'access' config value, the default depends on package.json#private
-changelog   string                   '@changesets/changelog-git'  changeset "changelog" config value
-no-install  boolean                  false                        opt out of npm installing the changelog package
+gro changeset --help # view the args docs
 
 # `gro changeset` is equivalent to:
 changeset init # if needed -- prefix with `npx ` if installed only locally

package/dist/docs/task.md

@@ -310,6 +310,11 @@ then `--a` and `--b` will be forwarded to `taskname2`.
 Forwarded args to Gro tasks override direct args, including args to `invoke_task`,
 so `gro taskname --a 1 -- gro taskname --a 2` will invoke `taskname` with `{a: 2}`.
 
+The `invoke_task` helper in the task context forwards the CLI args for the specified task.
+CLI args take precedence over args passed directly to `invoke_task`.
+This may not always be the desired behavior, but it gives the user more control,
+because you can't change args in code you don't control.
+
 ### throwing errors
 
 If a task encounters an error, normally it should throw rather than exiting the process.
@@ -355,6 +360,8 @@ What makes Gro different?
   and improved DX with new capabilities.
 - Tasks support CLI args that are validated and typesafe
   via colocated Zod schemas with minimal boilerplate.
+- Tasks are forwarded CLI args when called via `invoke_task` in other tasks,
+  so running `gro foo -- gro bar --a b` passes `{a: 'b'}` automatically to the `bar` task.
 - Module resolution differs and leverages discoverability:
   - When a task name is given to Gro,
     it first searches `src/lib/` in the current working directory and

package/dist/docs/tasks.gen.md.js

@@ -14,14 +14,13 @@ import { log_error_reasons } from '../task_logging.js';
 // TODO display more info about each task, including a summary and params
 // TODO needs some cleanup and better APIs - paths are confusing and verbose!
 // TODO add backlinks to every document that links to this one
-export const gen = async ({ origin_id, log }) => {
-    const result = await load_task_modules([paths.lib]);
+export const gen = async ({ config, origin_id, log }) => {
+    const result = await load_task_modules([paths.lib], config.task_root_paths);
     if (!result.ok) {
         log_error_reasons(log, result.reasons);
         throw new Error(result.type);
     }
     const tasks = result.modules;
-    // TODO need to get this from project config or something
     const root_path = parse_path_segments(paths.root).at(-1);
     const origin_dir = dirname(origin_id);
     const origin_base = basename(origin_id);

package/dist/docs/tasks.md

@@ -17,6 +17,7 @@ What is a `Task`? See [`task.md`](./task.md).
 - [gen](../gen.task.ts) - run code generation scripts
 - [lint](../lint.task.ts) - run eslint
 - [publish](../publish.task.ts) - bump version, publish to npm, and git push
+- [reinstall](../reinstall.task.ts) - refreshes package-lock.json with the latest and cleanest deps
 - [release](../release.task.ts) - publish and deploy
 - [run](../run.task.ts) - execute a file with the loader, like `node` but works for TypeScript
 - [sync](../sync.task.ts) - run `gro gen`, update `package.json`, and optionally `npm i` to sync up

package/dist/esbuild_plugin_external_worker.js

@@ -1,6 +1,5 @@
 import * as esbuild from 'esbuild';
 import { basename } from 'node:path';
-import { cwd } from 'node:process';
 import { print_build_result, to_define_import_meta_env } from './esbuild_helpers.js';
 import { resolve_specifier } from './resolve_specifier.js';
 import { esbuild_plugin_sveltekit_shim_alias } from './esbuild_plugin_sveltekit_shim_alias.js';
@@ -8,7 +7,7 @@ import { esbuild_plugin_sveltekit_shim_env } from './esbuild_plugin_sveltekit_sh
 import { esbuild_plugin_sveltekit_shim_app } from './esbuild_plugin_sveltekit_shim_app.js';
 import { esbuild_plugin_sveltekit_local_imports } from './esbuild_plugin_sveltekit_local_imports.js';
 import { esbuild_plugin_svelte } from './esbuild_plugin_svelte.js';
-export const esbuild_plugin_external_worker = ({ dev, build_options, dir = cwd(), svelte_compile_options, svelte_preprocessors, svelte_compile_module_options, alias, base_url, assets_url, public_prefix, private_prefix, env_dir, env_files, ambient_env, log, }) => ({
+export const esbuild_plugin_external_worker = ({ dev, build_options, dir = process.cwd(), svelte_compile_options, svelte_preprocessors, svelte_compile_module_options, alias, base_url, assets_url, public_prefix, private_prefix, env_dir, env_files, ambient_env, log, }) => ({
     name: 'external_worker',
     setup: (build) => {
         const builds = new Map();

package/dist/esbuild_plugin_svelte.js

@@ -1,10 +1,9 @@
 import { compile, compileModule, preprocess, } from 'svelte/compiler';
 import { readFile } from 'node:fs/promises';
 import { relative } from 'node:path';
-import { cwd } from 'node:process';
 import { SVELTE_MATCHER, SVELTE_RUNES_MATCHER } from './svelte_helpers.js';
 export const esbuild_plugin_svelte = (options = {}) => {
-    const { dir = cwd(), svelte_compile_options = {}, svelte_compile_module_options = {}, svelte_preprocessors, } = options;
+    const { dir = process.cwd(), svelte_compile_options = {}, svelte_compile_module_options = {}, svelte_preprocessors, } = options;
     return {
         name: 'svelte',
         setup: (build) => {

package/dist/esbuild_plugin_sveltekit_shim_alias.js

@@ -1,7 +1,6 @@
 import { escape_regexp } from '@ryanatkn/belt/regexp.js';
-import { cwd } from 'node:process';
 import { join } from 'node:path';
-export const esbuild_plugin_sveltekit_shim_alias = ({ dir = cwd(), alias, }) => ({
+export const esbuild_plugin_sveltekit_shim_alias = ({ dir = process.cwd(), alias, }) => ({
     name: 'sveltekit_shim_alias',
     setup: (build) => {
         const aliases = { $lib: 'src/lib', ...alias };

package/dist/format_directory.d.ts

@@ -1,2 +1,8 @@
-import { type Spawn_Result } from '@ryanatkn/belt/process.js';
-export declare const format_directory: (log: Logger, directory: string, check?: boolean, extensions?: string, root_paths?: string) => Promise<Spawn_Result>;
+import type { Spawn_Result } from '@ryanatkn/belt/process.js';
+/**
+ * Formats a directory on the filesystem.
+ * If the source directory is given, it also formats all of the root directory files.
+ * This is separated from `./format_file` to avoid importing all of the `prettier` code
+ * inside modules that import this one. (which has a nontrivial cost)
+ */
+export declare const format_directory: (log: Logger, dir: string, check?: boolean, extensions?: string, root_paths?: string) => Promise<Spawn_Result>;

package/dist/format_directory.js

@@ -1,27 +1,33 @@
-import { spawn } from '@ryanatkn/belt/process.js';
-import { GITHUB_DIRNAME, paths, README_FILENAME, SVELTEKIT_CONFIG_FILENAME, VITE_CONFIG_FILENAME, TSCONFIG_FILENAME, CONFIG_PATH, } from './paths.js';
+import { paths } from './paths.js';
+import { GITHUB_DIRNAME, README_FILENAME, SVELTEKIT_CONFIG_FILENAME, VITE_CONFIG_FILENAME, TSCONFIG_FILENAME, GRO_CONFIG_PATH, } from './path_constants.js';
 import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
+import { spawn_cli } from './cli.js';
 const DEFAULT_EXTENSIONS = 'ts,js,json,svelte,html,css,md,yml';
 const DEFAULT_ROOT_PATHS = `${[
     README_FILENAME,
-    CONFIG_PATH,
+    GRO_CONFIG_PATH,
     SVELTEKIT_CONFIG_FILENAME,
     VITE_CONFIG_FILENAME,
     TSCONFIG_FILENAME,
     GITHUB_DIRNAME,
 ].join(',')}/**/*`;
-// This formats a directory on the filesystem.
-// If the source directory is given, it also formats all of the root directory files.
-// This is separated from `./format_file` to avoid importing all of the `prettier` code
-// inside modules that import this one. (which has a nontrivial cost)
-export const format_directory = (log, directory, check = false, extensions = DEFAULT_EXTENSIONS, root_paths = DEFAULT_ROOT_PATHS) => {
+/**
+ * Formats a directory on the filesystem.
+ * If the source directory is given, it also formats all of the root directory files.
+ * This is separated from `./format_file` to avoid importing all of the `prettier` code
+ * inside modules that import this one. (which has a nontrivial cost)
+ */
+export const format_directory = async (log, dir, check = false, extensions = DEFAULT_EXTENSIONS, root_paths = DEFAULT_ROOT_PATHS) => {
     const forwarded_args = to_forwarded_args('prettier');
     forwarded_args[check ? 'check' : 'write'] = true;
-    const serialized_args = ['prettier', ...serialize_args(forwarded_args)];
-    serialized_args.push(`${directory}**/*.{${extensions}}`);
-    if (directory === paths.source) {
+    const serialized_args = serialize_args(forwarded_args);
+    serialized_args.push(`${dir}**/*.{${extensions}}`);
+    if (dir === paths.source) {
         serialized_args.push(`${paths.root}{${root_paths}}`);
     }
     log.info(print_command_args(serialized_args));
-    return spawn('npx', serialized_args);
+    const spawned = await spawn_cli('prettier', serialized_args);
+    if (!spawned)
+        throw new Error('failed to find `prettier` CLI locally or globally, do you need to run `npm i`?');
+    return spawned;
 };

package/dist/gen.d.ts

@@ -1,5 +1,6 @@
 import type { Logger } from '@ryanatkn/belt/log.js';
 import { z } from 'zod';
+import type { Gro_Config } from './config.js';
 export type Gen_Result = {
     origin_id: string;
     files: Gen_File[];
@@ -14,6 +15,10 @@ export interface Gen {
     (ctx: Gen_Context): Raw_Gen_Result | Promise<Raw_Gen_Result>;
 }
 export interface Gen_Context {
+    config: Gro_Config;
+    /**
+     * Same as `import.meta.url` but in path form.
+     */
     origin_id: string;
     log: Logger;
 }
@@ -55,3 +60,17 @@ export type Gen_Module_Result_Failure = {
 };
 export declare const to_gen_result: (origin_id: Flavored<string, "Source_Id">, raw_result: Raw_Gen_Result) => Gen_Result;
 export declare const to_output_file_name: (filename: string) => string;
+export type Analyzed_Gen_Result = {
+    file: Gen_File;
+    existing_content: string;
+    is_new: false;
+    has_changed: boolean;
+} | {
+    file: Gen_File;
+    existing_content: null;
+    is_new: true;
+    has_changed: true;
+};
+export declare const analyze_gen_results: (gen_results: Gen_Results) => Promise<Analyzed_Gen_Result[]>;
+export declare const analyze_gen_result: (file: Gen_File) => Promise<Analyzed_Gen_Result>;
+export declare const write_gen_results: (gen_results: Gen_Results, analyzed_gen_results: Analyzed_Gen_Result[], log: Logger) => Promise<void>;