@ryanatkn/gro 0.191.0 → 0.192.0

package/dist/build.task.js

@@ -1,119 +0,0 @@
-import { z } from 'zod';
-import { styleText as st } from 'node:util';
-import { git_check_clean_workspace, git_current_commit_hash } from '@fuzdev/fuz_util/git.js';
-import { rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { fs_exists } from '@fuzdev/fuz_util/fs.js';
-import { TaskError } from "./task.js";
-import { Plugins } from "./plugin.js";
-import { clean_fs } from "./clean_fs.js";
-import { is_build_cache_valid, create_build_cache_metadata, save_build_cache_metadata, discover_build_output_dirs, } from "./build_cache.js";
-import { paths } from "./paths.js";
-/** @nodocs */
-export const Args = z.strictObject({
-    sync: z.boolean().meta({ description: 'dual of no-sync' }).default(true),
-    'no-sync': z.boolean().meta({ description: 'opt out of gro sync' }).default(false),
-    gen: z.boolean().meta({ description: 'dual of no-gen' }).default(true),
-    'no-gen': z.boolean().meta({ description: 'opt out of gro gen' }).default(false),
-    install: z.boolean().meta({ 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()
-        .meta({ description: 'opt out of installing packages before building' })
-        .default(false),
-    force_build: z
-        .boolean()
-        .meta({ description: 'force a fresh build, ignoring the cache' })
-        .default(false),
-});
-/**
- * Length of git commit hash when displayed in logs (standard git convention).
- */
-export const GIT_SHORT_HASH_LENGTH = 7;
-/**
- * Formats a git commit hash for display in logs.
- * Returns '[none]' if hash is null (e.g., not in a git repo).
- */
-const format_commit_hash = (hash) => hash?.slice(0, GIT_SHORT_HASH_LENGTH) ?? '[none]';
-/** @nodocs */
-export const task = {
-    summary: 'build the project',
-    Args,
-    run: async (ctx) => {
-        const { args, invoke_task, log, config } = ctx;
-        const { sync, gen, install, force_build } = args;
-        if (sync || install) {
-            if (!sync)
-                log.warn('sync is false but install is true, so ignoring the sync option');
-            await invoke_task('sync', { install, gen: false });
-        }
-        if (gen) {
-            await invoke_task('gen');
-        }
-        // Batch git calls upfront for performance (spawning processes is expensive)
-        const [workspace_status, initial_commit] = await Promise.all([
-            git_check_clean_workspace(),
-            git_current_commit_hash(),
-        ]);
-        const workspace_dirty = !!workspace_status;
-        // Discover build output directories once to avoid redundant filesystem scans
-        let build_dirs;
-        // Check build cache unless force_build is set or workspace is dirty
-        if (!workspace_dirty && !force_build) {
-            const cache_valid = await is_build_cache_valid(config, log, initial_commit);
-            if (cache_valid) {
-                log.info(st('cyan', 'skipping build, cache is valid'), st('dim', '(use --force_build to rebuild)'));
-                return;
-            }
-        }
-        else if (workspace_dirty) {
-            // IMPORTANT: When workspace is dirty, we delete cache AND all outputs to prevent stale state.
-            // Rationale: Uncommitted changes could be reverted, leaving cached outputs from reverted code.
-            // This conservative approach prioritizes safety over convenience during development.
-            const cache_path = join(paths.build, 'build.json');
-            if (await fs_exists(cache_path)) {
-                await rm(cache_path, { force: true });
-            }
-            // Delete all build output directories
-            build_dirs = await discover_build_output_dirs();
-            await Promise.all(build_dirs.map((dir) => rm(dir, { recursive: true, force: true })));
-            log.info(st('yellow', 'workspace has uncommitted changes - skipping build cache'));
-            // Skip clean_fs - already manually cleaned cache and all build outputs above
-        }
-        else {
-            log.info(st('yellow', 'forcing fresh build, ignoring cache'));
-        }
-        // Clean build outputs (skip if workspace was dirty - already cleaned manually above)
-        if (!workspace_dirty) {
-            await clean_fs({ build_dist: true });
-        }
-        const plugins = await Plugins.create({ ...ctx, dev: false, watch: false });
-        await plugins.setup();
-        await plugins.adapt();
-        await plugins.teardown();
-        // Verify workspace didn't become dirty during build
-        const final_workspace_status = await git_check_clean_workspace();
-        if (final_workspace_status !== workspace_status) {
-            // Workspace state changed during build - this indicates a problem
-            throw new TaskError('Build process modified tracked files or created untracked files.\n\n' +
-                'Git status after build:\n' +
-                final_workspace_status +
-                '\n\n' +
-                'Builds should only write to output directories (build/, dist/, etc.).\n' +
-                'This usually indicates a plugin or build step is incorrectly modifying source files.');
-        }
-        // Save build cache metadata after successful build (only if workspace is clean)
-        if (!workspace_dirty) {
-            // Race condition protection: verify git commit didn't change during build
-            const current_commit = await git_current_commit_hash();
-            if (current_commit !== initial_commit) {
-                log.warn(st('yellow', 'git commit changed during build'), st('dim', `(${format_commit_hash(initial_commit)} → ${format_commit_hash(current_commit)})`), '- cache not saved');
-            }
-            else {
-                // Commit is stable - safe to save cache
-                const metadata = await create_build_cache_metadata(config, log, initial_commit, build_dirs);
-                await save_build_cache_metadata(metadata, log);
-                log.debug('Build cache metadata saved');
-            }
-        }
-    },
-};

package/dist/build_cache.d.ts

@@ -1,100 +0,0 @@
-import { z } from 'zod';
-import type { Logger } from '@fuzdev/fuz_util/log.js';
-import type { GroConfig } from './gro_config.ts';
-export declare const BUILD_CACHE_METADATA_FILENAME = "build.json";
-export declare const BUILD_CACHE_VERSION = "1";
-/**
- * Metadata about a single build output file.
- * Includes cryptographic hash for validation plus filesystem stats for debugging and optimization.
- */
-export declare const BuildOutputEntry: z.ZodObject<{
-    path: z.ZodString;
-    hash: z.ZodString;
-    size: z.ZodNumber;
-    mtime: z.ZodNumber;
-    ctime: z.ZodNumber;
-    mode: z.ZodNumber;
-}, z.core.$strict>;
-export type BuildOutputEntry = z.infer<typeof BuildOutputEntry>;
-/**
- * Metadata stored in .gro/ directory to track build cache validity.
- * Schema validates structure at load time to catch corrupted cache files.
- */
-export declare const BuildCacheMetadata: z.ZodObject<{
-    version: z.ZodString;
-    git_commit: z.ZodNullable<z.ZodString>;
-    build_cache_config_hash: z.ZodString;
-    timestamp: z.ZodString;
-    outputs: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        hash: z.ZodString;
-        size: z.ZodNumber;
-        mtime: z.ZodNumber;
-        ctime: z.ZodNumber;
-        mode: z.ZodNumber;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type BuildCacheMetadata = z.infer<typeof BuildCacheMetadata>;
-/**
- * Computes the cache key components for a build.
- * This determines whether a cached build can be reused.
- *
- * @param config Gro config (build_cache_config_hash is already computed during config load)
- * @param log Logger
- * @param git_commit Optional pre-computed git commit hash (optimization to avoid re-reading)
- */
-export declare const compute_build_cache_key: (config: GroConfig, log: Logger, git_commit?: string | null) => Promise<{
-    git_commit: string | null;
-    build_cache_config_hash: string;
-}>;
-/**
- * Loads build cache metadata from .gro/ directory.
- * Invalid or corrupted cache files are automatically deleted.
- */
-export declare const load_build_cache_metadata: () => Promise<BuildCacheMetadata | null>;
-/**
- * Saves build cache metadata to .gro/ directory.
- * Errors are logged but don't fail the build (cache is optional).
- */
-export declare const save_build_cache_metadata: (metadata: BuildCacheMetadata, log?: Logger) => Promise<void>;
-/**
- * Validates that a cached build is still valid by checking stats and hashing outputs.
- * Uses size as a fast negative check before expensive hashing.
- * This is comprehensive validation to catch manual tampering or corruption.
- */
-export declare const validate_build_cache: (metadata: BuildCacheMetadata) => Promise<boolean>;
-/**
- * Main function to check if the build cache is valid.
- * Returns true if the cached build can be used, false if a fresh build is needed.
- *
- * @param config Gro config
- * @param log Logger
- * @param git_commit Optional pre-computed git commit hash (optimization)
- */
-export declare const is_build_cache_valid: (config: GroConfig, log: Logger, git_commit?: string | null) => Promise<boolean>;
-/**
- * Collects information about all files in build output directories.
- * Returns an array of entries with path, hash, size, mtime, ctime, and mode.
- *
- * Files are hashed in parallel for performance. For very large builds (10k+ files),
- * this may take several seconds but ensures complete cache validation.
- *
- * @param build_dirs Array of output directories to scan (e.g., ['build', 'dist', 'dist_server'])
- */
-export declare const collect_build_outputs: (build_dirs: Array<string>) => Promise<Array<BuildOutputEntry>>;
-/**
- * Discovers all build output directories in the current working directory.
- * Returns an array of directory names that exist: build/, dist/, dist_*
- */
-export declare const discover_build_output_dirs: () => Promise<Array<string>>;
-/**
- * Creates build cache metadata after a successful build.
- * Automatically discovers all build output directories (build/, dist/, dist_*).
- *
- * @param config Gro config
- * @param log Logger
- * @param git_commit Optional pre-computed git commit hash (optimization)
- * @param build_dirs Optional pre-discovered build directories (optimization to avoid redundant filesystem scans)
- */
-export declare const create_build_cache_metadata: (config: GroConfig, log: Logger, git_commit?: string | null, build_dirs?: Array<string>) => Promise<BuildCacheMetadata>;
-//# sourceMappingURL=build_cache.d.ts.map

package/dist/build_cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build_cache.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/build_cache.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AACtB,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAMpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAI/C,eAAO,MAAM,6BAA6B,eAAe,CAAC;AAC1D,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;kBAW3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;kBAU7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,GACnC,QAAQ,SAAS,EACjB,KAAK,MAAM,EACX,aAAa,MAAM,GAAG,IAAI,KACxB,OAAO,CAAC;IACV,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,uBAAuB,EAAE,MAAM,CAAC;CAChC,CAYA,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,QAAa,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAoCnF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,GACrC,UAAU,kBAAkB,EAC5B,MAAM,MAAM,KACV,OAAO,CAAC,IAAI,CAcd,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAU,UAAU,kBAAkB,KAAG,OAAO,CAAC,OAAO,CAmCxF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAChC,QAAQ,SAAS,EACjB,KAAK,MAAM,EACX,aAAa,MAAM,GAAG,IAAI,KACxB,OAAO,CAAC,OAAO,CA+BjB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GACjC,YAAY,KAAK,CAAC,MAAM,CAAC,KACvB,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAkEjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,QAAa,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAkCxE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,GACvC,QAAQ,SAAS,EACjB,KAAK,MAAM,EACX,aAAa,MAAM,GAAG,IAAI,EAC1B,aAAa,KAAK,CAAC,MAAM,CAAC,KACxB,OAAO,CAAC,kBAAkB,CAW5B,CAAC"}

package/dist/build_cache.js

@@ -1,299 +0,0 @@
-import { mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { styleText as st } from 'node:util';
-import { z } from 'zod';
-import { git_current_commit_hash } from '@fuzdev/fuz_util/git.js';
-import { fs_exists } from '@fuzdev/fuz_util/fs.js';
-import { map_concurrent } from '@fuzdev/fuz_util/async.js';
-import { hash_secure } from '@fuzdev/fuz_util/hash.js';
-import { paths } from "./paths.js";
-import { SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_DIST_DIRNAME, GRO_DIST_PREFIX } from "./constants.js";
-export const BUILD_CACHE_METADATA_FILENAME = 'build.json';
-export const BUILD_CACHE_VERSION = '1';
-/**
- * Metadata about a single build output file.
- * Includes cryptographic hash for validation plus filesystem stats for debugging and optimization.
- */
-export const BuildOutputEntry = z.strictObject({
-    path: z
-        .string()
-        .meta({ description: "relative path from project root (e.g., 'build/index.html')." }),
-    hash: z.string().meta({ description: 'SHA-256 hash of file contents' }),
-    size: z.number().meta({ description: 'file size in bytes' }),
-    mtime: z.number().meta({ description: 'modification time in milliseconds since epoch' }),
-    ctime: z.number().meta({
-        description: 'POSIX change time in milliseconds since epoch',
-    }),
-    mode: z.number().meta({ description: 'unix file permission mode (e.g., 33188 = 0644)' }),
-});
-/**
- * Metadata stored in .gro/ directory to track build cache validity.
- * Schema validates structure at load time to catch corrupted cache files.
- */
-export const BuildCacheMetadata = z.strictObject({
-    version: z.string().meta({ description: 'schema version for future compatibility' }),
-    git_commit: z.string().nullable().meta({ description: 'git commit hash at time of build' }),
-    build_cache_config_hash: z
-        .string()
-        .meta({ description: "hash of user's custom build_cache_config from gro.config.ts." }),
-    timestamp: z.string().meta({ description: 'timestamp when build completed' }),
-    outputs: z
-        .array(BuildOutputEntry)
-        .meta({ description: 'build output files with hashes and filesystem stats' }),
-});
-/**
- * Computes the cache key components for a build.
- * This determines whether a cached build can be reused.
- *
- * @param config Gro config (build_cache_config_hash is already computed during config load)
- * @param log Logger
- * @param git_commit Optional pre-computed git commit hash (optimization to avoid re-reading)
- */
-export const compute_build_cache_key = async (config, log, git_commit) => {
-    // 1. Git commit hash - primary cache key
-    const commit = git_commit !== undefined ? git_commit : await git_current_commit_hash();
-    if (!commit) {
-        log.warn('Not in a git repository - build cache will use null git commit');
-    }
-    // 2. Build cache config hash - already computed during config normalization
-    return {
-        git_commit: commit,
-        build_cache_config_hash: config.build_cache_config_hash,
-    };
-};
-/**
- * Loads build cache metadata from .gro/ directory.
- * Invalid or corrupted cache files are automatically deleted.
- */
-export const load_build_cache_metadata = async () => {
-    const metadata_path = join(paths.build, BUILD_CACHE_METADATA_FILENAME);
-    if (!(await fs_exists(metadata_path))) {
-        return null;
-    }
-    try {
-        const contents = await readFile(metadata_path, 'utf-8');
-        const parsed = JSON.parse(contents);
-        // Validate structure with Zod
-        const metadata = BuildCacheMetadata.parse(parsed);
-        // Validate version
-        if (metadata.version !== BUILD_CACHE_VERSION) {
-            // Clean up stale cache with old schema version
-            try {
-                await rm(metadata_path, { force: true });
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-            return null;
-        }
-        return metadata;
-    }
-    catch {
-        // Clean up corrupted/invalid cache file
-        // (catches JSON.parse, Zod validation, and version errors)
-        try {
-            await rm(metadata_path, { force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-        return null;
-    }
-};
-/**
- * Saves build cache metadata to .gro/ directory.
- * Errors are logged but don't fail the build (cache is optional).
- */
-export const save_build_cache_metadata = async (metadata, log) => {
-    try {
-        // Ensure .gro directory exists
-        await mkdir(paths.build, { recursive: true });
-        const metadata_path = join(paths.build, BUILD_CACHE_METADATA_FILENAME);
-        await writeFile(metadata_path, JSON.stringify(metadata, null, '\t'), 'utf-8');
-    }
-    catch (error) {
-        // Cache writes are optional - log warning but don't fail the build
-        log?.warn(st('yellow', 'Failed to save build cache'), st('dim', `(${error instanceof Error ? error.message : String(error)})`));
-    }
-};
-/**
- * Validates that a cached build is still valid by checking stats and hashing outputs.
- * Uses size as a fast negative check before expensive hashing.
- * This is comprehensive validation to catch manual tampering or corruption.
- */
-export const validate_build_cache = async (metadata) => {
-    // Verify all tracked output files exist and have matching size
-    // Sequential checks with early return for performance
-    for (const output of metadata.outputs) {
-        // eslint-disable-next-line no-await-in-loop
-        if (!(await fs_exists(output.path))) {
-            return false;
-        }
-        // Fast negative check: size mismatch = definitely invalid
-        // This avoids expensive file reads and hashing for files that have clearly changed
-        // eslint-disable-next-line no-await-in-loop
-        const stats = await stat(output.path);
-        if (stats.size !== output.size) {
-            return false;
-        }
-    }
-    // Size matches for all files - now verify content with cryptographic hashing
-    // Hash files with controlled concurrency (could be 10k+ files)
-    const results = await map_concurrent(metadata.outputs, async (output) => {
-        try {
-            const contents = await readFile(output.path);
-            const actual_hash = await hash_secure(contents);
-            return actual_hash === output.hash;
-        }
-        catch {
-            // File deleted/inaccessible between checks = cache invalid
-            return false;
-        }
-    }, 20);
-    return results.every((valid) => valid);
-};
-/**
- * Main function to check if the build cache is valid.
- * Returns true if the cached build can be used, false if a fresh build is needed.
- *
- * @param config Gro config
- * @param log Logger
- * @param git_commit Optional pre-computed git commit hash (optimization)
- */
-export const is_build_cache_valid = async (config, log, git_commit) => {
-    // Load existing metadata
-    const metadata = await load_build_cache_metadata();
-    if (!metadata) {
-        log.debug('No build cache metadata found');
-        return false;
-    }
-    // Compute current cache key
-    const current = await compute_build_cache_key(config, log, git_commit);
-    // Check if cache keys have changed
-    if (metadata.git_commit !== current.git_commit) {
-        log.debug('Build cache invalid: git commit changed');
-        return false;
-    }
-    if (metadata.build_cache_config_hash !== current.build_cache_config_hash) {
-        log.debug('Build cache invalid: build_cache_config changed');
-        return false;
-    }
-    // Comprehensive validation: verify output files
-    const outputs_valid = await validate_build_cache(metadata);
-    if (!outputs_valid) {
-        log.debug('Build cache invalid: output files missing or corrupted');
-        return false;
-    }
-    log.info(st('green', 'Build cache valid'), st('dim', `(from ${metadata.timestamp})`));
-    return true;
-};
-/**
- * Collects information about all files in build output directories.
- * Returns an array of entries with path, hash, size, mtime, ctime, and mode.
- *
- * Files are hashed in parallel for performance. For very large builds (10k+ files),
- * this may take several seconds but ensures complete cache validation.
- *
- * @param build_dirs Array of output directories to scan (e.g., ['build', 'dist', 'dist_server'])
- */
-export const collect_build_outputs = async (build_dirs) => {
-    const files_hash_secure = [];
-    // Recursively collect files
-    const collect_files = async (dir, relative_base, dir_prefix) => {
-        const entries = await readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            // Skip metadata file itself
-            if (entry.name === BUILD_CACHE_METADATA_FILENAME) {
-                continue;
-            }
-            const full_path = join(dir, entry.name);
-            const relative_path = relative_base ? join(relative_base, entry.name) : entry.name;
-            const cache_key = join(dir_prefix, relative_path);
-            if (entry.isDirectory()) {
-                // eslint-disable-next-line no-await-in-loop
-                await collect_files(full_path, relative_path, dir_prefix);
-            }
-            else if (entry.isFile()) {
-                files_hash_secure.push({ full_path, cache_key });
-            }
-            // Symlinks are intentionally ignored - we only hash regular files
-        }
-    };
-    // Collect files from all build directories sequentially
-    for (const build_dir of build_dirs) {
-        // eslint-disable-next-line no-await-in-loop
-        if (!(await fs_exists(build_dir))) {
-            continue; // Skip non-existent directories
-        }
-        // eslint-disable-next-line no-await-in-loop
-        await collect_files(build_dir, '', build_dir);
-    }
-    // Hash files with controlled concurrency and collect stats (could be 10k+ files)
-    return map_concurrent(files_hash_secure, async ({ full_path, cache_key }) => {
-        const stats = await stat(full_path);
-        const contents = await readFile(full_path);
-        const hash = await hash_secure(contents);
-        return {
-            path: cache_key,
-            hash,
-            size: stats.size,
-            mtime: stats.mtimeMs,
-            ctime: stats.ctimeMs,
-            mode: stats.mode,
-        };
-    }, 20);
-};
-/**
- * Discovers all build output directories in the current working directory.
- * Returns an array of directory names that exist: build/, dist/, dist_*
- */
-export const discover_build_output_dirs = async () => {
-    const build_dirs = [];
-    // Check for SvelteKit app output (build/) and library output (dist/) in parallel
-    const [build_exists, dist_exists] = await Promise.all([
-        fs_exists(SVELTEKIT_BUILD_DIRNAME),
-        fs_exists(SVELTEKIT_DIST_DIRNAME),
-    ]);
-    if (build_exists) {
-        build_dirs.push(SVELTEKIT_BUILD_DIRNAME);
-    }
-    if (dist_exists) {
-        build_dirs.push(SVELTEKIT_DIST_DIRNAME);
-    }
-    // Check for server and other plugin outputs (dist_*)
-    const root_entries = await readdir('.');
-    const dist_dir_checks = await Promise.all(root_entries
-        .filter((p) => p.startsWith(GRO_DIST_PREFIX))
-        .map(async (p) => {
-        try {
-            const s = await stat(p);
-            return s.isDirectory() ? p : null;
-        }
-        catch {
-            // File was deleted/moved during iteration - skip it
-            return null;
-        }
-    }));
-    build_dirs.push(...dist_dir_checks.filter((p) => p !== null));
-    return build_dirs;
-};
-/**
- * Creates build cache metadata after a successful build.
- * Automatically discovers all build output directories (build/, dist/, dist_*).
- *
- * @param config Gro config
- * @param log Logger
- * @param git_commit Optional pre-computed git commit hash (optimization)
- * @param build_dirs Optional pre-discovered build directories (optimization to avoid redundant filesystem scans)
- */
-export const create_build_cache_metadata = async (config, log, git_commit, build_dirs) => {
-    const cache_key = await compute_build_cache_key(config, log, git_commit);
-    const dirs = build_dirs ?? (await discover_build_output_dirs());
-    const outputs = await collect_build_outputs(dirs);
-    return {
-        version: BUILD_CACHE_VERSION,
-        ...cache_key,
-        timestamp: new Date().toISOString(),
-        outputs,
-    };
-};

package/dist/changelog.d.ts

@@ -1,11 +0,0 @@
-import type { Logger } from '@fuzdev/fuz_util/log.js';
-import type { FetchValueCache } from '@fuzdev/fuz_util/fetch.js';
-/**
- * Updates a changelog produced by `@changesets/changelog-git` with better links and formatting.
- * It's similar to `@changesets/changelog-github` but doesn't require a token for light usage.
- * This may be better implemented as a standalone dependency
- * as an alternative to `@changesets/changelog-git`.
- * @returns boolean indicating if the changelog changed
- */
-export declare const update_changelog: (owner: string, repo: string, path?: string, token?: string, log?: Logger, cache?: FetchValueCache) => Promise<boolean>;
-//# sourceMappingURL=changelog.d.ts.map

package/dist/changelog.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"changelog.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/changelog.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,2BAA2B,CAAC;AAI/D;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAC5B,OAAO,MAAM,EACb,MAAM,MAAM,EACZ,aAAqB,EACrB,QAAQ,MAAM,EACd,MAAM,MAAM,EACZ,QAAO,eAA2B,KAChC,OAAO,CAAC,OAAO,CAUjB,CAAC"}

package/dist/changelog.js

@@ -1,47 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises';
-import { z } from 'zod';
-import { github_fetch_commit_prs } from "./github.js";
-/**
- * Updates a changelog produced by `@changesets/changelog-git` with better links and formatting.
- * It's similar to `@changesets/changelog-github` but doesn't require a token for light usage.
- * This may be better implemented as a standalone dependency
- * as an alternative to `@changesets/changelog-git`.
- * @returns boolean indicating if the changelog changed
- */
-export const update_changelog = async (owner, repo, path = 'CHANGELOG.md', token, log, cache = new Map()) => {
-    const contents = await readFile(path, 'utf8');
-    const parsed = parse_changelog(contents);
-    const mapped = await map_changelog(parsed, owner, repo, token, log, cache);
-    const updated = serialize_changelog(mapped);
-    if (contents === updated) {
-        return false;
-    }
-    await writeFile(path, updated, 'utf8');
-    return true;
-};
-// keeping this really simple for now, no need to parse further for our current usecases
-const ParsedChangelog = z.array(z.string());
-const parse_changelog = (contents) => contents.split('\n');
-const serialize_changelog = (parsed) => parsed.join('\n');
-const LINE_WITH_SHA_MATCHER = /^- ([a-z0-9]{7,8}): /;
-const map_changelog = async (parsed, owner, repo, token, log, cache) => {
-    const mapped = [];
-    for (const line of parsed) {
-        const matches = LINE_WITH_SHA_MATCHER.exec(line);
-        if (matches) {
-            const commit_sha = matches[1];
-            const l = '- ' + line.substring(commit_sha.length + 4);
-            const prs = await github_fetch_commit_prs(owner, repo, commit_sha, token, log, cache); // eslint-disable-line no-await-in-loop
-            if (prs?.length) {
-                mapped.push(`${l} (${prs.map((p) => `[#${p.number}](${p.html_url})`).join(', ')})`);
-            }
-            else {
-                mapped.push(`${l} ([${commit_sha}](https://github.com/${owner}/${repo}/commit/${commit_sha}))`);
-            }
-        }
-        else {
-            mapped.push(line);
-        }
-    }
-    return mapped;
-};

package/dist/changeset.task.d.ts

@@ -1,35 +0,0 @@
-import { z } from 'zod';
-import { type Task } from './task.ts';
-/** @nodocs */
-export declare const Args: z.ZodObject<{
-    /**
-     * The optional rest args get joined with a space to form the `message`.
-     */
-    _: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    minor: z.ZodDefault<z.ZodBoolean>;
-    major: z.ZodDefault<z.ZodBoolean>;
-    dir: z.ZodDefault<z.ZodString>;
-    access: z.ZodOptional<z.ZodEnum<{
-        public: "public";
-        restricted: "restricted";
-    }>>;
-    changelog: z.ZodDefault<z.ZodString>;
-    dep: z.ZodDefault<z.ZodBoolean>;
-    'no-dep': z.ZodDefault<z.ZodBoolean>;
-    origin: z.ZodDefault<z.ZodString>;
-    changeset_cli: z.ZodDefault<z.ZodString>;
-}, z.core.$strict>;
-export type Args = z.infer<typeof Args>;
-/**
- * Calls the `changeset` CLI with some simple automations.
- * This API is designed for convenient manual usage, not clarity or normality.
- *
- * Usage:
- * - gro changeset some commit message
- * - gro changeset some commit message --minor
- * - gro changeset "some commit message" --minor
- *
- * @nodocs
- */
-export declare const task: Task<Args>;
-//# sourceMappingURL=changeset.task.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"changeset.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/changeset.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAatB,OAAO,EAAY,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAa/C,cAAc;AACd,eAAO,MAAM,IAAI;IAChB;;OAEG;;;;;;;;;;;;;;kBAuBF,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA0F3B,CAAC"}