@ryanatkn/gro 0.142.0 → 0.143.1

package/dist/build.task.js

@@ -7,7 +7,7 @@ export const Args = z
     'no-sync': z.boolean({ description: 'opt out of gro sync' }).default(false),
     install: z.boolean({ description: 'dual of no-install' }).default(true),
     'no-install': z // convenience, same as `gro build -- gro sync --no-install` but the latter takes precedence
-        .boolean({ description: 'opt out of `npm install` before building' })
+        .boolean({ description: 'opt out of installing packages before building' })
         .default(false),
 })
     .strict();

package/dist/changeset.task.js

@@ -25,7 +25,7 @@ export const Args = z
         .default('@changesets/changelog-git'),
     dep: z.boolean({ description: 'dual of no-dep' }).default(true),
     'no-dep': z
-        .boolean({ description: 'opt out of npm installing the changelog package' })
+        .boolean({ description: 'opt out of installing the changelog package' })
         .default(false),
     origin: Git_Origin.describe('git origin to deploy to').default('origin'),
     changeset_cli: z.string({ description: 'the changeset CLI to use' }).default(CHANGESET_CLI),
@@ -79,11 +79,11 @@ export const task = {
             }
             await spawn('git', ['add', dir]);
             if (dep) {
-                await spawn(config.pm_cli, ['i', '-D', changelog]);
+                await spawn(config.pm_cli, ['install', '-D', changelog]);
             }
         }
         // TODO small problem here where generated files don't get committed
-        await invoke_task('sync', { install: inited || !dep }); // after the `npm i` above, and in all cases
+        await invoke_task('sync', { install: inited || !dep }); // after installing 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 = create_changeset_adder(package_json.name, dir, message, bump);

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

