@ryanatkn/gro 0.112.0

package/dist/git.js

@@ -0,0 +1,200 @@
+import { spawn, spawn_out } from '@ryanatkn/belt/process.js';
+import { z } from 'zod';
+import { exists } from './fs.js';
+import { to_file_path } from './path.js';
+// TODO maybe extract to `util-git`
+export const Git_Origin = z.string();
+export const Git_Branch = z.string();
+/**
+ * Returns the current git branch name or throws if something goes wrong.
+ */
+export const git_current_branch_name = async (options) => {
+    const { stdout } = await spawn_out('git', ['rev-parse', '--abbrev-ref', 'HEAD'], options);
+    if (!stdout)
+        throw Error('git_current_branch_name failed');
+    const branch_name = stdout.toString().trim();
+    return branch_name;
+};
+/**
+ * @returns a boolean indicating if the remote git branch exists
+ */
+export const git_remote_branch_exists = async (origin = 'origin', branch, options) => {
+    const final_branch = branch ?? (await git_current_branch_name(options));
+    if (options?.cwd && !(await exists(to_file_path(options.cwd)))) {
+        return false;
+    }
+    const result = await spawn('git', ['ls-remote', '--exit-code', '--heads', origin, 'refs/heads/' + final_branch], options);
+    if (result.ok) {
+        return true;
+    }
+    else if (result.code === 2) {
+        return false;
+    }
+    else {
+        throw Error(`git_remote_branch_exists failed for origin '${origin}' and branch '${final_branch}' with code ${result.code}`);
+    }
+};
+/**
+ * @returns a boolean indicating if the local git branch exists
+ */
+export const git_local_branch_exists = async (branch, options) => {
+    if (options?.cwd && !(await exists(to_file_path(options.cwd)))) {
+        return false;
+    }
+    const result = await spawn('git', ['show-ref', '--quiet', 'refs/heads/' + branch], options);
+    return result.ok;
+};
+/**
+ * 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 or uncommitted changes, or `null` if it's clean
+ */
+export const git_check_clean_workspace = async (options) => {
+    const unstaged_result = await spawn('git', ['diff', '--exit-code', '--quiet'], options);
+    if (!unstaged_result.ok) {
+        return 'git has unstaged changes';
+    }
+    const staged_result = await spawn('git', ['diff', '--exit-code', '--cached', '--quiet'], options);
+    if (!staged_result.ok) {
+        return 'git has staged but uncommitted changes';
+    }
+    const status_result = await spawn_out('git', ['status', '--porcelain'], options);
+    if (status_result.stdout?.length) {
+        return 'git has untracked files';
+    }
+    return null;
+};
+/**
+ * Calls `git fetch` and throws if anything goes wrong.
+ */
+export const git_fetch = async (origin = 'origin', branch, options) => {
+    const args = ['fetch', origin];
+    if (branch)
+        args.push(branch);
+    const result = await spawn('git', args, options);
+    if (!result.ok) {
+        throw Error(`git_fetch failed for origin '${origin}' and branch '${branch}' with code ${result.code}`);
+    }
+};
+/**
+ * Calls `git checkout` and throws if anything goes wrong.
+ * @returns the previous branch name, if it changed
+ */
+export const git_checkout = async (branch, options) => {
+    const current_branch = await git_current_branch_name(options);
+    if (branch === current_branch) {
+        return null;
+    }
+    const result = await spawn('git', ['checkout', branch], options);
+    if (!result.ok) {
+        throw Error(`git_checkout failed for branch '${branch}' with code ${result.code}`);
+    }
+    return current_branch;
+};
+/**
+ * Calls `git pull` and throws if anything goes wrong.
+ */
+export const git_pull = async (origin = 'origin', branch, options) => {
+    const args = ['pull', origin];
+    if (branch)
+        args.push(branch);
+    const result = await spawn('git', args, options);
+    if (!result.ok) {
+        throw Error(`git_pull failed for branch '${branch}' with code ${result.code}`);
+    }
+};
+/**
+ * Calls `git push` and throws if anything goes wrong.
+ */
+export const git_push = async (origin, branch, options) => {
+    const final_branch = branch ?? (await git_current_branch_name(options));
+    const result = await spawn('git', ['push', origin, final_branch], options);
+    if (!result.ok) {
+        throw Error(`git_push failed for branch '${final_branch}' with code ${result.code}`);
+    }
+};
+/**
+ * Calls `git push` and throws if anything goes wrong.
+ */
+export const git_push_to_create = async (origin = 'origin', branch, options) => {
+    const final_branch = branch ?? (await git_current_branch_name(options));
+    const push_args = ['push'];
+    if (await git_remote_branch_exists(origin, final_branch, options)) {
+        push_args.push(origin);
+    }
+    else {
+        push_args.push('-u', origin);
+    }
+    push_args.push(final_branch);
+    const result = await spawn('git', push_args, options);
+    if (!result.ok) {
+        throw Error(`git_push failed for branch '${final_branch}' with code ${result.code}`);
+    }
+};
+/**
+ * Deletes a branch locally and throws if anything goes wrong.
+ */
+export const git_delete_local_branch = async (branch, options) => {
+    const result = await spawn('git', ['branch', '-D', branch], options);
+    if (!result.ok) {
+        throw Error(`git_delete_local_branch failed for branch '${branch}' with code ${result.code}`);
+    }
+};
+/**
+ * Deletes a branch remotely and throws if anything goes wrong.
+ */
+export const git_delete_remote_branch = async (origin, branch, options) => {
+    const result = await spawn('git', ['push', origin, ':' + branch], options);
+    if (!result.ok) {
+        throw Error(`git_delete_remote_branch failed for branch '${branch}' with code ${result.code}`);
+    }
+};
+/**
+ * Resets the `target` branch back to its first commit both locally and remotely.
+ */
+export const git_reset_branch_to_first_commit = async (origin, branch, options) => {
+    const previous_branch = await git_checkout(branch, options);
+    const first_commit_hash = await git_current_branch_first_commit_hash(options);
+    await spawn('git', ['reset', '--hard', first_commit_hash], options);
+    await spawn('git', ['push', origin, branch, '--force'], options);
+    if (previous_branch) {
+        await git_checkout(previous_branch, options);
+    }
+};
+/**
+ * Returns the branch's latest commit hash or throws if something goes wrong.
+ */
+export const git_current_commit_hash = async (branch, options) => {
+    const final_branch = branch ?? (await git_current_branch_name(options));
+    const { stdout } = await spawn_out('git', ['show-ref', '-s', final_branch], options);
+    if (!stdout)
+        return null; // TODO hack for CI
+    return stdout.toString().split('\n')[0].trim();
+};
+/**
+ * Returns the hash of the current branch's first commit or throws if something goes wrong.
+ */
+export const git_current_branch_first_commit_hash = async (options) => {
+    const { stdout } = await spawn_out('git', ['rev-list', '--max-parents=0', '--abbrev-commit', 'HEAD'], options);
+    if (!stdout)
+        throw Error('git_current_branch_first_commit_hash failed');
+    return stdout.toString().trim();
+};
+/**
+ * Returns the global git config setting for `pull.rebase`.
+ * Gro is currently written to expect `true`,
+ * but the restriction could be loosened with additional work.
+ */
+export const git_check_setting_pull_rebase = async (options) => {
+    const value = await spawn_out('git', ['config', '--global', 'pull.rebase'], options);
+    return value.stdout?.trim() === 'true';
+};
+/**
+ * Clones a branch locally to another directory and updates the origin to match the source.
+ */
+export const git_clone_locally = async (origin, branch, source_dir, target_dir, options) => {
+    await spawn('git', ['clone', '-b', branch, '--single-branch', source_dir, target_dir], options);
+    const origin_url = (await spawn_out('git', ['remote', 'get-url', origin], { ...options, cwd: source_dir })).stdout?.trim();
+    if (!origin_url)
+        throw Error('Failed to get the origin url with git in ' + source_dir);
+    await spawn('git', ['remote', 'set-url', origin, origin_url], { ...options, cwd: target_dir });
+};

