@ryanatkn/gro 0.117.0 → 0.119.0

package/dist/gen.js

@@ -1,6 +1,9 @@
 import { join, basename, dirname, isAbsolute } from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { z } from 'zod';
 import { gen_module_meta, to_gen_module_type } from './gen_module.js';
+import { print_path } from './paths.js';
+import { exists } from './fs.js';
 export const Gen_Config = z.object({
     imports: z.record(z.string(), z.string()).default({}),
 });
@@ -79,3 +82,45 @@ const validate_gen_files = (files) => {
         ids.add(file.id);
     }
 };
+export const analyze_gen_results = (gen_results) => Promise.all(gen_results.successes
+    .map((result) => result.files.map((file) => analyze_gen_result(file)))
+    .flat());
+export const analyze_gen_result = async (file) => {
+    if (!(await exists(file.id))) {
+        return {
+            file,
+            existing_content: null,
+            is_new: true,
+            has_changed: true,
+        };
+    }
+    const existing_content = await readFile(file.id, 'utf8');
+    return {
+        file,
+        existing_content,
+        is_new: false,
+        has_changed: file.content !== existing_content,
+    };
+};
+export const write_gen_results = async (gen_results, analyzed_gen_results, log) => {
+    await Promise.all(gen_results.successes
+        .map((result) => result.files.map(async (file) => {
+        const analyzed = analyzed_gen_results.find((r) => r.file.id === file.id);
+        if (!analyzed)
+            throw Error('Expected to find analyzed result: ' + file.id);
+        const log_args = [print_path(file.id), 'generated from', print_path(file.origin_id)];
+        if (analyzed.is_new) {
+            log.info('writing new', ...log_args);
+            await mkdir(dirname(file.id), { recursive: true });
+            await writeFile(file.id, file.content);
+        }
+        else if (analyzed.has_changed) {
+            log.info('writing changed', ...log_args);
+            await writeFile(file.id, file.content);
+        }
+        else {
+            log.info('skipping unchanged', ...log_args);
+        }
+    }))
+        .flat());
+};

package/dist/gen.task.js

@@ -2,16 +2,15 @@ import { red, green, gray } from 'kleur/colors';
 import { print_ms, print_error } from '@ryanatkn/belt/print.js';
 import { plural } from '@ryanatkn/belt/string.js';
 import { z } from 'zod';
-import { dirname } from 'node:path';
-import { mkdir, writeFile } from 'node:fs/promises';
 import { Task_Error } from './task.js';
 import { run_gen } from './run_gen.js';
-import { load_gen_module, check_gen_modules, find_gen_modules } from './gen_module.js';
+import { load_gen_module, find_gen_modules } from './gen_module.js';
 import { Raw_Input_Path, to_input_paths } from './input_path.js';
 import { load_modules } from './modules.js';
 import { format_file } from './format_file.js';
 import { paths, print_path } from './paths.js';
 import { log_error_reasons } from './task_logging.js';
