@fuzdev/gro 0.192.0

package/dist/parse_imports.js

@@ -0,0 +1,140 @@
+import { parseSync } from 'oxc-parser';
+import { UnreachableError } from '@fuzdev/fuz_util/error.js';
+import { JS_MATCHER, TS_MATCHER, SVELTE_MATCHER, SVELTE_SCRIPT_MATCHER } from "./constants.js";
+// TODO this is probably way more complicated that it should be, maybe report the issues upstream unless I made a mistake here
+/**
+ * Extracts the string value from a module request, handling different quote styles.
+ * Returns null if the value is not a valid string literal.
+ */
+const extract_string_literal = (content, start, end) => {
+    const value = content.substring(start, end);
+    // Check if it's a string literal (starts and ends with quotes)
+    if ((value.startsWith("'") && value.endsWith("'")) ||
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith('`') && value.endsWith('`'))) {
+        // Remove the quotes
+        return value.slice(1, -1);
+    }
+    // Not a valid string literal
+    return null;
+};
+export const parse_imports = (id, contents, ignore_types = true) => {
+    const specifiers = [];
+    const is_svelte = SVELTE_MATCHER.test(id);
+    const parse_from = (s) => {
+        const parsed = parseSync(is_svelte ? id + '.ts' : id, s, {});
+        // Process static imports
+        for (const static_import of parsed.module.staticImports) {
+            // Get the module source node
+            const import_decl = parsed.program.body.find((node) => node.type === 'ImportDeclaration' && node.start === static_import.start);
+            if (!import_decl?.source)
+                continue;
+            // Extract the module request string value
+            const value = extract_string_literal(s, import_decl.source.start, import_decl.source.end);
+            if (!value)
+                continue;
+            // Skip type-only imports if ignore_types is true
+            if (ignore_types) {
+                // Handle import type {...} (type-only imports)
+                if (import_decl.importKind === 'type') {
+                    continue;
+                }
+                // Handle inline type imports ({type foo})
+                if (static_import.entries.length > 0) {
+                    // If all imports are type imports, skip this import
+                    const has_non_type_specifier = static_import.entries.some((entry) => !entry.isType);
+                    if (!has_non_type_specifier) {
+                        continue;
+                    }
+                }
+            }
+            specifiers.push(value);
+        }
+        // Process dynamic imports
+        for (const dynamic_import of parsed.module.dynamicImports) {
+            // Find the corresponding AST node
+            let found = false;
+            for (const node of parsed.program.body) {
+                if (node.type === 'ExpressionStatement' &&
+                    node.expression.type === 'AwaitExpression' &&
+                    node.expression.argument.type === 'ImportExpression') {
+                    const import_expr = node.expression.argument;
+                    if (import_expr.start === dynamic_import.start) {
+                        // Only process string literals (not expressions or variables)
+                        if (import_expr.source.type === 'Literal') {
+                            const value = String(import_expr.source.value);
+                            if (value) {
+                                specifiers.push(value);
+                            }
+                        }
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            // If we didn't find a match through AST, fall back to the original approach
+            // but only for simple string literals
+            if (!found) {
+                const value = extract_string_literal(s, dynamic_import.moduleRequest.start, dynamic_import.moduleRequest.end);
+                if (value) {
+                    specifiers.push(value);
+                }
+            }
+        }
+        // Process re-exports
+        for (const node of parsed.program.body) {
+            if (node.type === 'ExportNamedDeclaration' && node.source) {
+                // Skip type-only exports if ignore_types is true
+                if (ignore_types && node.exportKind === 'type') {
+                    continue;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (node.source.type === 'Literal') {
+                    const value = node.source.value;
+                    if (value) {
+                        specifiers.push(value);
+                    }
+                }
+                else {
+                    throw new UnreachableError(node.source.type);
+                }
+            }
+        }
+    };
+    if (is_svelte) {
+        // Reset the regexp state between calls
+        SVELTE_SCRIPT_MATCHER.lastIndex = 0;
+        // Capture script tags at the top level (not nested in HTML)
+        let last_index = 0;
+        const script_blocks = [];
+        // First collect all script blocks
+        let match;
+        while ((match = SVELTE_SCRIPT_MATCHER.exec(contents)) !== null) {
+            // Save position of the script tag
+            const start = match.index;
+            const end = SVELTE_SCRIPT_MATCHER.lastIndex;
+            // Only process top-level script tags (skip nested ones)
+            // A nested script would be inside another HTML tag between lastIndex and start
+            const text_between = contents.substring(last_index, start);
+            const contains_opening_tag = /<[a-z][^>]*>/i.test(text_between);
+            const contains_closing_tag = /<\/[a-z][^>]*>/i.test(text_between);
+            // If we're not nested (no HTML tag nesting), process this script
+            if (!(contains_opening_tag && !contains_closing_tag)) {
+                script_blocks.push({
+                    content: match[1],
+                    start,
+                    end,
+                });
+            }
+            last_index = end;
+        }
+        // Process all the collected script blocks
+        for (const script_block of script_blocks) {
+            parse_from(script_block.content);
+        }
+    }
+    else if (TS_MATCHER.test(id) || JS_MATCHER.test(id)) {
+        parse_from(contents);
+    }
+    return specifiers;
+};

package/dist/paths.d.ts

@@ -0,0 +1,41 @@
+import type { PathId } from '@fuzdev/fuz_util/path.js';
+export declare const LIB_DIRNAME: string;
+export declare const LIB_PATH: string;
+/** @trailing_slash */
+export declare const LIB_DIR: string;
+export declare const ROUTES_DIRNAME: string;
+export interface Paths {
+    /** @trailing_slash */
+    root: string;
+    /** @trailing_slash */
+    source: string;
+    /** @trailing_slash */
+    lib: string;
+    /** @trailing_slash */
+    build: string;
+    /** @trailing_slash */
+    build_dev: string;
+    config: string;
+}
+export declare const create_paths: (root_dir: string) => Paths;
+export declare const infer_paths: (id: PathId) => Paths;
+export declare const is_gro_id: (id: PathId) => boolean;
+export declare const to_root_path: (id: PathId, p?: Paths) => string;
+export declare const path_id_to_base_path: (path_id: PathId, p?: Paths) => string;
+export declare const base_path_to_path_id: (base_path: string, p?: Paths) => PathId;
+export declare const print_path: (path: string, p?: Paths) => string;
+export declare const replace_extension: (path: string, new_extension: string) => string;
+/**
+ * Paths for the user repo.
+ */
+export declare const paths: Paths;
+/** @trailing_slash */
+export declare const GRO_PACKAGE_DIR = "gro/";
+export declare const IS_THIS_GRO: boolean;
+/**
+ * Paths for the Gro package being used by the user repo.
+ */
+export declare const gro_paths: Paths;
+/** @trailing_slash */
+export declare const GRO_DIST_DIR: string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/paths.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAkBrD,eAAO,MAAM,WAAW,QAA2C,CAAC;AACpE,eAAO,MAAM,QAAQ,QAA2B,CAAC;AACjD,sBAAsB;AACtB,eAAO,MAAM,OAAO,QAAiB,CAAC;AACtC,eAAO,MAAM,cAAc,QAA8C,CAAC;AAE1E,MAAM,WAAW,KAAK;IACrB,sBAAsB;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,YAAY,GAAI,UAAU,MAAM,KAAG,KAW/C,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,IAAI,MAAM,KAAG,KAA4C,CAAC;AAEtF,eAAO,MAAM,SAAS,GAAI,IAAI,MAAM,KAAG,OACiC,CAAC;AAGzE,eAAO,MAAM,YAAY,GAAI,IAAI,MAAM,EAAE,SAAmB,KAAG,MAClC,CAAC;AAG9B,eAAO,MAAM,oBAAoB,GAAI,SAAS,MAAM,EAAE,SAAwB,KAAG,MACrD,CAAC;AAI7B,eAAO,MAAM,oBAAoB,GAAI,WAAW,MAAM,EAAE,SAA0B,KAAG,MAC3D,CAAC;AAE3B,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,EAAE,SAAqB,KAAG,MAMhE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,EAAE,eAAe,MAAM,KAAG,MAGvE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK,OAA8B,CAAC;AAEjD,sBAAsB;AACtB,eAAO,MAAM,eAAe,SAAS,CAAC;AAYtC,eAAO,MAAM,WAAW,SAAsC,CAAC;AAC/D;;GAEG;AACH,eAAO,MAAM,SAAS,OAA2D,CAAC;AAClF,sBAAsB;AACtB,eAAO,MAAM,YAAY,QAAgD,CAAC"}

package/dist/paths.js

@@ -0,0 +1,69 @@
+import { join, extname, relative, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensure_end, strip_end } from '@fuzdev/fuz_util/string.js';
+import { styleText as st } from 'node:util';
+import { GRO_CONFIG_FILENAME, GRO_DEV_DIR, GRO_DIR, SOURCE_DIR, SVELTEKIT_DIST_DIRNAME, } from "./constants.js";
+import { default_svelte_config } from "./svelte_config.js";
+/*
+
+A path `id` is an absolute path to the source/.gro/dist directory.
+It's the same name that Rollup uses.
+
+*/
+export const LIB_DIRNAME = basename(default_svelte_config.lib_path);
+export const LIB_PATH = SOURCE_DIR + LIB_DIRNAME;
+/** @trailing_slash */
+export const LIB_DIR = LIB_PATH + '/';
+export const ROUTES_DIRNAME = basename(default_svelte_config.routes_path);
+export const create_paths = (root_dir) => {
+    // TODO remove reliance on trailing slash towards windows support
+    const root = ensure_end(root_dir, '/');
+    return {
+        root,
+        source: root + SOURCE_DIR,
+        lib: root + LIB_DIR,
+        build: root + GRO_DIR,
+        build_dev: root + GRO_DEV_DIR,
+        config: root + GRO_CONFIG_FILENAME,
+    };
+};
+export const infer_paths = (id) => (is_gro_id(id) ? gro_paths : paths);
+export const is_gro_id = (id) => id.startsWith(gro_paths.root) || gro_paths.root === ensure_end(id, '/');
+// '/home/me/app/src/foo/bar/baz.ts' → 'src/foo/bar/baz.ts'
+export const to_root_path = (id, p = infer_paths(id)) => relative(p.root, id) || './';
+// '/home/me/app/src/foo/bar/baz.ts' → 'foo/bar/baz.ts'
+export const path_id_to_base_path = (path_id, p = infer_paths(path_id)) => relative(p.source, path_id);
+// TODO base_path is an obsolete concept, it was a remnant from forcing `src/`
+// 'foo/bar/baz.ts' → '/home/me/app/src/foo/bar/baz.ts'
+export const base_path_to_path_id = (base_path, p = infer_paths(base_path)) => join(p.source, base_path);
+export const print_path = (path, p = infer_paths(path)) => {
+    let final_path = strip_end(path, '/') === strip_end(GRO_DIST_DIR, '/') ? 'gro' : to_root_path(path, p);
+    final_path =
+        final_path === 'gro' ? final_path : final_path[0] === '.' ? final_path : './' + final_path;
+    return st('gray', final_path);
+};
+export const replace_extension = (path, new_extension) => {
+    const { length } = extname(path);
+    return (length === 0 ? path : path.substring(0, path.length - length)) + new_extension;
+};
+/**
+ * Paths for the user repo.
+ */
+export const paths = create_paths(process.cwd());
+/** @trailing_slash */
+export const GRO_PACKAGE_DIR = 'gro/';
+// TODO document these conditions with comments
+// TODO there's probably a more robust way to do this
+const filename = fileURLToPath(import.meta.url);
+const gro_package_dir_path = join(filename, filename.includes('/gro/src/lib/')
+    ? '../../../'
+    : filename.includes('/gro/dist/')
+        ? '../../'
+        : '../');
+export const IS_THIS_GRO = gro_package_dir_path === paths.root;
+/**
+ * Paths for the Gro package being used by the user repo.
+ */
+export const gro_paths = IS_THIS_GRO ? paths : create_paths(gro_package_dir_path);
+/** @trailing_slash */
+export const GRO_DIST_DIR = gro_paths.root + SVELTEKIT_DIST_DIRNAME + '/';

package/dist/plugin.d.ts

@@ -0,0 +1,36 @@
+import type { TaskContext } from './task.ts';
+/**
+ * Gro `Plugin`s enable custom behavior during `gro dev` and `gro build`.
+ * In contrast, `Adapter`s use the results of `gro build` to produce final artifacts.
+ */
+export interface Plugin<TPluginContext extends PluginContext = PluginContext> {
+    name: string;
+    setup?: (ctx: TPluginContext) => void | Promise<void>;
+    adapt?: (ctx: TPluginContext) => void | Promise<void>;
+    teardown?: (ctx: TPluginContext) => void | Promise<void>;
+}
+export type PluginsCreateConfig<TPluginContext extends PluginContext = PluginContext> = (ctx: TPluginContext) => Array<Plugin<TPluginContext>> | Promise<Array<Plugin<TPluginContext>>>;
+export interface PluginContext<TArgs = object> extends TaskContext<TArgs> {
+    dev: boolean;
+    watch: boolean;
+}
+/** See `Plugins.create` for a usage example. */
+export declare class Plugins<TPluginContext extends PluginContext> {
+    readonly ctx: TPluginContext;
+    readonly instances: Array<Plugin<TPluginContext>>;
+    constructor(ctx: TPluginContext, instances: Array<Plugin>);
+    static create<TPluginContext extends PluginContext>(ctx: TPluginContext): Promise<Plugins<TPluginContext>>;
+    setup(): Promise<void>;
+    adapt(): Promise<void>;
+    teardown(): Promise<void>;
+}
+/**
+ * Replaces a plugin by name in `plugins` without mutating the param.
+ * Throws if the plugin name cannot be found.
+ * @param plugins - accepts the same types as the return value of `PluginsCreateConfig`
+ * @param new_plugin
+ * @param name - @default new_plugin.name
+ * @returns `plugins` with `new_plugin` at the index of the plugin with `name`
+ */
+export declare const plugin_replace: (plugins: Array<Plugin>, new_plugin: Plugin, name?: string) => Array<Plugin>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AAE3C;;;GAGG;AACH,MAAM,WAAW,MAAM,CAAC,cAAc,SAAS,aAAa,GAAG,aAAa;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzD;AAED,MAAM,MAAM,mBAAmB,CAAC,cAAc,SAAS,aAAa,GAAG,aAAa,IAAI,CACvF,GAAG,EAAE,cAAc,KACf,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;AAE5E,MAAM,WAAW,aAAa,CAAC,KAAK,GAAG,MAAM,CAAE,SAAQ,WAAW,CAAC,KAAK,CAAC;IACxE,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;CACf;AAED,gDAAgD;AAChD,qBAAa,OAAO,CAAC,cAAc,SAAS,aAAa;IACxD,QAAQ,CAAC,GAAG,EAAE,cAAc,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC;gBAEtC,GAAG,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC;WAK5C,MAAM,CAAC,cAAc,SAAS,aAAa,EACvD,GAAG,EAAE,cAAc,GACjB,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;IAS7B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAetB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAatB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAc/B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAC1B,SAAS,KAAK,CAAC,MAAM,CAAC,EACtB,YAAY,MAAM,EAClB,aAAsB,KACpB,KAAK,CAAC,MAAM,CAMd,CAAC"}

package/dist/plugin.js

@@ -0,0 +1,78 @@
+/** See `Plugins.create` for a usage example. */
+export class Plugins {
+    ctx;
+    instances;
+    constructor(ctx, instances) {
+        this.ctx = ctx;
+        this.instances = instances;
+    }
+    static async create(ctx) {
+        const { timings } = ctx;
+        const timing_to_create = timings.start('plugins.create');
+        const instances = await ctx.config.plugins(ctx);
+        const plugins = new Plugins(ctx, instances);
+        timing_to_create();
+        return plugins;
+    }
+    async setup() {
+        const { ctx, instances } = this;
+        if (!instances.length)
+            return;
+        const { timings, log } = ctx;
+        const timing_to_setup = timings.start('plugins.setup');
+        for (const plugin of instances) {
+            if (!plugin.setup)
+                continue;
+            log.debug('setup plugin', plugin.name);
+            const timing = timings.start(`setup:${plugin.name}`);
+            await plugin.setup(ctx); // eslint-disable-line no-await-in-loop
+            timing();
+        }
+        timing_to_setup();
+    }
+    async adapt() {
+        const { ctx, instances } = this;
+        const { timings } = ctx;
+        const timing_to_run_adapters = timings.start('plugins.adapt');
+        for (const plugin of instances) {
+            if (!plugin.adapt)
+                continue;
+            const timing = timings.start(`adapt:${plugin.name}`);
+            await plugin.adapt(ctx); // eslint-disable-line no-await-in-loop
+            timing();
+        }
+        timing_to_run_adapters();
+    }
+    async teardown() {
+        const { ctx, instances } = this;
+        if (!instances.length)
+            return;
+        const { timings, log } = ctx;
+        const timing_to_teardown = timings.start('plugins.teardown');
+        for (const plugin of instances) {
+            if (!plugin.teardown)
+                continue;
+            log.debug('teardown plugin', plugin.name);
+            const timing = timings.start(`teardown:${plugin.name}`);
+            await plugin.teardown(ctx); // eslint-disable-line no-await-in-loop
+            timing();
+        }
+        timing_to_teardown();
+    }
+}
+/**
+ * Replaces a plugin by name in `plugins` without mutating the param.
+ * Throws if the plugin name cannot be found.
+ * @param plugins - accepts the same types as the return value of `PluginsCreateConfig`
+ * @param new_plugin
+ * @param name - @default new_plugin.name
+ * @returns `plugins` with `new_plugin` at the index of the plugin with `name`
+ */
+export const plugin_replace = (plugins, new_plugin, name = new_plugin.name) => {
+    const index = plugins.findIndex((p) => p.name === name);
+    if (index === -1)
+        throw Error('Failed to find plugin to replace: ' + name);
+    const replaced = plugins.slice();
+    replaced[index] = new_plugin;
+    return replaced;
+};

package/dist/publish.task.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { type Task } from './task.ts';
+/** @nodocs */
+export declare const Args: z.ZodObject<{
+    branch: z.ZodDefault<z.ZodString>;
+    origin: z.ZodDefault<z.ZodString>;
+    changelog: z.ZodDefault<z.ZodString>;
+    preserve_changelog: z.ZodDefault<z.ZodBoolean>;
+    optional: z.ZodDefault<z.ZodBoolean>;
+    dry: z.ZodDefault<z.ZodBoolean>;
+    check: z.ZodDefault<z.ZodBoolean>;
+    'no-check': z.ZodDefault<z.ZodBoolean>;
+    build: z.ZodDefault<z.ZodBoolean>;
+    'no-build': z.ZodDefault<z.ZodBoolean>;
+    pull: z.ZodDefault<z.ZodBoolean>;
+    'no-pull': z.ZodDefault<z.ZodBoolean>;
+    sync: z.ZodDefault<z.ZodBoolean>;
+    'no-sync': z.ZodDefault<z.ZodBoolean>;
+    install: z.ZodDefault<z.ZodBoolean>;
+    'no-install': z.ZodDefault<z.ZodBoolean>;
+    changeset_cli: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=publish.task.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publish.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/publish.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAYtB,OAAO,EAAY,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAQ/C,cAAc;AACd,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;kBAuCf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAkK3B,CAAC"}

package/dist/publish.task.js

@@ -0,0 +1,176 @@
+import { spawn } from '@fuzdev/fuz_util/process.js';
+import { z } from 'zod';
+import { styleText as st } from 'node:util';
+import { fs_exists } from '@fuzdev/fuz_util/fs.js';
+import { GitBranch, GitOrigin, git_check_clean_workspace, git_checkout, git_fetch, git_pull, } from '@fuzdev/fuz_util/git.js';
+import { TaskError } from "./task.js";
+import { package_json_load, package_json_parse_repo_url } from "./package_json.js";
+import { find_cli, spawn_cli } from "./cli.js";
+import { has_sveltekit_library } from "./sveltekit_helpers.js";
+import { update_changelog } from "./changelog.js";
+import { load_from_env } from "./env.js";
+import { CHANGESET_CLI } from "./changeset_helpers.js";
+/** @nodocs */
+export const Args = z.strictObject({
+    branch: GitBranch.describe('branch to publish from').default('main'),
+    origin: GitOrigin.describe('git origin to publish from').default('origin'),
+    changelog: z
+        .string()
+        .meta({ description: 'file name and path of the changelog' })
+        .default('CHANGELOG.md'),
+    preserve_changelog: z
+        .boolean()
+        .meta({
+        description: 'opt out of linkifying and formatting the changelog from @changesets/changelog-git',
+    })
+        .default(false),
+    optional: z
+        .boolean()
+        .meta({ description: 'exit gracefully if there are no changesets' })
+        .default(false),
+    dry: z
+        .boolean()
+        .meta({ description: 'build and prepare to publish without actually publishing' })
+        .default(false),
+    check: z.boolean().meta({ description: 'dual of no-check' }).default(true),
+    'no-check': z
+        .boolean()
+        .meta({ description: 'opt out of checking before publishing' })
+        .default(false),
+    build: z.boolean().meta({ description: 'dual of no-build' }).default(true),
+    'no-build': z.boolean().meta({ description: 'opt out of building' }).default(false),
+    pull: z.boolean().meta({ description: 'dual of no-pull' }).default(true),
+    'no-pull': z.boolean().meta({ description: 'opt out of git pull' }).default(false),
+    sync: z.boolean().meta({ description: 'dual of no-sync' }).default(true),
+    'no-sync': z.boolean().meta({ description: 'opt out of gro sync' }).default(false),
+    install: z.boolean().meta({ description: 'dual of no-install' }).default(true),
+    'no-install': z
+        .boolean()
+        .meta({ description: 'opt out of installing packages before publishing' })
+        .default(false),
+    changeset_cli: z.string().meta({ description: 'the changeset CLI to use' }).default(CHANGESET_CLI),
+});
+/** @nodocs */
+export const task = {
+    summary: 'bump version, publish to the configured registry, and git push',
+    Args,
+    run: async ({ args, log, invoke_task, config }) => {
+        const { branch, origin, changelog, preserve_changelog, dry, check, build, pull, sync, install, optional, changeset_cli, } = args;
+        if (dry) {
+            log.info(st('green', 'dry run!'));
+        }
+        const package_json = await package_json_load();
+        const has_sveltekit_library_result = await has_sveltekit_library(package_json);
+        if (!has_sveltekit_library_result.ok) {
+            throw new TaskError('Failed to find SvelteKit library: ' + has_sveltekit_library_result.message);
+        }
+        const changelog_exists = await fs_exists(changelog);
+        const found_changeset_cli = await find_cli(changeset_cli);
+        if (!found_changeset_cli) {
+            throw new TaskError('changeset command not found, install @changesets/cli locally or globally');
+        }
+        // Make sure we're on the right branch:
+        await git_fetch(origin, branch);
+        await git_checkout(branch);
+        if (pull) {
+            if (await git_check_clean_workspace()) {
+                throw new TaskError('The git workspace is not clean, pass --no-pull to bypass git pull');
+            }
+            await git_pull(origin, branch);
+        }
+        // Install packages to ensure deps are current.
+        // Handles cases like branch switches where package.json changed.
+        // Skip gen because it will run after version bump.
+        if (sync || install) {
+            if (!sync)
+                log.warn('sync is false but install is true, so running sync for install only');
+            await invoke_task('sync', { install, gen: false });
+        }
+        // Check before proceeding, defaults to true.
+        if (check) {
+            await invoke_task('check', { workspace: true, sync: false });
+        }
+        let version;
+        let optional_and_version_unchanged = false;
+        // Bump the version so the package.json is updated before building:
+        // TODO problem here is build may fail and put us in a bad state,
+        // but I don't see how we could do this to robustly
+        // have the new version in the build without building twice -
+        // maybe the code should catch the error and revert the version and delete the tag?
+        if (dry) {
+            log.info('dry run, skipping changeset version');
+        }
+        else {
+            if (typeof package_json.version !== 'string') {
+                throw new TaskError('Failed to find package.json version');
+            }
+            const parsed_repo_url = package_json_parse_repo_url(package_json);
+            if (!parsed_repo_url) {
+                throw new TaskError('package.json `repository` must contain a repo url (and GitHub only for now, sorry),' +
+                    ' like `git+https://github.com/fuzdev/gro.git` or `https://github.com/fuzdev/gro`' +
+                    ' or an object with the `url` key');
+            }
+            // This is the first line that alters the repo.
+            const changeset_version_result = await spawn_cli(found_changeset_cli, ['version'], log);
+            if (!changeset_version_result?.ok) {
+                throw Error('changeset version failed: no commits were made: see the error above');
+            }
+            if (!preserve_changelog) {
+                const token = load_from_env('SECRET_GITHUB_API_TOKEN');
+                if (!token) {
+                    log.warn('the env var SECRET_GITHUB_API_TOKEN was not found, so API calls with be unauthorized');
+                }
+                await update_changelog(parsed_repo_url.owner, parsed_repo_url.repo, changelog, token, log);
+            }
+            // Update package-lock.json to reflect the new version.
+            if (install) {
+                const install_result = await spawn(config.pm_cli, ['install']);
+                if (!install_result.ok) {
+                    throw new TaskError(`Failed \`${config.pm_cli} install\` after version bump`);
+                }
+            }
+            // Regenerate files that depend on package.json version.
+            // The check above ensures gen is updated.
+            await invoke_task('gen');
+            const package_json_after_versioning = await package_json_load();
+            version = package_json_after_versioning.version;
+            if (package_json.version === version) {
+                // The version didn't change.
+                // For now this is the best detection we have for a no-op `changeset version`.
+                if (optional) {
+                    optional_and_version_unchanged = true;
+                }
+                else {
+                    // Doesn't build if the version didn't change and publishing isn't optional.
+                    throw new TaskError(`\`${changeset_cli} version\` failed: are there any changes?`);
+                }
+            }
+        }
+        // Build after the version is bumped so the new version is in the build as needed.
+        // Skip sync and install because we already handled both above.
+        if (build) {
+            await invoke_task('build', { sync: false, install: false });
+        }
+        // Return early if there are no changes and publishing is optional, but after building,
+        // so if callers want to optimize away building
+        // they need to do so manually like in `gro release`.
+        // TODO this could be cleaned up if tasks had a return value to callers, it could specifiy that it didn't build
+        if (optional_and_version_unchanged)
+            return;
+        if (dry) {
+            log.info('publishing branch ' + branch);
+            log.info(st('green', 'dry run complete!'));
+            return;
+        }
+        const changeset_publish_result = await spawn_cli(found_changeset_cli, ['publish'], log);
+        if (!changeset_publish_result?.ok) {
+            throw new TaskError(`\`${changeset_cli} publish\` failed - continue manually or try again after running \`git reset --hard\``);
+        }
+        if (!changelog_exists && (await fs_exists(changelog))) {
+            await spawn('git', ['add', changelog]);
+        }
+        await spawn('git', ['commit', '-a', '-m', `publish v${version}`]);
+        await spawn('git', ['push', '--follow-tags']);
+        log.info(st('green', `published to branch ${st('cyan', branch)}!`));
+    },
+};

package/dist/register.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register.d.ts.map

package/dist/register.d.ts.map

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

package/dist/register.js

@@ -0,0 +1,2 @@
+import { register } from 'node:module';
+register('./loader.js', import.meta.url);

package/dist/reinstall.task.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { type Task } from './task.ts';
+/** @nodocs */
+export declare const Args: z.ZodObject<{}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=reinstall.task.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reinstall.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/reinstall.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,OAAO,EAAY,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAG/C,cAAc;AACd,eAAO,MAAM,IAAI,iCAAqB,CAAC;AACvC,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAgC3B,CAAC"}

package/dist/reinstall.task.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { spawn } from '@fuzdev/fuz_util/process.js';
+import { rm } from 'node:fs/promises';
+import { TaskError } from "./task.js";
+import { LOCKFILE_FILENAME, NODE_MODULES_DIRNAME } from "./constants.js";
+/** @nodocs */
+export const Args = z.strictObject({});
+/** @nodocs */
+export const task = {
+    summary: `refreshes ${LOCKFILE_FILENAME} with the latest and cleanest deps`,
+    Args,
+    run: async ({ log, config }) => {
+        log.info(`running the initial \`${config.pm_cli} install\``);
+        const initial_install_result = await spawn(config.pm_cli, ['install']);
+        if (!initial_install_result.ok) {
+            throw new TaskError(`Failed initial \`${config.pm_cli} install\``);
+        }
+        // Deleting both the lockfile and node_modules upgrades to the latest minor/patch versions.
+        await Promise.all([rm(LOCKFILE_FILENAME), rm(NODE_MODULES_DIRNAME, { recursive: true })]);
+        log.info(`running \`${config.pm_cli} install\` after deleting ${LOCKFILE_FILENAME} and ${NODE_MODULES_DIRNAME}, this can take a while...`);
+        const second_install_result = await spawn(config.pm_cli, ['install']);
+        if (!second_install_result.ok) {
+            throw new TaskError(`Failed \`${config.pm_cli} install\` after deleting ${LOCKFILE_FILENAME} and ${NODE_MODULES_DIRNAME}`);
+        }
+        // TODO @many this relies on npm behavior that changed in v11
+        // Deleting the lockfile and reinstalling cleans the lockfile of unnecessary dep noise,
+        // like esbuild's many packages for each platform.
+        await rm(LOCKFILE_FILENAME);
+        log.info(`running \`${config.pm_cli} install\` one last time to clean ${LOCKFILE_FILENAME}`);
+        const final_install_result = await spawn(config.pm_cli, ['install']);
+        if (!final_install_result.ok) {
+            throw new TaskError(`Failed \`${config.pm_cli} install\``);
+        }
+    },
+};

package/dist/release.task.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import type { Task } from './task.ts';
+/** @nodocs */
+export declare const Args: z.ZodObject<{}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=release.task.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"release.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/release.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAIpC,cAAc;AACd,eAAO,MAAM,IAAI,iCAAqB,CAAC;AACvC,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAc3B,CAAC"}