package/dist/git.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/git.test.js

@@ -0,0 +1,18 @@
+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';
+test('git_current_branch_name', async () => {
+    const branch_name = await git_current_branch_name();
+    assert.ok(branch_name);
+});
+test('git_check_clean_workspace', async () => {
+    await git_check_clean_workspace();
+});
+test('git_current_commit_hash', async () => {
+    await git_current_commit_hash();
+});
+test('git_current_branch_first_commit_hash', async () => {
+    const first_commit_hash = await git_current_branch_first_commit_hash();
+    assert.ok(first_commit_hash);
+});
+test.run();

package/dist/github.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare const Github_Pull_Request: z.ZodObject<{
+    url: z.ZodString;
+    id: z.ZodNumber;
+    html_url: z.ZodString;
+    number: z.ZodNumber;
+    user: z.ZodObject<{
+        login: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        login: string;
+    }, {
+        login: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    number: number;
+    url: string;
+    id: number;
+    html_url: string;
+    user: {
+        login: string;
+    };
+}, {
+    number: number;
+    url: string;
+    id: number;
+    html_url: string;
+    user: {
+        login: string;
+    };
+}>;
+export type Github_Pull_Request = z.infer<typeof Github_Pull_Request>;
+/**
+ * @see https://docs.github.com/en/rest/commits/commits?apiVersion=2022-11-28#list-pull-requests-associated-with-a-commit
+ */
+export declare const github_fetch_commit_prs: (owner: string, repo: string, commit_sha: string, token?: string, log?: any, cache?: any, api_version?: string) => Promise<Github_Pull_Request[] | null>;

package/dist/github.js

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

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

@@ -0,0 +1,12 @@
+import type { Create_Gro_Config } from './config.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.
+ * It looks at the project and tries to do the right thing:
+ *
+ * - if `src/routes`, assumes a SvelteKit frontend
+ * - if `src/lib`, assumes a Node library
+ * - if `src/lib/server/server.ts`, assumes a Node server
+ */
+declare const config: Create_Gro_Config;
+export default config;

package/dist/gro.config.default.js

@@ -0,0 +1,31 @@
+import { has_sveltekit_library, 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';
+/**
+ * This is the default config that's passed to `gro.config.ts`
+ * if it exists in the current project, and if not, this is the final config.
+ * It looks at the project and tries to do the right thing:
+ *
+ * - if `src/routes`, assumes a SvelteKit frontend
+ * - if `src/lib`, assumes a Node library
+ * - 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(),
+    ]);
+    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' })
+            : null,
+        // TODO replace with an esbuild plugin, see the module for more
+        // import {gro_plugin_gen} from './gro_plugin_gen.js';
+        // gro_plugin_gen(),
+    ];
+    return cfg;
+};
+export default config;

package/dist/gro.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/gro.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { join } from 'node:path';
+import { resolve_gro_module_path, spawn_with_loader } from './gro_helpers.js';
+/*
+
+This file is a loader for the Gro CLI.
+Its only purpose is to import the `invoke.js` script in the correct directory.
+By using `resolve_gro_module_path` it lets the global Gro CLI defer
+to a local installation of Gro if one is available,
+and it also provides special handling for the case
+where we're running Gro inside Gro's own repo for development.
+
+*/
+const invoke_path = await resolve_gro_module_path('invoke.js');
+const loader_path = join(invoke_path, '../loader.js');
+const spawned = await spawn_with_loader(loader_path, invoke_path, process.argv.slice(2));
+if (!spawned.ok) {
+    process.exit(spawned.code || 1);
+}

package/dist/gro_helpers.d.ts

@@ -0,0 +1,43 @@
+import { type Spawn_Result } from '@ryanatkn/belt/process.js';
+/**
+ * Resolves a path to an internal Gro file.
+ * Prefers any local installation of Gro and falls back to the current CLI context.
+ *
+ * Uses heuristics to find `path`, so may fail in some rare corner cases.
+ * Currently looks for `gro.js` as a sibling to the `path` arg for detection.
+ * If this fails for your usecases, rename `gro.js` or open an issue/PR!
+ *
+ * Used by the CLI and `gro run`.
+ *
+ * case 1:
+ *
+ * We're in a directory that has a local installation of Gro at `node_modules/.bin/gro`.
+ * Use this local version instead of the global.
+ *
+ * case 2:
+ *
+ * We're running Gro inside the Gro repo itself.
+ *
+ * In this case, we use the build directory instead of dist.
+ * There's a paradox here for using Gro inside itself -
+ * ideally we use the dist directory because that's what's shipped,
+ * but the build directory has all of the tests,
+ * and loading two instances of its modules causes problems
+ * like `instanceof` checks failing.
+ * For now we'll just run from build and see if it causes any problems.
+ * There's probably a better design in here somewhere.
+ *
+ * case 3:
+ *
+ * Fall back to invoking Gro from wherever the CLI is being executed.
+ * When using the global CLI, this uses the global Gro installation.
+ *
+ */
+export declare const resolve_gro_module_path: (path?: string) => Promise<string>;
+/**
+ * Runs a file using the Gro loader.
+ *
+ * @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>;

package/dist/gro_helpers.js

@@ -0,0 +1,79 @@
+import { realpath } from 'node:fs/promises';
+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';
+/**
+ * Resolves a path to an internal Gro file.
+ * Prefers any local installation of Gro and falls back to the current CLI context.
+ *
+ * Uses heuristics to find `path`, so may fail in some rare corner cases.
+ * Currently looks for `gro.js` as a sibling to the `path` arg for detection.
+ * If this fails for your usecases, rename `gro.js` or open an issue/PR!
+ *
+ * Used by the CLI and `gro run`.
+ *
+ * case 1:
+ *
+ * We're in a directory that has a local installation of Gro at `node_modules/.bin/gro`.
+ * Use this local version instead of the global.
+ *
+ * case 2:
+ *
+ * We're running Gro inside the Gro repo itself.
+ *
+ * In this case, we use the build directory instead of dist.
+ * There's a paradox here for using Gro inside itself -
+ * ideally we use the dist directory because that's what's shipped,
+ * but the build directory has all of the tests,
+ * and loading two instances of its modules causes problems
+ * like `instanceof` checks failing.
+ * For now we'll just run from build and see if it causes any problems.
+ * There's probably a better design in here somewhere.
+ *
+ * case 3:
+ *
+ * Fall back to invoking Gro from wherever the CLI is being executed.
+ * When using the global CLI, this uses the global Gro installation.
+ *
+ */
+export const resolve_gro_module_path = async (path = '') => {
+    const gro_bin_path = resolve(NODE_MODULES_DIRNAME, '.bin/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);
+        }
+    }
+};
+/**
+ * Runs a file using the Gro loader.
+ *
+ * @param loader_path path to loader
+ * @param invoke_path path to file to spawn with `node`
+ */
+export const spawn_with_loader = async (loader_path, invoke_path, argv) => spawn('node', [
+    '--import',
+    `data:text/javascript,
+			import {register} from "node:module";
+			import {pathToFileURL} from "node:url";
+			register("${loader_path}", pathToFileURL("./"));`,
+    '--enable-source-maps',
+    invoke_path,
+    ...argv,
+]);

package/dist/gro_plugin_gen.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin, Plugin_Context } from './plugin.js';
+import type { Args } from './args.js';
+export interface Task_Args extends Args {
+    watch?: boolean;
+}
+export declare const plugin: () => Plugin<Plugin_Context<Task_Args>>;