+import { write_gen_results, analyze_gen_results } from './gen.js';
 export const Args = z
     .object({
     _: z.array(Raw_Input_Path, { description: 'paths to generate' }).default([]),
@@ -25,7 +24,7 @@ export const Args = z
 export const task = {
     summary: 'run code generation scripts',
     Args,
-    run: async ({ args, log, timings }) => {
+    run: async ({ args, log, timings, config }) => {
         const { _: raw_input_paths, check } = args;
         const input_paths = raw_input_paths.length ? to_input_paths(raw_input_paths) : [paths.source];
         // load all of the gen modules
@@ -48,23 +47,23 @@ export const task = {
         }
         // run `gen` on each of the modules
         const timing_to_generate_code = timings.start('generate code'); // TODO this ignores `gen_results.elapsed` - should it return `Timings` instead?
-        const gen_results = await run_gen(load_modules_result.modules, log, timings, format_file);
+        const gen_results = await run_gen(load_modules_result.modules, config, log, timings, format_file);
         timing_to_generate_code();
         const fail_count = gen_results.failures.length;
+        const analyzed_gen_results = await analyze_gen_results(gen_results);
         if (check) {
             // check if any files changed, and if so, throw errors,
             // but if there are gen failures, skip the check and defer to their errors
             if (!fail_count) {
                 log.info('checking generated files for changes');
                 const timing_to_check_results = timings.start('check results for changes');
-                const check_gen_modules_results = await check_gen_modules(gen_results);
                 timing_to_check_results();
                 let has_unexpected_changes = false;
-                for (const result of check_gen_modules_results) {
-                    if (!result.has_changed)
+                for (const analyzed of analyzed_gen_results) {
+                    if (!analyzed.has_changed)
                         continue;
                     has_unexpected_changes = true;
-                    log.error(red(`Generated file ${print_path(result.file.id)} via ${print_path(result.file.origin_id)} ${result.is_new ? 'is new' : 'has changed'}.`));
+                    log.error(red(`Generated file ${print_path(analyzed.file.id)} via ${print_path(analyzed.file.origin_id)} ${analyzed.is_new ? 'is new' : 'has changed'}.`));
                 }
                 if (has_unexpected_changes) {
                     throw new Task_Error('Failed gen check. Some generated files have unexpectedly changed.' +
@@ -77,20 +76,21 @@ export const task = {
             // write generated files to disk
             log.info('writing generated files to disk');
             const timing_to_output_results = timings.start('output results');
-            await Promise.all(gen_results.successes
-                .map((result) => result.files.map(async (file) => {
-                log.info('writing', print_path(file.id), 'generated from', print_path(file.origin_id));
-                await mkdir(dirname(file.id), { recursive: true });
-                await writeFile(file.id, file.content);
-            }))
-                .flat());
+            await write_gen_results(gen_results, analyzed_gen_results, log);
             timing_to_output_results();
         }
-        let logResult = '';
+        // TODO these final printed results could be improved showing a breakdown per file id
+        const new_count = analyzed_gen_results.filter((r) => r.is_new).length;
+        const changed_count = analyzed_gen_results.filter((r) => r.has_changed).length;
+        const skipped_count = analyzed_gen_results.filter((r) => !r.is_new && !r.has_changed).length;
+        let log_result = green('gen results:');
+        log_result += `\n\t${new_count} ` + gray('new');
+        log_result += `\n\t${changed_count} ` + gray('changed');
+        log_result += `\n\t${skipped_count} ` + gray('skipped');
         for (const result of gen_results.results) {
-            logResult += `\n\t${result.ok ? green('✓') : red('🞩')}  ${result.ok ? result.files.length : 0} ${gray('in')} ${print_ms(result.elapsed)} ${gray('←')} ${print_path(result.id)}`;
+            log_result += `\n\t${result.ok ? green('✓') : red('🞩')}  ${result.ok ? result.files.length : 0} ${gray('in')} ${print_ms(result.elapsed)} ${gray('←')} ${print_path(result.id)}`;
         }
-        log.info(logResult);
+        log.info(log_result);
         log.info(green(`generated ${gen_results.output_count} file${plural(gen_results.output_count)} from ${gen_results.successes.length} input file${plural(gen_results.successes.length)}`));
         if (fail_count) {
             for (const result of gen_results.failures) {

package/dist/gen_module.d.ts

@@ -1,5 +1,5 @@
 import { type Module_Meta, type Load_Module_Result, type Find_Modules_Result } from './modules.js';
-import type { Gen, Gen_Results, Gen_File } from './gen.js';
+import type { Gen } from './gen.js';
 import { Input_Path } from './input_path.js';
 export declare const GEN_FILE_PATTERN_TEXT = "gen";
 export declare const GEN_FILE_PATTERN: string;
@@ -31,17 +31,4 @@ export interface Basic_Gen_Module_Meta extends Module_Meta<Gen_Module> {
     mod: Basic_Gen_Module;
 }
 export declare const load_gen_module: (id: string) => Promise<Load_Module_Result<Gen_Module_Meta>>;
-export type Check_Gen_Module_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 check_gen_modules: (gen_results: Gen_Results) => Promise<Check_Gen_Module_Result[]>;
-export declare const check_gen_module: (file: Gen_File) => Promise<Check_Gen_Module_Result>;
 export declare const find_gen_modules: (input_paths?: Input_Path[], extensions?: string[], root_dirs?: string[]) => Promise<Find_Modules_Result>;

package/dist/gen_module.js

@@ -1,9 +1,7 @@
-import { readFile } from 'node:fs/promises';
 import { load_module, find_modules, } from './modules.js';
 import { Input_Path, get_possible_source_ids } from './input_path.js';
 import { paths } from './paths.js';
 import { search_fs } from './search_fs.js';
-import { exists } from './fs.js';
 export const GEN_FILE_PATTERN_TEXT = 'gen';
 export const GEN_FILE_PATTERN = '.' + GEN_FILE_PATTERN_TEXT + '.';
 export const is_gen_path = (path) => path.includes(GEN_FILE_PATTERN);
@@ -28,26 +26,6 @@ export const load_gen_module = async (id) => {
     }
     return result;
 };
-export const check_gen_modules = (gen_results) => Promise.all(gen_results.successes
-    .map((result) => result.files.map((file) => check_gen_module(file)))
-    .flat());
-export const check_gen_module = async (file) => {
-    if (!(await exists(file.id))) {
-        return {
-            file,
-            existing_content: null,
-            is_new: true,
-            has_changed: true,
-        };
-    }
-    const existing_content = await readFile(file.id, 'utf8');
-    return {
-        file,
-        existing_content,
-        is_new: false,
-        has_changed: file.content !== existing_content,
-    };
-};
 export const find_gen_modules = (input_paths = [paths.source], 
 // TODO improve this API to allow config, maybe just a simple `gen` filter function, so the user could return a Rollup pluginutils filter,
 // gets a little tricky with the `get_possible_source_ids` API usage, which would probably need to change

package/dist/git.d.ts

@@ -22,6 +22,11 @@ export declare const git_local_branch_exists: (branch: Git_Branch, options?: Spa
  * @returns an error message if the git workspace has any unstaged or uncommitted changes, or `null` if it's clean
  */
 export declare const git_check_clean_workspace: (options?: SpawnOptions) => Promise<string | null>;
+/**
+ * TODO make this return an enum and separate the text into a different function
+ * @returns an error message if the git workspace has any unstaged stages, or `null` if it's clean
+ */
+export declare const git_check_fully_staged_workspace: (options?: SpawnOptions) => Promise<string | null>;
 /**
  * Calls `git fetch` and throws if anything goes wrong.
  */

package/dist/git.js

@@ -63,6 +63,21 @@ export const git_check_clean_workspace = async (options) => {
     }
     return null;
 };
+/**
+ * TODO make this return an enum and separate the text into a different function
+ * @returns an error message if the git workspace has any unstaged stages, or `null` if it's clean
+ */
+export const git_check_fully_staged_workspace = async (options) => {
+    const unstaged_result = await spawn('git', ['diff', '--exit-code', '--quiet'], options);
+    if (!unstaged_result.ok) {
+        return 'git has unstaged changes';
+    }
+    const status_result = await spawn_out('git', ['status', '--porcelain'], options);
+    if (status_result.stdout?.includes('??')) {
+        return 'git has untracked files';
+    }
+    return null;
+};
 /**
  * Calls `git fetch` and throws if anything goes wrong.
  */

package/dist/git.test.js

@@ -1,6 +1,6 @@
 import { test } from 'uvu';
 import * as assert from 'uvu/assert';
-import { git_check_clean_workspace, git_current_branch_first_commit_hash, git_current_branch_name, git_current_commit_hash, } from './git.js';
+import { git_check_clean_workspace, git_check_fully_staged_workspace, git_current_branch_first_commit_hash, git_current_branch_name, git_current_commit_hash, } from './git.js';
 test('git_current_branch_name', async () => {
     const branch_name = await git_current_branch_name();
     assert.ok(branch_name);
@@ -8,6 +8,9 @@ test('git_current_branch_name', async () => {
 test('git_check_clean_workspace', async () => {
     await git_check_clean_workspace();
 });
+test('git_check_fully_staged_workspace', async () => {
+    await git_check_fully_staged_workspace();
+});
 test('git_current_commit_hash', async () => {
     await git_current_commit_hash();
 });

package/dist/gro.config.default.js

@@ -1,6 +1,7 @@
-import { has_sveltekit_library, gro_plugin_sveltekit_library, } from './gro_plugin_sveltekit_library.js';
+import { gro_plugin_sveltekit_library } from './gro_plugin_sveltekit_library.js';
 import { has_server, gro_plugin_server } from './gro_plugin_server.js';
-import { has_sveltekit_app, gro_plugin_sveltekit_app } from './gro_plugin_sveltekit_app.js';
+import { gro_plugin_sveltekit_app } from './gro_plugin_sveltekit_app.js';
+import { has_sveltekit_app, has_sveltekit_library } from './sveltekit_helpers.js';
 /**
  * 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.
@@ -11,16 +12,12 @@ import { has_sveltekit_app, gro_plugin_sveltekit_app } from './gro_plugin_svelte
  * - if `src/lib/server/server.ts`, assumes a Node server
  */
 const config = async (cfg) => {
-    const [enable_sveltekit_library, enable_server, enable_sveltekit_app] = await Promise.all([
-        has_sveltekit_library(),
-        has_server(),
-        has_sveltekit_app(),
-    ]);
+    const [has_sveltekit_library_result, has_server_result, has_sveltekit_app_result] = await Promise.all([has_sveltekit_library(), has_server(), has_sveltekit_app()]);
     cfg.plugins = async () => [
-        enable_sveltekit_library ? gro_plugin_sveltekit_library() : null,
-        enable_server ? gro_plugin_server() : null,
-        enable_sveltekit_app
-            ? gro_plugin_sveltekit_app({ host_target: enable_server ? 'node' : 'github_pages' })
+        has_sveltekit_library_result.ok ? gro_plugin_sveltekit_library() : null,
+        has_server_result.ok ? gro_plugin_server() : null,
+        has_sveltekit_app_result.ok
+            ? gro_plugin_sveltekit_app({ host_target: has_server_result.ok ? 'node' : 'github_pages' })
             : null,
         // TODO replace with an esbuild plugin, see the module for more
         // import {gro_plugin_gen} from './gro_plugin_gen.js';

package/dist/gro_helpers.js

@@ -3,7 +3,12 @@ import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from '@ryanatkn/belt/process.js';
 import { exists } from './fs.js';
-import { NODE_MODULES_DIRNAME } from './paths.js';
+import { NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME } from './path_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.
@@ -40,26 +45,22 @@ import { NODE_MODULES_DIRNAME } from './paths.js';
  */
 export const resolve_gro_module_path = async (path = '') => {
     const gro_bin_path = resolve(NODE_MODULES_DIRNAME, '.bin/gro');
+    // case 1
+    // Prefer any locally installed version of Gro.
     if (await exists(gro_bin_path)) {
-        // case 1
-        // Prefer any locally installed version of Gro.
         return join(await realpath(gro_bin_path), '..', path);
     }
-    else {
-        // 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.
-        const file_path = fileURLToPath(import.meta.url);
-        const base_path = 'dist';
-        if ((await exists(join(base_path, 'gro.js'))) && (await exists(join(base_path, path)))) {
-            return join(file_path, '../..', base_path, path);
-        }
-        else {
-            // case 3
-            // Fall back to the version associated with the running CLI.
-            return join(file_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 ((await exists(join(SVELTEKIT_DIST_DIRNAME, 'gro.js'))) &&
+        (await exists(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.

package/dist/gro_plugin_gen.js

@@ -32,7 +32,7 @@ export const plugin = () => {
             void flush_gen_queue();
         }
     }, FLUSH_DEBOUNCE_DELAY);
-    const gen = (files = []) => spawn('npx', ['gro', 'gen', ...files]);
+    const gen = (files = []) => spawn_cli('gro', ['gen', ...files]);
     return {
         name: 'gro_plugin_gen',
         setup: async ({ args: { watch }, dev, log }) => {

package/dist/gro_plugin_server.d.ts

@@ -1,8 +1,11 @@
 import * as esbuild from 'esbuild';
 import type { Config as SvelteKitConfig } from '@sveltejs/kit';
+import type { Result } from '@ryanatkn/belt/result.js';
 import type { Plugin, Plugin_Context } from './plugin.js';
 export declare const SERVER_SOURCE_ID: Flavored<string, "Source_Id">;
-export declare const has_server: (path?: Flavored<string, "Source_Id">) => Promise<boolean>;
+export declare const has_server: (path?: Flavored<string, "Source_Id">) => Promise<Result<object, {
+    message: string;
+}>>;
 export interface Options {
     /**
      * same as esbuild's `entryPoints`

package/dist/gro_plugin_server.js

@@ -1,10 +1,10 @@
 import { spawn_restartable_process } from '@ryanatkn/belt/process.js';
 import * as esbuild from 'esbuild';
-import { cwd } from 'node:process';
 import { join, resolve } from 'node:path';
 import { identity } from '@ryanatkn/belt/function.js';
-import { strip_before } from '@ryanatkn/belt/string.js';
-import { base_path_to_source_id, GRO_DEV_DIRNAME, SERVER_DIST_PATH, LIB_DIRNAME, paths, } from './paths.js';
+import { strip_before, strip_end } from '@ryanatkn/belt/string.js';
+import { base_path_to_source_id, LIB_DIRNAME, paths } from './paths.js';
+import { GRO_DEV_DIRNAME, SERVER_DIST_PATH } from './path_constants.js';
 import { watch_dir } from './watch_dir.js';
 import { init_sveltekit_config } from './sveltekit_config.js';
 import { esbuild_plugin_sveltekit_shim_app } from './esbuild_plugin_sveltekit_shim_app.js';
@@ -16,10 +16,16 @@ import { esbuild_plugin_sveltekit_local_imports } from './esbuild_plugin_sveltek
 import { exists } from './fs.js';
 import { esbuild_plugin_svelte } from './esbuild_plugin_svelte.js';
 import { throttle } from './throttle.js';
+import { sveltekit_config_global } from './sveltekit_config_global.js';
 // TODO sourcemap as a hoisted option? disable for production by default - or like `outpaths`, passed a `dev` param
 export const SERVER_SOURCE_ID = base_path_to_source_id(LIB_DIRNAME + '/server/server.ts');
-export const has_server = (path = SERVER_SOURCE_ID) => exists(path);
-export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = cwd(), outpaths = (dev) => ({
+export const has_server = async (path = SERVER_SOURCE_ID) => {
+    if (!(await exists(path))) {
+        return { ok: false, message: `no server file found at ${path}` };
+    }
+    return { ok: true };
+};
+export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = process.cwd(), outpaths = (dev) => ({
     outdir: join(dir, dev ? GRO_DEV_DIRNAME : SERVER_DIST_PATH),
     outbase: paths.lib,
     outname: 'server/server.js',
@@ -32,7 +38,10 @@ export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = cwd
     return {
         name: 'gro_plugin_server',
         setup: async ({ dev, watch, timings, log }) => {
-            const { alias, base_url, assets_url, env_dir, private_prefix, public_prefix, svelte_compile_options, svelte_compile_module_options, svelte_preprocessors, } = await init_sveltekit_config(sveltekit_config ?? dir);
+            const parsed_sveltekit_config = !sveltekit_config && strip_end(dir, '/') === process.cwd()
+                ? sveltekit_config_global
+                : await init_sveltekit_config(sveltekit_config ?? dir);
+            const { alias, base_url, assets_url, env_dir, private_prefix, public_prefix, svelte_compile_options, svelte_compile_module_options, svelte_preprocessors, } = parsed_sveltekit_config;
             // TODO hacky
             if (svelte_compile_options.generate === undefined) {
                 svelte_compile_options.generate = 'server';

package/dist/gro_plugin_sveltekit_app.d.ts

@@ -1,7 +1,6 @@
 import type { Plugin, Plugin_Context } from './plugin.js';
 import { type Map_Package_Json } from './package_json.js';
 import { type Map_Src_Json } from './src_json.js';
-export declare const has_sveltekit_app: () => Promise<boolean>;
 export interface Options {
     /**
      * Used for finalizing a SvelteKit build like adding a `.nojekyll` file for GitHub Pages.

package/dist/gro_plugin_sveltekit_app.js

@@ -4,13 +4,11 @@ import { dirname, join } from 'node:path';
 import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
 import { exists } from './fs.js';
 import { serialize_package_json, load_package_json } from './package_json.js';
-import { init_sveltekit_config } from './sveltekit_config.js';
 import { Task_Error } from './task.js';
 import { spawn_cli } from './cli.js';
 import { serialize_src_json, create_src_json } from './src_json.js';
 import { DEFAULT_EXPORTS_EXCLUDER } from './config.js';
-import { SVELTEKIT_CONFIG_FILENAME } from './paths.js';
-export const has_sveltekit_app = () => exists(SVELTEKIT_CONFIG_FILENAME);
+import { sveltekit_config_global } from './sveltekit_config_global.js';
 export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_known_package_json, well_known_src_json, well_known_src_files, } = {}) => {
     let sveltekit_process = null;
     return {
@@ -57,7 +55,7 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
                 // maybe a Vite middleware is best? what if this plugin added its plugin to your `vite.config.ts`?
                 // copy files to `static` before building, in such a way
                 // that's non-destructive to existing files and dirs and easy to clean up
-                const { assets_path } = await init_sveltekit_config(); // TODO probably put in plugin context
+                const { assets_path } = sveltekit_config_global;
                 const cleanups = [
                     serialized_package_json
                         ? await create_temporarily(join(assets_path, '.well-known/package.json'), serialized_package_json)

package/dist/gro_plugin_sveltekit_library.d.ts

@@ -1,4 +1,2 @@
 import type { Plugin, Plugin_Context } from './plugin.js';
-import { Package_Json } from './package_json.js';
-export declare const has_sveltekit_library: (package_json?: Package_Json) => Promise<boolean>;
 export declare const gro_plugin_sveltekit_library: () => Plugin<Plugin_Context>;

package/dist/gro_plugin_sveltekit_library.js

@@ -1,24 +1,23 @@
 import { print_spawn_result, spawn } from '@ryanatkn/belt/process.js';
 import { Task_Error } from './task.js';
-import { Package_Json, load_package_json } from './package_json.js';
+import { load_package_json } from './package_json.js';
 import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
 import { find_cli, spawn_cli } from './cli.js';
-export const has_sveltekit_library = async (package_json) => {
-    const p = package_json ?? (await load_package_json()); // TODO from param, on config?
-    return !!p.devDependencies?.['@sveltejs/package'] || !!p.dependencies?.['@sveltejs/package'];
-    // TODO @multiple get from the sveltekit config
-    // && exists(sveltekit_config.lib_path);
-};
+import { SVELTE_PACKAGE_CLI, has_sveltekit_library } from './sveltekit_helpers.js';
 export const gro_plugin_sveltekit_library = () => {
     return {
         name: 'gro_plugin_sveltekit_library',
         setup: async ({ log }) => {
-            if ((await find_cli('svelte-package')) !== 'local') {
-                throw new Task_Error('Failed to find svelte-package, run `npm i -D @sveltejs/package`');
+            const has_sveltekit_library_result = await has_sveltekit_library();
+            if (!has_sveltekit_library_result.ok) {
+                throw new Task_Error('Failed to find SvelteKit library: ' + has_sveltekit_library_result.message);
+            }
+            if ((await find_cli(SVELTE_PACKAGE_CLI)) !== 'local') {
+                throw new Task_Error(`Failed to find ${SVELTE_PACKAGE_CLI}, run \`npm i\``);
             }
-            const serialized_args = serialize_args(to_forwarded_args('svelte-package'));
+            const serialized_args = serialize_args(to_forwarded_args(SVELTE_PACKAGE_CLI));
             log.info(print_command_args(serialized_args));
-            await spawn_cli('svelte-package', serialized_args);
+            await spawn_cli(SVELTE_PACKAGE_CLI, serialized_args);
         },
         adapt: async ({ log, timings }) => {
             const package_json = await load_package_json();

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export type { Gro_Config, Create_Gro_Config } from './config.js';
 export { type Plugin, replace_plugin } from './plugin.js';
-export { type Gen, type Gen_Context } from './gen.js';
+export type { Gen, Gen_Context } from './gen.js';
 export { type Task, type Task_Context, Task_Error } from './task.js';

package/dist/index.js

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

package/dist/input_path.d.ts

@@ -26,7 +26,7 @@ export declare const to_input_paths: (raw_input_paths: Raw_Input_Path[], root_pa
  * This is first used to fall back to the Gro dir to search for tasks.
  * It's the helper used in implementations of `get_possible_source_ids_for_input_path` below.
  */
-export declare const get_possible_source_ids: (input_path: Flavored<string, "Input_Path">, extensions: string[], root_dirs?: string[]) => Source_Id[];
+export declare const get_possible_source_ids: (input_path: Flavored<string, "Input_Path">, extensions: string[], root_dirs: string[]) => Source_Id[];
 /**
  * Gets the path data for each input path, checking the filesystem for the possibilities
  * and stopping at the first existing file or falling back to the first existing directory.

package/dist/input_path.js

@@ -59,7 +59,7 @@ export const get_possible_source_ids = (input_path, extensions, root_dirs) => {
     if (isAbsolute(input_path)) {
         add_possible_source_ids(input_path);
     }
-    else if (root_dirs?.length) {
+    else {
         for (const root_dir of root_dirs) {
             add_possible_source_ids(join(root_dir, input_path));
         }

package/dist/input_path.test.js

@@ -22,14 +22,14 @@ test('to_input_paths', () => {
 });
 test('get_possible_source_ids in the gro directory', () => {
     const input_path = resolve('src/foo/bar');
-    assert.equal(get_possible_source_ids(input_path, ['.baz.ts']), [
+    assert.equal(get_possible_source_ids(input_path, ['.baz.ts'], []), [
         input_path,
         input_path + '.baz.ts',
     ]);
 });
 test('get_possible_source_ids does not repeat the extension', () => {
     const input_path = resolve('src/foo/bar.baz.ts');
-    assert.equal(get_possible_source_ids(input_path, ['.baz.ts']), [input_path]);
+    assert.equal(get_possible_source_ids(input_path, ['.baz.ts'], []), [input_path]);
 });
 test('get_possible_source_ids does not repeat with the same root directory', () => {
     const input_path = resolve('src/foo/bar.baz.ts');
@@ -39,7 +39,7 @@ test('get_possible_source_ids does not repeat with the same root directory', ()
 });
 test('get_possible_source_ids implied to be a directory by trailing slash', () => {
     const input_path = resolve('src/foo/bar') + '/';
-    assert.equal(get_possible_source_ids(input_path, ['.baz.ts']), [input_path]);
+    assert.equal(get_possible_source_ids(input_path, ['.baz.ts'], []), [input_path]);
 });
 test('load_source_ids_by_input_path', async () => {
     const test_files = {

package/dist/invoke.js

@@ -2,6 +2,7 @@ import { attach_process_error_handlers } from '@ryanatkn/belt/process.js';
 import { invoke_task } from './invoke_task.js';
 import { to_task_args } from './args.js';
 import { load_config } from './config.js';
+import { sveltekit_sync_if_obviously_needed } from './sveltekit_helpers.js';
 /*
 
 This module invokes the Gro CLI which in turn invokes tasks.
@@ -14,5 +15,6 @@ and the rest of the args are forwarded to the task's `run` function.
 */
 // handle uncaught errors
 attach_process_error_handlers((err) => err?.constructor?.name === 'Task_Error' ? 'Task_Error' : null);
+await sveltekit_sync_if_obviously_needed();
 const { task_name, args } = to_task_args();
 await invoke_task(task_name, args, await load_config());

package/dist/invoke_task.d.ts

@@ -17,4 +17,4 @@ import type { Gro_Config } from './config.js';
  * there are some subtle differences in the complex logical branches.
  * The comments describe each condition.
  */
-export declare const invoke_task: (task_name: Flavored<string, "Raw_Input_Path">, args: Args, config: Gro_Config, timings?: any) => Promise<void>;
+export declare const invoke_task: (task_name: Flavored<string, "Raw_Input_Path">, args: Args | undefined, config: Gro_Config, timings?: any) => Promise<void>;