@@ -1 +1 @@
-{"version":3,"file":"check.task.d.ts","sourceRoot":"../src/lib/","sources":["check.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAIhD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBP,CAAC;AACX,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAyD3B,CAAC"}
+{"version":3,"file":"check.task.d.ts","sourceRoot":"../src/lib/","sources":["check.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAIhD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBP,CAAC;AACX,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAyD3B,CAAC"}

package/dist/check.task.js

@@ -21,7 +21,9 @@ export const Args = z
     sync: z.boolean({ description: 'dual of no-sync' }).default(true),
     'no-sync': z.boolean({ description: 'opt out of syncing' }).default(false),
     install: z.boolean({ description: 'dual of no-install' }).default(true),
-    'no-install': z.boolean({ description: 'opt out of `npm install` when syncing' }).default(false), // convenience, same as `gro check -- gro sync --no-install` but the latter takes precedence
+    'no-install': z
+        .boolean({ description: 'opt out of installing packages when syncing' })
+        .default(false), // convenience, same as `gro check -- gro sync --no-install` but the latter takes precedence
     workspace: z
         .boolean({ description: 'ensure a clean git workspace, useful for CI, also implies --no-sync' })
         .default(false),
@@ -33,7 +35,7 @@ export const task = {
     run: async ({ args, invoke_task, log, config }) => {
         const { typecheck, test, gen, format, package_json, lint, sync, install, workspace } = args;
         // When checking the workspace, which was added for CI, never sync.
-        // Setup like `npm i` and `sveltekit-sync` should be done in the CI setup.
+        // Setup like installing packages and `sveltekit-sync` should be done in the CI setup.
         if (sync && !workspace) {
             await invoke_task('sync', { install, gen: false }); // never generate because `gro gen --check` runs below
         }

package/dist/clean_fs.js

@@ -1,7 +1,7 @@
 import { rm } from 'node:fs/promises';
 import { readdirSync } from 'node:fs';
 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';
+import { NODE_MODULES_DIRNAME, GRO_DIST_PREFIX, SVELTEKIT_DEV_DIRNAME, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_VITE_CACHE_PATH, SVELTEKIT_DIST_DIRNAME, } from './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

@@ -3,7 +3,7 @@ import { spawn, spawn_process, } from '@ryanatkn/belt/process.js';
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import { NODE_MODULES_DIRNAME } from './path_constants.js';
+import { NODE_MODULES_DIRNAME } from './constants.js';
 import { print_command_args } from './args.js';
 /**
  * Searches the filesystem for the CLI `name`, first local to the cwd and then globally.

package/dist/{path_constants.d.ts → constants.d.ts}

@@ -23,4 +23,7 @@ export declare const TS_MATCHER: RegExp;
 export declare const JS_MATCHER: RegExp;
 export declare const JSON_MATCHER: RegExp;
 export declare const EVERYTHING_MATCHER: RegExp;
-//# sourceMappingURL=path_constants.d.ts.map
+export declare const JS_CLI_DEFAULT = "node";
+export declare const PM_CLI_DEFAULT = "npm";
+export declare const PRETTIER_CLI_DEFAULT = "prettier";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"../src/lib/","sources":["constants.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,cAAc,QAAQ,CAAC;AACpC,eAAO,MAAM,WAAW,SAAS,CAAC;AAClC,eAAO,MAAM,eAAe,UAAU,CAAC;AACvC,eAAO,MAAM,gBAAgB,gBAAgB,CAAC;AAC9C,eAAO,MAAM,eAAe,QAAuB,CAAC;AACpD,eAAO,MAAM,UAAU,QAAuB,CAAC;AAC/C,eAAO,MAAM,OAAO,QAAoB,CAAC;AACzC,eAAO,MAAM,WAAW,QAAwB,CAAC;AACjD,eAAO,MAAM,eAAe,kBAAkB,CAAC;AAC/C,eAAO,MAAM,eAAe,cAAc,CAAC;AAC3C,eAAO,MAAM,yBAAyB,qBAAqB,CAAC;AAC5D,eAAO,MAAM,oBAAoB,mBAAmB,CAAC;AACrD,eAAO,MAAM,oBAAoB,iBAAiB,CAAC;AACnD,eAAO,MAAM,iBAAiB,sBAAsB,CAAC;AACrD,eAAO,MAAM,qBAAqB,gBAAgB,CAAC;AACnD,eAAO,MAAM,uBAAuB,UAAU,CAAC;AAC/C,eAAO,MAAM,sBAAsB,SAAS,CAAC;AAC7C,eAAO,MAAM,yBAAyB,QAAkC,CAAC;AACzE,eAAO,MAAM,cAAc,YAAY,CAAC;AACxC,eAAO,MAAM,WAAW,SAAS,CAAC;AAClC,eAAO,MAAM,iBAAiB,kBAAkB,CAAC;AAEjD,eAAO,MAAM,UAAU,QAAwB,CAAC;AAChD,eAAO,MAAM,UAAU,QAAwB,CAAC;AAChD,eAAO,MAAM,YAAY,QAAY,CAAC;AACtC,eAAO,MAAM,kBAAkB,QAAO,CAAC;AAEvC,eAAO,MAAM,cAAc,SAAS,CAAC;AACrC,eAAO,MAAM,cAAc,QAAQ,CAAC;AACpC,eAAO,MAAM,oBAAoB,aAAa,CAAC"}

package/dist/{path_constants.js → constants.js}

@@ -30,3 +30,6 @@ export const TS_MATCHER = /\.(ts|tsx|mts|cts)$/;
 export const JS_MATCHER = /\.(js|jsx|mjs|cjs)$/;
 export const JSON_MATCHER = /\.json$/;
 export const EVERYTHING_MATCHER = /.*/;
+export const JS_CLI_DEFAULT = 'node';
+export const PM_CLI_DEFAULT = 'npm';
+export const PRETTIER_CLI_DEFAULT = 'prettier';

package/dist/deploy.task.js

@@ -7,7 +7,7 @@ import { join, resolve } from 'node:path';
 import { existsSync, readdirSync } from 'node:fs';
 import { Task_Error } from './task.js';
 import { print_path } from './paths.js';
-import { GRO_DIRNAME, GIT_DIRNAME, SVELTEKIT_BUILD_DIRNAME } from './path_constants.js';
+import { GRO_DIRNAME, GIT_DIRNAME, SVELTEKIT_BUILD_DIRNAME } from './constants.js';
 import { empty_dir } 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

package/dist/dev.task.js

@@ -13,7 +13,7 @@ export const Args = z
     'no-sync': z.boolean({ description: 'opt out of gro sync' }).default(false),
     install: z.boolean({ description: 'dual of no-install' }).default(true),
     'no-install': z // convenience, same as `gro dev -- gro sync --no-install` but the latter takes precedence
-        .boolean({ description: 'opt out of `npm install` before starting the dev server' })
+        .boolean({ description: 'opt out of installing packages before starting the dev server' })
         .default(false),
 })
     .strict();

package/dist/esbuild_plugin_svelte.js

@@ -5,7 +5,7 @@ import { relative } from 'node:path';
 import { SVELTE_MATCHER, SVELTE_RUNES_MATCHER } from './svelte_helpers.js';
 import { to_define_import_meta_env, default_ts_transform_options } from './esbuild_helpers.js';
 import { default_sveltekit_config, to_default_compile_module_options, } from './sveltekit_config.js';
-import { TS_MATCHER } from './path_constants.js';
+import { TS_MATCHER } from './constants.js';
 export const esbuild_plugin_svelte = (options) => {
     const { dev, base_url, dir = process.cwd(), svelte_compile_options = default_sveltekit_config.svelte_compile_options, svelte_compile_module_options = to_default_compile_module_options(svelte_compile_options), svelte_preprocessors, ts_transform_options = default_ts_transform_options, is_ts = (f) => TS_MATCHER.test(f), } = options;
     const final_ts_transform_options = {

package/dist/esbuild_plugin_sveltekit_local_imports.js

@@ -1,7 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { resolve_specifier } from './resolve_specifier.js';
-import { EVERYTHING_MATCHER } from './path_constants.js';
+import { EVERYTHING_MATCHER } from './constants.js';
 /**
  * Adds support for imports to both `.ts` and `.js`,
  * as well as imports without extensions that resolve to `.js` or `.ts`.

package/dist/esbuild_plugin_sveltekit_shim_app.js

@@ -1,5 +1,5 @@
 import { render_sveltekit_shim_app_environment, render_sveltekit_shim_app_paths, sveltekit_shim_app_specifiers, } from './sveltekit_shim_app.js';
-import { EVERYTHING_MATCHER } from './path_constants.js';
+import { EVERYTHING_MATCHER } from './constants.js';
 export const esbuild_plugin_sveltekit_shim_app = ({ dev, base_url, assets_url, }) => ({
     name: 'sveltekit_shim_app',
     setup: (build) => {

package/dist/esbuild_plugin_sveltekit_shim_env.js

@@ -1,5 +1,5 @@
 import { render_env_shim_module } from './sveltekit_shim_env.js';
-import { EVERYTHING_MATCHER } from './path_constants.js';
+import { EVERYTHING_MATCHER } from './constants.js';
 import { SVELTEKIT_ENV_MATCHER } from './sveltekit_helpers.js';
 const namespace = 'sveltekit_shim_env';
 export const esbuild_plugin_sveltekit_shim_env = ({ dev, public_prefix, private_prefix, env_dir, env_files, ambient_env, }) => ({

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

@@ -1 +1 @@
-{"version":3,"file":"format.task.d.ts","sourceRoot":"../src/lib/","sources":["format.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAIhD,eAAO,MAAM,IAAI;;;;;;EAMP,CAAC;AACX,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAa3B,CAAC"}
+{"version":3,"file":"format.task.d.ts","sourceRoot":"../src/lib/","sources":["format.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAIhD,eAAO,MAAM,IAAI;;;;;;EAMP,CAAC;AACX,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAqB3B,CAAC"}

package/dist/format.task.js

@@ -13,10 +13,10 @@ export const Args = z
 export const task = {
     summary: 'format source files',
     Args,
-    run: async ({ args, log }) => {
+    run: async ({ args, log, config }) => {
         const { check } = args;
         // TODO forward prettier args
-        const format_result = await format_directory(log, paths.source, check);
+        const format_result = await format_directory(log, paths.source, check, undefined, undefined, undefined, config.pm_cli);
         if (!format_result.ok) {
             throw new Task_Error(`Failed ${check ? 'formatting check' : 'to format'}. ${print_spawn_result(format_result)}`);
         }

package/dist/format_directory.d.ts

@@ -7,5 +7,5 @@ import { type Cli } from './cli.js';
  * 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, prettier_cli?: string | Cli) => Promise<Spawn_Result>;
+export declare const format_directory: (log: Logger, dir: string, check?: boolean, extensions?: string, root_paths?: string, prettier_cli?: string | Cli, pm_cli?: string) => Promise<Spawn_Result>;
 //# sourceMappingURL=format_directory.d.ts.map

package/dist/format_directory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format_directory.d.ts","sourceRoot":"../src/lib/","sources":["format_directory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAYlD,OAAO,EAAyB,KAAK,GAAG,EAAC,MAAM,UAAU,CAAC;AAc1D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,QACvB,MAAM,OACN,MAAM,4EAIG,MAAM,GAAG,GAAG,KACxB,OAAO,CAAC,YAAY,CActB,CAAC"}
+{"version":3,"file":"format_directory.d.ts","sourceRoot":"../src/lib/","sources":["format_directory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAclD,OAAO,EAAyB,KAAK,GAAG,EAAC,MAAM,UAAU,CAAC;AAY1D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,QACvB,MAAM,OACN,MAAM,4EAIG,MAAM,GAAG,GAAG,WAClB,MAAM,KACZ,OAAO,CAAC,YAAY,CActB,CAAC"}

package/dist/format_directory.js

@@ -1,10 +1,9 @@
 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 { GITHUB_DIRNAME, README_FILENAME, SVELTEKIT_CONFIG_FILENAME, VITE_CONFIG_FILENAME, TSCONFIG_FILENAME, GRO_CONFIG_PATH, PM_CLI_DEFAULT, PRETTIER_CLI_DEFAULT, } from './constants.js';
 import { serialize_args, to_forwarded_args } from './args.js';
 import { spawn_cli, to_cli_name } from './cli.js';
-const PRETTIER_CLI = 'prettier';
-const DEFAULT_EXTENSIONS = 'ts,js,json,svelte,html,css,md,yml';
-const DEFAULT_ROOT_PATHS = `${[
+const EXTENSIONS_DEFAULT = 'ts,js,json,svelte,html,css,md,yml';
+const ROOT_PATHS_DEFAULT = `${[
     README_FILENAME,
     GRO_CONFIG_PATH,
     SVELTEKIT_CONFIG_FILENAME,
@@ -18,7 +17,7 @@ const DEFAULT_ROOT_PATHS = `${[
  * 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, prettier_cli = PRETTIER_CLI) => {
+export const format_directory = async (log, dir, check = false, extensions = EXTENSIONS_DEFAULT, root_paths = ROOT_PATHS_DEFAULT, prettier_cli = PRETTIER_CLI_DEFAULT, pm_cli = PM_CLI_DEFAULT) => {
     const forwarded_args = to_forwarded_args(to_cli_name(prettier_cli));
     forwarded_args[check ? 'check' : 'write'] = true;
     const serialized_args = serialize_args(forwarded_args);
@@ -28,6 +27,6 @@ export const format_directory = async (log, dir, check = false, extensions = DEF
     }
     const spawned = await spawn_cli(prettier_cli, serialized_args, log);
     if (!spawned)
-        throw new Error(`failed to find \`${to_cli_name(prettier_cli)}\` CLI locally or globally, do you need to run \`npm i\`?`);
+        throw new Error(`failed to find \`${to_cli_name(prettier_cli)}\` CLI locally or globally, do you need to run \`${pm_cli} install\`?`);
     return spawned;
 };

package/dist/gen.task.js

@@ -9,7 +9,7 @@ import { format_file } from './format_file.js';
 import { print_path } from './paths.js';
 import { log_error_reasons } from './task_logging.js';
 import { write_gen_results, analyze_gen_results, find_genfiles, load_genfiles } from './gen.js';
-import { SOURCE_DIRNAME } from './path_constants.js';
+import { SOURCE_DIRNAME } from './constants.js';
 export const Args = z
     .object({
     _: z.array(Raw_Input_Path, { description: 'input paths to generate' }).default([SOURCE_DIRNAME]),

package/dist/gro_config.d.ts

@@ -27,6 +27,10 @@ export interface Gro_Config {
      * directories and files are included if they pass all of these filters.
      */
     search_filters: Path_Filter[];
+    /**
+     * 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'`.
      */
@@ -42,6 +46,7 @@ export interface Raw_Gro_Config {
     map_package_json?: Map_Package_Json | null;
     task_root_dirs?: string[];
     search_filters?: Path_Filter | Path_Filter[] | null;
+    js_cli?: string;
     pm_cli?: string;
 }
 export type Create_Gro_Config = (base_config: Gro_Config) => Raw_Gro_Config | Promise<Raw_Gro_Config>;
@@ -52,8 +57,8 @@ export declare const create_empty_gro_config: () => Gro_Config;
  * Customize via `search_filters` in the `Gro_Config`.
  * See the test cases for the exact behavior.
  */
-export declare const DEFAULT_SEARCH_EXCLUDER: RegExp;
-export declare const DEFAULT_EXPORTS_EXCLUDER: RegExp;
+export declare const SEARCH_EXCLUDER_DEFAULT: RegExp;
+export declare const EXPORTS_EXCLUDER_DEFAULT: RegExp;
 /**
  * Transforms a `Raw_Gro_Config` to the more strict `Gro_Config`.
  * This allows users to provide a more relaxed config.

package/dist/gro_config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro_config.d.ts","sourceRoot":"../src/lib/","sources":["gro_config.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAC,WAAW,EAAE,OAAO,EAAC,MAAM,WAAW,CAAC;AAEpD;;;;GAIG;AACH,MAAM,WAAW,UAAU;IAC1B;;OAEG;IACH,OAAO,EAAE,qBAAqB,CAAC;IAC/B;;;;OAIG;IACH,gBAAgB,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC1C;;;OAGG;IACH,cAAc,EAAE,OAAO,EAAE,CAAC;IAC1B;;;OAGG;IACH,cAAc,EAAE,WAAW,EAAE,CAAC;IAC9B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC9B,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAChC,gBAAgB,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC3C,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,WAAW,GAAG,WAAW,EAAE,GAAG,IAAI,CAAC;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,iBAAiB,GAAG,CAC/B,WAAW,EAAE,UAAU,KACnB,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;AAE9C,eAAO,MAAM,uBAAuB,QAAO,UAWzC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,QAUnC,CAAC;AAWF,eAAO,MAAM,wBAAwB,QAAwD,CAAC;AAE9F;;;GAGG;AACH,eAAO,MAAM,oBAAoB,eAAgB,cAAc,KAAG,UAsBjE,CAAC;AAEF,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,iBAAiB,CAAC;CACrD;AAED,eAAO,MAAM,eAAe,oBAA6B,OAAO,CAAC,UAAU,CAiB1E,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,CACxC,aAAa,EAAE,GAAG,EAClB,WAAW,EAAE,MAAM,KACf,OAAO,CAAC,aAAa,IAAI,iBAS7B,CAAC"}
+{"version":3,"file":"gro_config.d.ts","sourceRoot":"../src/lib/","sources":["gro_config.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAC,WAAW,EAAE,OAAO,EAAC,MAAM,WAAW,CAAC;AAEpD;;;;GAIG;AACH,MAAM,WAAW,UAAU;IAC1B;;OAEG;IACH,OAAO,EAAE,qBAAqB,CAAC;IAC/B;;;;OAIG;IACH,gBAAgB,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC1C;;;OAGG;IACH,cAAc,EAAE,OAAO,EAAE,CAAC;IAC1B;;;OAGG;IACH,cAAc,EAAE,WAAW,EAAE,CAAC;IAC9B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC9B,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAChC,gBAAgB,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC3C,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,WAAW,GAAG,WAAW,EAAE,GAAG,IAAI,CAAC;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,iBAAiB,GAAG,CAC/B,WAAW,EAAE,UAAU,KACnB,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;AAE9C,eAAO,MAAM,uBAAuB,QAAO,UAYzC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,QAUnC,CAAC;AAWF,eAAO,MAAM,wBAAwB,QAAwD,CAAC;AAE9F;;;GAGG;AACH,eAAO,MAAM,oBAAoB,eAAgB,cAAc,KAAG,UAwBjE,CAAC;AAEF,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,iBAAiB,CAAC;CACrD;AAED,eAAO,MAAM,eAAe,oBAA6B,OAAO,CAAC,UAAU,CAiB1E,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,CACxC,aAAa,EAAE,GAAG,EAClB,WAAW,EAAE,MAAM,KACf,OAAO,CAAC,aAAa,IAAI,iBAS7B,CAAC"}

package/dist/gro_config.js

@@ -1,7 +1,7 @@
 import { join, resolve } from 'node:path';
 import { existsSync } from 'node:fs';
 import { GRO_DIST_DIR, IS_THIS_GRO, paths } from './paths.js';
-import { GRO_CONFIG_PATH, NODE_MODULES_DIRNAME, SERVER_DIST_PATH, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_DIST_DIRNAME, } from './path_constants.js';
+import { GRO_CONFIG_PATH, JS_CLI_DEFAULT, NODE_MODULES_DIRNAME, PM_CLI_DEFAULT, SERVER_DIST_PATH, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_DIST_DIRNAME, } from './constants.js';
 import create_default_config from './gro.config.default.js';
 export const create_empty_gro_config = () => ({
     plugins: () => [],
@@ -12,8 +12,9 @@ export const create_empty_gro_config = () => ({
         IS_THIS_GRO ? null : paths.root,
         IS_THIS_GRO ? null : GRO_DIST_DIR,
     ].filter((v) => v !== null),
-    search_filters: [(id) => !DEFAULT_SEARCH_EXCLUDER.test(id)],
-    pm_cli: 'npm',
+    search_filters: [(id) => !SEARCH_EXCLUDER_DEFAULT.test(id)],
+    js_cli: JS_CLI_DEFAULT,
+    pm_cli: PM_CLI_DEFAULT,
 });
 /**
  * The regexp used by default to exclude directories and files
@@ -21,7 +22,7 @@ export const create_empty_gro_config = () => ({
  * Customize via `search_filters` in the `Gro_Config`.
  * See the test cases for the exact behavior.
  */
-export const DEFAULT_SEARCH_EXCLUDER = new RegExp(`(${'(^|/)\\.[^/]+' + // exclude all `.`-prefixed directories
+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
@@ -30,11 +31,11 @@ export const DEFAULT_SEARCH_EXCLUDER = new RegExp(`(${'(^|/)\\.[^/]+' + // exclu
 })($|/)`, 'u');
 const default_map_package_json = (package_json) => {
     if (package_json.exports) {
-        package_json.exports = Object.fromEntries(Object.entries(package_json.exports).filter(([k]) => !DEFAULT_EXPORTS_EXCLUDER.test(k)));
+        package_json.exports = Object.fromEntries(Object.entries(package_json.exports).filter(([k]) => !EXPORTS_EXCLUDER_DEFAULT.test(k)));
     }
     return package_json;
 };
-export const DEFAULT_EXPORTS_EXCLUDER = /(\.md|\.(test|ignore)\.|\/(test|fixtures|ignore)\/)/;
+export const EXPORTS_EXCLUDER_DEFAULT = /(\.md|\.(test|ignore)\.|\/(test|fixtures|ignore)\/)/;
 /**
  * Transforms a `Raw_Gro_Config` to the more strict `Gro_Config`.
  * This allows users to provide a more relaxed config.
@@ -43,7 +44,7 @@ export const normalize_gro_config = (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, pm_cli = empty_config.pm_cli, } = raw_config;
+    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, } = raw_config;
     return {
         plugins,
         map_package_json,
@@ -53,6 +54,7 @@ export const normalize_gro_config = (raw_config) => {
             : search_filters
                 ? [search_filters]
                 : [],
+        js_cli,
         pm_cli,
     };
 };

package/dist/gro_helpers.d.ts

@@ -45,5 +45,5 @@ export declare const resolve_gro_module_path: (path?: string) => string;
  * @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: string[]) => Promise<Spawn_Result>;
+export declare const spawn_with_loader: (loader_path: string, invoke_path: string, argv: string[], js_cli?: string) => Promise<Spawn_Result>;
 //# sourceMappingURL=gro_helpers.d.ts.map

package/dist/gro_helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro_helpers.d.ts","sourceRoot":"../src/lib/","sources":["gro_helpers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAQ,KAAK,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAUnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,uBAAuB,qBAAgB,MAsBnD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,gBAChB,MAAM,eACN,MAAM,QACb,MAAM,EAAE,KACZ,OAAO,CAAC,YAAY,CAgBtB,CAAC"}
+{"version":3,"file":"gro_helpers.d.ts","sourceRoot":"../src/lib/","sources":["gro_helpers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAQ,KAAK,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAUnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,uBAAuB,qBAAgB,MAsBnD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,gBAChB,MAAM,eACN,MAAM,QACb,MAAM,EAAE,sBAEZ,OAAO,CAAC,YAAY,CAgBtB,CAAC"}

package/dist/gro_helpers.js

@@ -2,7 +2,7 @@ import { realpathSync, existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from '@ryanatkn/belt/process.js';
-import { NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME } from './path_constants.js';
+import { JS_CLI_DEFAULT, NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME } from './constants.js';
 /*
 
 This module is intended to have minimal dependencies to avoid over-imports in the CLI.
@@ -74,7 +74,7 @@ export const resolve_gro_module_path = (path = '') => {
  * @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) => {
+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.
@@ -89,5 +89,5 @@ export const spawn_with_loader = (loader_path, invoke_path, argv) => {
         args.push('-C', 'development'); // same as `--conditions`
     }
     args.push(invoke_path, ...argv);
-    return spawn('node', args);
+    return spawn(js_cli, args);
 };

package/dist/gro_plugin_server.js

@@ -6,7 +6,7 @@ import { strip_before, strip_end } from '@ryanatkn/belt/string.js';
 import { existsSync } from 'node:fs';
 import { throttle } from '@ryanatkn/belt/throttle.js';
 import { base_path_to_path_id, LIB_DIRNAME, paths } from './paths.js';
-import { GRO_DEV_DIRNAME, SERVER_DIST_PATH } from './path_constants.js';
+import { GRO_DEV_DIRNAME, SERVER_DIST_PATH } from './constants.js';
 import { watch_dir } from './watch_dir.js';
 import { init_sveltekit_config, default_sveltekit_config } from './sveltekit_config.js';
 import { esbuild_plugin_sveltekit_shim_app } from './esbuild_plugin_sveltekit_shim_app.js';
@@ -28,7 +28,7 @@ export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = pro
     outdir: join(dir, dev ? GRO_DEV_DIRNAME : SERVER_DIST_PATH),
     outbase: paths.lib,
     outname: 'server/server.js',
-}), env_files, ambient_env, sveltekit_config, target = 'esnext', esbuild_build_options = identity, rebuild_throttle_delay = 1000, cli_command = 'node', run, // `dev` default is not available in this scope
+}), env_files, ambient_env, sveltekit_config, target = 'esnext', esbuild_build_options = identity, rebuild_throttle_delay = 1000, cli_command, run, // `dev` default is not available in this scope
  } = {}) => {
     let build_ctx = null;
     let watcher = null;
@@ -36,7 +36,7 @@ export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = pro
     let deps = null;
     return {
         name: 'gro_plugin_server',
-        setup: async ({ dev, watch, timings, log }) => {
+        setup: async ({ dev, watch, timings, log, config }) => {
             const parsed_sveltekit_config = !sveltekit_config && strip_end(dir, '/') === process.cwd()
                 ? default_sveltekit_config
                 : await init_sveltekit_config(sveltekit_config ?? dir);
@@ -141,7 +141,7 @@ export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = pro
                     cli_args.push('-C', 'development'); // same as `--conditions`
                 }
                 cli_args.push(server_outpath);
-                server_process = spawn_restartable_process(cli_command, cli_args);
+                server_process = spawn_restartable_process(cli_command ?? config.js_cli, cli_args);
             }
         },
         teardown: async () => {

package/dist/gro_plugin_sveltekit_app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro_plugin_sveltekit_app.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_sveltekit_app.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,OAAO,EAAyB,KAAK,gBAAgB,EAAoB,MAAM,mBAAmB,CAAC;AAGnG,OAAO,EAAC,KAAK,YAAY,EAAsC,MAAM,eAAe,CAAC;AAMrF,MAAM,WAAW,OAAO;IACvB;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;;OAGG;IACH,uBAAuB,CAAC,EAAE,OAAO,GAAG,gBAAgB,CAAC;IAErD;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,GAAG,YAAY,CAAC;IAE7C;;;OAGG;IACH,oBAAoB,CAAC,EAAE,OAAO,GAAG,gBAAgB,CAAC;IAClD;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE7D,MAAM,MAAM,gBAAgB,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;AAE9D,eAAO,MAAM,wBAAwB,oGAMlC,OAAO,KAAQ,MA2GjB,CAAC"}
+{"version":3,"file":"gro_plugin_sveltekit_app.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_sveltekit_app.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,OAAO,EAAyB,KAAK,gBAAgB,EAAoB,MAAM,mBAAmB,CAAC;AAGnG,OAAO,EAAC,KAAK,YAAY,EAAsC,MAAM,eAAe,CAAC;AAMrF,MAAM,WAAW,OAAO;IACvB;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;;OAGG;IACH,uBAAuB,CAAC,EAAE,OAAO,GAAG,gBAAgB,CAAC;IAErD;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,GAAG,YAAY,CAAC;IAE7C;;;OAGG;IACH,oBAAoB,CAAC,EAAE,OAAO,GAAG,gBAAgB,CAAC;IAClD;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE7D,MAAM,MAAM,gBAAgB,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;AAE9D,eAAO,MAAM,wBAAwB,oGAMlC,OAAO,KAAQ,MA6GjB,CAAC"}

package/dist/gro_plugin_sveltekit_app.js

@@ -5,18 +5,18 @@ import { serialize_package_json, load_package_json } from './package_json.js';
 import { Task_Error } from './task.js';
 import { find_cli, spawn_cli, spawn_cli_process } from './cli.js';
 import { serialize_src_json, create_src_json } from './src_json.js';
-import { DEFAULT_EXPORTS_EXCLUDER } from './gro_config.js';
+import { EXPORTS_EXCLUDER_DEFAULT } from './gro_config.js';
 import { default_sveltekit_config } from './sveltekit_config.js';
-import { SOURCE_DIRNAME } from './path_constants.js';
+import { SOURCE_DIRNAME } from './constants.js';
 import { VITE_CLI } from './sveltekit_helpers.js';
 export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_known_package_json, well_known_src_json, well_known_src_files, vite_cli = VITE_CLI, } = {}) => {
     let sveltekit_process = undefined;
     return {
         name: 'gro_plugin_sveltekit_app',
-        setup: async ({ dev, watch, log }) => {
+        setup: async ({ dev, watch, log, config }) => {
             const found_vite_cli = find_cli(vite_cli);
             if (!found_vite_cli)
-                throw new Error(`Failed to find Vite CLI \`${vite_cli}\`, do you need to run \`npm i\`?`);
+                throw new Error(`Failed to find Vite CLI \`${vite_cli}\`, do you need to run \`${config.pm_cli} i\`?`);
             if (dev) {
                 // `vite dev` in development mode
                 if (watch) {
@@ -67,7 +67,7 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
                         : null,
                     serialized_src_json && well_known_src_files
                         ? copy_temporarily(SOURCE_DIRNAME, assets_path, '.well-known', well_known_src_files === true
-                            ? (file_path) => !DEFAULT_EXPORTS_EXCLUDER.test(file_path)
+                            ? (file_path) => !EXPORTS_EXCLUDER_DEFAULT.test(file_path)
                             : well_known_src_files)
                         : null,
                     /**

package/dist/gro_plugin_sveltekit_library.js

@@ -5,14 +5,14 @@ import { SVELTE_PACKAGE_CLI, run_svelte_package, } from './sveltekit_helpers.js'
 export const gro_plugin_sveltekit_library = ({ svelte_package_options, svelte_package_cli = SVELTE_PACKAGE_CLI, } = {}) => {
     return {
         name: 'gro_plugin_sveltekit_library',
-        setup: async ({ dev, log }) => {
+        setup: async ({ dev, log, config }) => {
             if (!dev) {
-                await run_svelte_package(svelte_package_options, svelte_package_cli, log);
+                await run_svelte_package(svelte_package_options, svelte_package_cli, log, config.pm_cli);
             }
         },
         adapt: async ({ log, timings, config }) => {
             const package_json = load_package_json();
-            // `npm link`
+            // link the CLI binaries if they exist
             if (package_json.bin) {
                 const timing_to_link = timings.start(`${config.pm_cli} link`);
                 await Promise.all(Object.values(package_json.bin).map(async (bin_path) => {

package/dist/loader.js

@@ -9,7 +9,7 @@ import { render_sveltekit_shim_app_environment, render_sveltekit_shim_app_paths,
 import { default_sveltekit_config } from './sveltekit_config.js';
 import { SVELTE_MATCHER, SVELTE_RUNES_MATCHER } from './svelte_helpers.js';
 import { IS_THIS_GRO, paths } from './paths.js';
-import { JSON_MATCHER, NODE_MODULES_DIRNAME, TS_MATCHER } from './path_constants.js';
+import { JSON_MATCHER, NODE_MODULES_DIRNAME, TS_MATCHER } from './constants.js';
 import { to_define_import_meta_env, default_ts_transform_options } from './esbuild_helpers.js';
 import { resolve_specifier } from './resolve_specifier.js';
 import { resolve_node_specifier } from './resolve_node_specifier.js';

package/dist/module.js

@@ -1,5 +1,5 @@
 import { LIB_DIRNAME } from './paths.js';
-import { SOURCE_DIR, SOURCE_DIRNAME } from './path_constants.js';
+import { SOURCE_DIR, SOURCE_DIRNAME } from './constants.js';
 export const MODULE_PATH_SRC_PREFIX = SOURCE_DIR;
 export const MODULE_PATH_LIB_PREFIX = `$${LIB_DIRNAME}/`;
 const INTERNAL_MODULE_MATCHER = new RegExp(`^(\\.?\\.?|${SOURCE_DIRNAME}|\\$${LIB_DIRNAME})\\/`, 'u');

package/dist/moss_helpers.d.ts

@@ -1,7 +1,7 @@
 import type { Result } from '@ryanatkn/belt/result.js';
 import { type Package_Json } from './package_json.js';
 export declare const MOSS_PACKAGE_DEP_NAME = "@ryanatkn/moss";
-export declare const load_moss_plugin: (package_json?: Package_Json, dep_name?: string, plugin_path?: string, local_plugin_path?: string) => Promise<Result<{
+export declare const load_moss_plugin: (package_json?: Package_Json, dep_name?: string, plugin_path?: string, local_plugin_path?: string, pm_cli?: string) => Promise<Result<{
     gro_plugin_moss: any;
 }, {
     message: string;

package/dist/moss_helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"moss_helpers.d.ts","sourceRoot":"../src/lib/","sources":["moss_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAIrD,OAAO,EAAU,KAAK,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAG7D,eAAO,MAAM,qBAAqB,mBAAmB,CAAC;AAGtD,eAAO,MAAM,gBAAgB,kBACb,YAAY,0EAIzB,OAAO,CAAC,MAAM,CAAC;IAAC,eAAe,EAAE,GAAG,CAAA;CAAC,EAAE;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CA4B3D,CAAC"}
+{"version":3,"file":"moss_helpers.d.ts","sourceRoot":"../src/lib/","sources":["moss_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAIrD,OAAO,EAAU,KAAK,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAG7D,eAAO,MAAM,qBAAqB,mBAAmB,CAAC;AAGtD,eAAO,MAAM,gBAAgB,kBACb,YAAY,2FAKzB,OAAO,CAAC,MAAM,CAAC;IAAC,eAAe,EAAE,GAAG,CAAA;CAAC,EAAE;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CA4B3D,CAAC"}

package/dist/moss_helpers.js

@@ -1,15 +1,15 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { has_dep } from './package_json.js';
-import { NODE_MODULES_DIRNAME } from './path_constants.js';
+import { NODE_MODULES_DIRNAME, PM_CLI_DEFAULT } from './constants.js';
 export const MOSS_PACKAGE_DEP_NAME = '@ryanatkn/moss';
 // TODO plugin type?
 export const load_moss_plugin = async (package_json, dep_name = MOSS_PACKAGE_DEP_NAME, plugin_path = `${NODE_MODULES_DIRNAME}/${dep_name}/dist/gro_plugin_moss.js`, // TODO maybe lookup from its `package_json.exports`? kinda unnecessary
-local_plugin_path = 'src/lib/gro_plugin_moss.ts') => {
+local_plugin_path = 'src/lib/gro_plugin_moss.ts', pm_cli = PM_CLI_DEFAULT) => {
     if (!has_dep(dep_name, package_json)) {
         return {
             ok: false,
-            message: `no dependency found in package.json for ${dep_name}, install it with \`npm i -D ${dep_name}\``,
+            message: `no dependency found in package.json for ${dep_name}, install it with \`${pm_cli} install -D ${dep_name}\``,
         };
     }
     let path = undefined;

package/dist/package.d.ts

@@ -137,6 +137,10 @@ export declare const package_json: {
             types: string;
             default: string;
         };
+        './constants.js': {
+            types: string;
+            default: string;
+        };
         './deploy.task.js': {
             types: string;
             default: string;
@@ -301,10 +305,6 @@ export declare const package_json: {
             types: string;
             default: string;
         };
-        './path_constants.js': {
-            types: string;
-            default: string;
-        };
         './path.js': {
             types: string;
             default: string;
@@ -532,6 +532,13 @@ export declare const src_json: {
                 kind: "variable";
             }[];
         };
+        './constants.js': {
+            path: string;
+            declarations: {
+                name: string;
+                kind: "variable";
+            }[];
+        };
         './deploy.task.js': {
             path: string;
             declarations: {
@@ -897,13 +904,6 @@ export declare const src_json: {
                 kind: "type";
             })[];
         };
-        './path_constants.js': {
-            path: string;
-            declarations: {
-                name: string;
-                kind: "variable";
-            }[];
-        };
         './path.js': {
             path: string;
             declarations: ({

package/dist/package.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAswBD,CAAC"}
+{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAywBD,CAAC"}