package/dist/gro_plugin_gen.js

@@ -0,0 +1,80 @@
+// TODO this became unused with https://github.com/ryanatkn/gro/pull/382
+// because we no longer have a normal system build - replace with an esbuild plugin
+// @ts-nocheck
+import { spawn } from '@ryanatkn/belt/process.js';
+import { source_id_to_base_path } from './paths.js';
+import { find_gen_modules, is_gen_path } from './gen_module.js';
+import { filter_dependents } from './build/source_file.js';
+import { throttle } from './throttle.js';
+const FLUSH_DEBOUNCE_DELAY = 500;
+export const plugin = () => {
+    let generating = false;
+    let regen = false;
+    let on_filer_build;
+    const queued_files = new Set();
+    const queue_gen = (gen_file_name) => {
+        queued_files.add(gen_file_name);
+        void flush_gen_queue();
+    };
+    const flush_gen_queue = throttle(async () => {
+        // hacky way to avoid concurrent `gro gen` calls
+        if (generating) {
+            regen = true;
+            return;
+        }
+        generating = true;
+        const files = Array.from(queued_files);
+        queued_files.clear();
+        await gen(files);
+        generating = false;
+        if (regen) {
+            regen = false;
+            void flush_gen_queue();
+        }
+    }, FLUSH_DEBOUNCE_DELAY);
+    const gen = (files = []) => spawn('npx', ['gro', 'gen', ...files]);
+    return {
+        name: 'gro_plugin_gen',
+        setup: async ({ args: { watch }, dev, log }) => {
+            // For production builds, we assume `gen` is already fresh,
+            // which should be checked by CI via `gro check` which calls `gro gen --check`.
+            if (!dev)
+                return;
+            // Run `gen`, first checking if there are any modules to avoid a console error.
+            // Some parts of the build may have already happened,
+            // making us miss `build` events for gen dependencies,
+            // so we run `gen` here even if it's usually wasteful.
+            const found = await find_gen_modules();
+            if (found.ok && found.source_ids_by_input_path.size > 0) {
+                await gen();
+            }
+            // Do we need to just generate everything once and exit?
+            // TODO could we have an esbuild context here? problem is watching the right files, maybe a plugin that tracks deps
+            if (!filer || !watch) {
+                log.info('generating and exiting early');
+                return;
+            }
+            // When a file builds, check it and its tree of dependents
+            // for any `.gen.` files that need to run.
+            on_filer_build = async ({ source_file, build_config }) => {
+                // TODO how to handle this now? the loader traces deps for us with `parentPath`,
+                // but we probably want to make this an esbuild plugin instead
+                // if (build_config.name !== 'system') return;
+                if (is_gen_path(source_file.id)) {
+                    queue_gen(source_id_to_base_path(source_file.id));
+                }
+                const dependent_gen_file_ids = filter_dependents(source_file, build_config, filer.find_by_id, // cast because we can assume they're all `SourceFile`s
+                is_gen_path);
+                for (const dependent_gen_file_id of dependent_gen_file_ids) {
+                    queue_gen(source_id_to_base_path(dependent_gen_file_id));
+                }
+            };
+            filer.on('build', on_filer_build);
+        },
+        teardown: async ({ filer }) => {
+            if (on_filer_build && filer) {
+                filer.off('build', on_filer_build);
+            }
+        },
+    };
+};

package/dist/gro_plugin_server.d.ts

@@ -0,0 +1,77 @@
+import * as esbuild from 'esbuild';
+import type { Config as SvelteKitConfig } from '@sveltejs/kit';
+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 interface Options {
+    /**
+     * same as esbuild's `entryPoints`
+     */
+    entry_points?: string[];
+    /**
+     * @default cwd
+     */
+    dir?: string;
+    /**
+     * Returns the `Outpaths` given a `dev` param.
+     * Decoupling this from plugin creation allows it to be created generically,
+     * so the build and dev tasks can be the source of truth for `dev`.
+     */
+    outpaths?: Create_Outpaths;
+    /**
+     * @default SvelteKit's `.env`, `.env.development`, and `.env.production`
+     */
+    env_files?: string[];
+    /**
+     * @default process.env
+     */
+    ambient_env?: Record<string, string>;
+    /**
+     * @default loaded from `${cwd}/${SVELTEKIT_CONFIG_FILENAME}`
+     */
+    sveltekit_config?: SvelteKitConfig;
+    /**
+     * @default 'esnext'
+     */
+    target?: string;
+    /**
+     * Optionally map the esbuild options.
+     * @default identity
+     */
+    esbuild_build_options?: (base_options: esbuild.BuildOptions) => esbuild.BuildOptions;
+    /**
+     * Milliseconds to throttle rebuilds.
+     * Should be longer than it takes to build to avoid backpressure.
+     * @default 1000
+     */
+    rebuild_throttle_delay?: number;
+    /**
+     * The CLI command to run the server, like `'node'` or `'bun'` or `'deno'`.
+     * Receives the path to the server js file as its argument.
+     * @default 'node'
+     */
+    cli_command?: string;
+    /**
+     * Whether to run the server or not after building.
+     * @default dev
+     */
+    run?: boolean;
+}
+export interface Outpaths {
+    /**
+     * @default '.gro/dev' or 'dist_server'
+     */
+    outdir: string;
+    /**
+     * @default 'src/lib'
+     */
+    outbase: string;
+    /**
+     * @default 'server.js'
+     */
+    outname: string;
+}
+export interface Create_Outpaths {
+    (dev: boolean): Outpaths;
+}
+export declare const gro_plugin_server: ({ entry_points, dir, outpaths, env_files, ambient_env, sveltekit_config, target, esbuild_build_options, rebuild_throttle_delay, cli_command, run, }?: Options) => Plugin<Plugin_Context>;