@smoothbricks/cli 0.1.0 → 0.2.0

package/dist/monorepo/packed-manifest.d.ts

@@ -0,0 +1,4 @@
+import type { PackageInfo } from '../lib/workspace.js';
+export declare function readPackedPackageJson(root: string, tarball: string, packageName: string): Promise<Record<string, unknown>>;
+export declare function validatePackedWorkspaceDependencies(root: string, sourcePackage: PackageInfo, packedPackage: Record<string, unknown>): string[];
+//# sourceMappingURL=packed-manifest.d.ts.map

package/dist/monorepo/packed-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packed-manifest.d.ts","sourceRoot":"","sources":["../../src/monorepo/packed-manifest.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGvD,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAUlC;AAED,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,WAAW,EAC1B,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrC,MAAM,EAAE,CAoCV"}

package/dist/monorepo/packed-manifest.js

@@ -0,0 +1,51 @@
+import { $ } from 'bun';
+import { isRecord, recordProperty } from '../lib/json.js';
+import { decode } from '../lib/run.js';
+import { getWorkspacePackages, workspaceDependencyFields } from '../lib/workspace.js';
+export async function readPackedPackageJson(root, tarball, packageName) {
+    const result = await $ `tar -xOf ${tarball} package/package.json`.cwd(root).quiet().nothrow();
+    if (result.exitCode !== 0) {
+        throw new Error(`${packageName}: unable to inspect packed package.json.`);
+    }
+    const parsed = JSON.parse(decode(result.stdout));
+    if (!isRecord(parsed)) {
+        throw new Error(`${packageName}: packed package.json is not an object.`);
+    }
+    return parsed;
+}
+export function validatePackedWorkspaceDependencies(root, sourcePackage, packedPackage) {
+    const workspaceVersions = new Map(getWorkspacePackages(root).map((pkg) => [pkg.name, pkg.version]));
+    const failures = [];
+    for (const field of workspaceDependencyFields) {
+        const sourceDependencies = recordProperty(sourcePackage.json, field);
+        const packedDependencies = recordProperty(packedPackage, field);
+        if (!sourceDependencies && !packedDependencies) {
+            continue;
+        }
+        for (const [name, range] of Object.entries(packedDependencies ?? {})) {
+            if (typeof range === 'string' && range.startsWith('workspace:')) {
+                failures.push(`${sourcePackage.path}: packed ${field}.${name} must not contain ${range}`);
+            }
+        }
+        if (!sourceDependencies) {
+            continue;
+        }
+        for (const [name, sourceRange] of Object.entries(sourceDependencies)) {
+            const workspaceVersion = workspaceVersions.get(name);
+            if (!workspaceVersion) {
+                continue;
+            }
+            const packedRange = packedDependencies?.[name];
+            if (sourceRange !== 'workspace:*') {
+                failures.push(`${sourcePackage.path}: source ${field}.${name} must use workspace:*`);
+            }
+            if (packedRange !== workspaceVersion) {
+                failures.push(`${sourcePackage.path}: packed ${field}.${name} must be ${workspaceVersion}, got ${formatRange(packedRange)}`);
+            }
+        }
+    }
+    return failures;
+}
+function formatRange(value) {
+    return typeof value === 'string' ? value : '<missing>';
+}

package/dist/monorepo/packed-package.d.ts

@@ -1,2 +1,5 @@
 export declare function validatePackedPublicPackages(root: string): Promise<number>;
+export declare function validatePackedPublicPackagePublint(root: string): Promise<number>;
+export declare function validatePackedPublicPackageManifest(root: string): Promise<number>;
+export declare function validatePackedPublicPackageTypes(root: string): Promise<number>;
 //# sourceMappingURL=packed-package.d.ts.map

package/dist/monorepo/packed-package.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"packed-package.d.ts","sourceRoot":"","sources":["../../src/monorepo/packed-package.ts"],"names":[],"mappings":"AASA,wBAAsB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAMhF"}
+{"version":3,"file":"packed-package.d.ts","sourceRoot":"","sources":["../../src/monorepo/packed-package.ts"],"names":[],"mappings":"AAUA,wBAAsB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAMhF;AAED,wBAAsB,kCAAkC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAMtF;AAED,wBAAsB,mCAAmC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAMvF;AAED,wBAAsB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAMpF"}

package/dist/monorepo/packed-package.js

@@ -3,58 +3,96 @@ import { join } from 'node:path';
 import { publint } from 'publint';
 import { formatMessage } from 'publint/utils';
 import { isRecord } from '../lib/json.js';
-import { runStatus } from '../lib/run.js';
+import { runResult, runStatus } from '../lib/run.js';
 import { listPublicPackages } from '../lib/workspace.js';
+import { readPackedPackageJson, validatePackedWorkspaceDependencies } from './packed-manifest.js';
 export async function validatePackedPublicPackages(root) {
+    return ((await validatePackedPublicPackagePublint(root)) +
+        (await validatePackedPublicPackageManifest(root)) +
+        (await validatePackedPublicPackageTypes(root)));
+}
+export async function validatePackedPublicPackagePublint(root) {
     let failures = 0;
     for (const pkg of listPublicPackages(root)) {
-        failures += await validatePackedPublicPackage(root, pkg);
+        failures += await validatePackedPublicPackageTool(root, pkg, validatePublint);
     }
     return failures;
 }
-async function validatePackedPublicPackage(root, pkg) {
+export async function validatePackedPublicPackageManifest(root) {
     let failures = 0;
+    for (const pkg of listPublicPackages(root)) {
+        failures += await validatePackedPublicPackageTool(root, pkg, validatePackedManifest);
+    }
+    return failures;
+}
+export async function validatePackedPublicPackageTypes(root) {
+    let failures = 0;
+    for (const pkg of listPublicPackages(root)) {
+        failures += await validatePackedPublicPackageTool(root, pkg, validateAttw);
+    }
+    return failures;
+}
+async function validatePackedPublicPackageTool(root, pkg, validate) {
     const packed = await packPackage(root, pkg);
     try {
-        const lint = await publint({ pack: { tarball: packed.arrayBuffer }, level: 'warning', strict: true });
-        for (const message of lint.messages) {
-            console.error(`${pkg.path}: publint ${message.type} ${message.code}: ${formatMessage(message, lint.pkg)}`);
-            failures++;
-        }
-        const attwArgs = [
-            packed.path,
-            '--format',
-            'ascii',
-            '--no-color',
-            '--profile',
-            'node16',
-            '--ignore-rules',
-            'cjs-resolves-to-esm',
-            ...attwExcludedEntrypointArgs(pkg),
-        ];
-        const attwStatus = await runStatus('attw', ['--quiet', ...attwArgs], root, true);
-        if (attwStatus !== 0) {
-            await runStatus('attw', attwArgs, root);
-            console.error(`${pkg.path}: are-the-types-wrong validation failed`);
-            failures++;
-        }
-        else {
-            console.log(`${pkg.path}: are-the-types-wrong valid.`);
-        }
+        return await validate(root, pkg, packed);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         console.error(`${pkg.path}: packed package validation failed: ${message}`);
-        failures++;
+        return 1;
     }
     finally {
         unlinkSync(packed.path);
     }
-    if (failures === 0) {
-        console.log(`${pkg.path}: packed package is valid.`);
+}
+async function validatePublint(_root, pkg, packed) {
+    let failures = 0;
+    const lint = await publint({ pack: { tarball: packed.arrayBuffer }, level: 'warning', strict: true });
+    for (const message of lint.messages) {
+        console.error(`${pkg.path}: publint ${message.type} ${message.code}: ${formatMessage(message, lint.pkg)}`);
+        failures++;
     }
     return failures;
 }
+async function validatePackedManifest(root, pkg, packed) {
+    let failures = 0;
+    const packedPackage = await readPackedPackageJson(root, packed.path, pkg.name);
+    for (const message of validatePackedWorkspaceDependencies(root, pkg, packedPackage)) {
+        console.error(message);
+        failures++;
+    }
+    return failures;
+}
+async function validateAttw(root, pkg, packed) {
+    const attwArgs = [
+        packed.path,
+        '--format',
+        'ascii',
+        '--no-color',
+        '--profile',
+        'node16',
+        '--ignore-rules',
+        'cjs-resolves-to-esm',
+        ...attwExcludedEntrypointArgs(pkg),
+    ];
+    const attw = await runResult('attw', attwArgs, root);
+    if (attw.exitCode === 0) {
+        return 0;
+    }
+    printAttwOutput(attw.stdout);
+    printAttwOutput(attw.stderr);
+    console.error(`${pkg.path}: are-the-types-wrong validation failed`);
+    return 1;
+}
+function printAttwOutput(output) {
+    for (const line of output.split('\n')) {
+        if (!line || line.includes('(ignored)')) {
+            continue;
+        }
+        console.error(line);
+    }
+}
 function attwExcludedEntrypointArgs(pkg) {
     const excluded = wasmExportEntrypoints(pkg.json.exports);
     return excluded.length === 0 ? [] : ['--exclude-entrypoints', ...excluded];

package/dist/monorepo/packs/index.d.ts

@@ -1,10 +1,29 @@
 export interface MonorepoContext {
     root: string;
     syncRuntime: boolean;
+    verbose?: boolean;
 }
 export interface ValidatePackOptions {
     failFast?: boolean;
+    fix?: boolean;
+    verbose?: boolean;
+}
+export interface MonorepoPack {
+    name: string;
+    init?(ctx: MonorepoContext): Promise<void> | void;
+    fixPreBuild?(ctx: MonorepoContext): Promise<void> | void;
+    fixPostBuild?(ctx: MonorepoContext): Promise<void> | void;
+    validatePreBuild?(ctx: MonorepoContext): Promise<number> | number;
+    validatePostBuild?(ctx: MonorepoContext): Promise<number> | number;
+}
+export interface ValidatePackRunHooks {
+    packs?: readonly MonorepoPack[];
+    runBuild?: (ctx: MonorepoContext, options?: ValidatePackOptions) => Promise<number> | number;
+}
+export interface ValidatePackResult {
+    failures: number;
+    failedChecks: number;
 }
 export declare function runInitPacks(ctx: MonorepoContext): Promise<void>;
-export declare function runValidatePacks(ctx: MonorepoContext, options?: ValidatePackOptions): Promise<number>;
+export declare function runValidatePacks(ctx: MonorepoContext, options?: ValidatePackOptions, hooks?: ValidatePackRunHooks): Promise<ValidatePackResult>;
 //# sourceMappingURL=index.d.ts.map

package/dist/monorepo/packs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/monorepo/packs/index.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAuDD,wBAAsB,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAItE;AAED,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,eAAe,EAAE,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CAgB/G"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/monorepo/packs/index.ts"],"names":[],"mappings":"AA6BA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAClD,WAAW,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACzD,YAAY,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1D,gBAAgB,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;IAClE,iBAAiB,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;CACpE;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAChC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,mBAAmB,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;CAC9F;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AAgGD,wBAAsB,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAItE;AAED,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,eAAe,EACpB,OAAO,GAAE,mBAAwB,EACjC,KAAK,GAAE,oBAAyB,GAC/B,OAAO,CAAC,kBAAkB,CAAC,CA0B7B"}

package/dist/monorepo/packs/index.js

@@ -1,16 +1,21 @@
 import { chmodSync, existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+import { runStatus } from '../../lib/run.js';
+import { readProjectTargets } from '../../nx/index.js';
+import { syncBunLockfileVersions, validateBunLockfileVersions } from '../lockfile.js';
 import { validateManagedFiles } from '../managed-files.js';
-import { validateNxSync } from '../nx-sync.js';
+import { fixNxSync, validateNxSync } from '../nx-sync.js';
 import { fixPackageHygiene, validatePackageHygiene } from '../package-hygiene.js';
-import { applyPublicPackageDefaults, applyWorkspaceDependencyDefaults, validateNxReleaseConfig, validatePublicPackageMetadata, validatePublicTags, validateRootPackagePolicy, validateWorkspaceDependencies, } from '../package-policy.js';
-import { validatePackedPublicPackages } from '../packed-package.js';
+import { applyFixableMonorepoDefaults, applyNxReleaseDefaults, applyPublicPackageDefaults, applyWorkspaceDependencyDefaults, validateNxProjectNames, validateNxReleaseConfig, validatePublicPackageMetadata, validatePublicTags, validateRootPackagePolicy, validateWorkspaceDependencies, } from '../package-policy.js';
+import { validatePackedPublicPackageManifest, validatePackedPublicPackagePublint, validatePackedPublicPackageTypes, } from '../packed-package.js';
 import { syncRootRuntimeVersions } from '../runtime.js';
+import { applyToolConfigDefaults, validateToolConfig } from '../tool-validation.js';
 const packs = [
     {
         name: 'core',
         async init(ctx) {
             ensureLocalSmooShim(ctx.root);
+            applyNxReleaseDefaults(ctx.root);
             if (ctx.syncRuntime) {
                 await syncRootRuntimeVersions(ctx.root);
             }
@@ -18,11 +23,21 @@ const packs = [
                 console.log('skip           root runtime versions (outside devenv; pass --sync-runtime to force)');
             }
         },
-        async validate(ctx) {
+        async fixPreBuild(ctx) {
+            applyFixableMonorepoDefaults(ctx.root);
+            await applyToolConfigDefaults(ctx.root);
+            syncBunLockfileVersions(ctx.root);
+            await fixNxSync(ctx.root, ctx.verbose === true);
+            applyWorkspaceDependencyDefaults(ctx.root, { resolvedTargetsByProject: await readResolvedTargetsByProject(ctx) });
+        },
+        async validatePreBuild(ctx) {
             return (validateManagedFiles(ctx.root) +
                 validateRootPackagePolicy(ctx.root) +
+                validateToolConfig(ctx.root) +
+                validateNxProjectNames(ctx.root) +
                 validateNxReleaseConfig(ctx.root) +
-                (await validateNxSync(ctx.root)));
+                validateBunLockfileVersions(ctx.root) +
+                (await validateNxSync(ctx.root, ctx.verbose === true)));
         },
     },
     {
@@ -30,24 +45,55 @@ const packs = [
         init(ctx) {
             applyPublicPackageDefaults(ctx.root);
         },
-        validate(ctx) {
+        fixPreBuild(ctx) {
+            applyPublicPackageDefaults(ctx.root);
+        },
+        validatePreBuild(ctx) {
             return validatePublicTags(ctx.root) + validatePublicPackageMetadata(ctx.root);
         },
     },
     {
         name: 'workspace-dependencies',
-        async init(ctx) {
+        init(ctx) {
             applyWorkspaceDependencyDefaults(ctx.root);
+        },
+        async fixPostBuild(ctx) {
+            applyWorkspaceDependencyDefaults(ctx.root, { resolvedTargetsByProject: await readResolvedTargetsByProject(ctx) });
+        },
+        async validatePostBuild(ctx) {
+            return validateWorkspaceDependencies(ctx.root, {
+                resolvedTargetsByProject: await readResolvedTargetsByProject(ctx),
+            });
+        },
+    },
+    {
+        name: 'package-hygiene',
+        async init(ctx) {
+            await fixPackageHygiene(ctx.root, ctx.verbose === true);
+        },
+        async fixPostBuild(ctx) {
             await fixPackageHygiene(ctx.root);
         },
-        async validate(ctx) {
-            return validateWorkspaceDependencies(ctx.root) + (await validatePackageHygiene(ctx.root));
+        async validatePostBuild(ctx) {
+            return validatePackageHygiene(ctx.root, ctx.verbose === true);
+        },
+    },
+    {
+        name: 'packed-package-publint',
+        validatePostBuild(ctx) {
+            return validatePackedPublicPackagePublint(ctx.root);
+        },
+    },
+    {
+        name: 'packed-package-manifest',
+        validatePostBuild(ctx) {
+            return validatePackedPublicPackageManifest(ctx.root);
         },
     },
     {
-        name: 'packed-packages',
-        validate(ctx) {
-            return validatePackedPublicPackages(ctx.root);
+        name: 'packed-package-types',
+        validatePostBuild(ctx) {
+            return validatePackedPublicPackageTypes(ctx.root);
         },
     },
 ];
@@ -56,22 +102,198 @@ export async function runInitPacks(ctx) {
         await pack.init?.(ctx);
     }
 }
-export async function runValidatePacks(ctx, options = {}) {
+export async function runValidatePacks(ctx, options = {}, hooks = {}) {
+    const selectedPacks = hooks.packs ?? packs;
+    const build = hooks.runBuild ?? runBuild;
+    if (options.fix) {
+        await runFixPhase(ctx, selectedPacks, 'pre-build', 'fixPreBuild');
+        const buildFailures = await build(ctx, options);
+        if (buildFailures > 0) {
+            return { failures: buildFailures, failedChecks: 1 };
+        }
+        await runFixPhase(ctx, selectedPacks, 'post-build', 'fixPostBuild');
+        return runValidationPhases(ctx, selectedPacks, options, false);
+    }
+    const preBuild = await runValidationPhase(ctx, selectedPacks, options, 'pre-build', 'validatePreBuild', false);
+    if (preBuild.failures > 0 && options.failFast) {
+        return preBuild;
+    }
+    const buildFailures = await build(ctx, options);
+    if (buildFailures > 0) {
+        return { failures: preBuild.failures + buildFailures, failedChecks: preBuild.failedChecks + 1 };
+    }
+    return sumResults(preBuild, await runValidationPhase(ctx, selectedPacks, options, 'post-build', 'validatePostBuild', true));
+}
+async function runValidationPhases(ctx, selectedPacks, options, printedBefore) {
+    const preBuild = await runValidationPhase(ctx, selectedPacks, options, 'pre-build', 'validatePreBuild', printedBefore);
+    if (preBuild.failures > 0 && options.failFast) {
+        return preBuild;
+    }
+    return sumResults(preBuild, await runValidationPhase(ctx, selectedPacks, options, 'post-build', 'validatePostBuild', true));
+}
+async function runValidationPhase(ctx, selectedPacks, options, phase, method, printedBefore) {
     let failures = 0;
+    let failedChecks = 0;
     let checkedPacks = 0;
-    for (const pack of packs) {
-        if (!pack.validate) {
+    let hasPrinted = printedBefore;
+    for (const pack of selectedPacks) {
+        const validate = pack[method];
+        if (!validate) {
             continue;
         }
-        console.log(`${checkedPacks === 0 ? '' : '\n'}== ${pack.name} ==`);
+        const label = `${pack.name} (${phase})`;
+        if (options.verbose) {
+            printCheckHeading(label, hasPrinted || checkedPacks > 0);
+        }
+        hasPrinted = true;
         checkedPacks++;
-        const packFailures = await pack.validate(ctx);
+        let packFailures;
+        let output = emptyCapturedOutput();
+        try {
+            if (options.verbose) {
+                packFailures = await validate(ctx);
+            }
+            else {
+                const captured = await captureConsoleOutput(() => validate(ctx));
+                packFailures = captured.result;
+                output = captured.output;
+            }
+        }
+        catch (error) {
+            if (!options.verbose) {
+                printCheckHeading(label, true);
+                if (error instanceof CapturedConsoleError) {
+                    output = error.output;
+                }
+                printCapturedOutput(output);
+            }
+            throw error instanceof CapturedConsoleError ? error.cause : error;
+        }
         failures += packFailures;
+        if (packFailures > 0) {
+            failedChecks++;
+        }
+        if (!options.verbose && packFailures > 0) {
+            printCheckHeading(label, true);
+            printCapturedOutput(output);
+        }
+        printCheckStatus(label, packFailures);
         if (packFailures > 0 && options.failFast) {
             break;
         }
     }
-    return failures;
+    return { failures, failedChecks };
+}
+function sumResults(left, right) {
+    return { failures: left.failures + right.failures, failedChecks: left.failedChecks + right.failedChecks };
+}
+async function runFixPhase(ctx, selectedPacks, phase, method) {
+    let checkedPacks = 0;
+    for (const pack of selectedPacks) {
+        const fix = pack[method];
+        if (!fix) {
+            continue;
+        }
+        const label = `${pack.name} (${phase} fix)`;
+        if (ctx.verbose) {
+            printCheckHeading(label, checkedPacks > 0);
+        }
+        checkedPacks++;
+        if (ctx.verbose) {
+            await fix(ctx);
+            continue;
+        }
+        let output = emptyCapturedOutput();
+        try {
+            output = (await captureConsoleOutput(() => fix(ctx))).output;
+        }
+        catch (error) {
+            if (error instanceof CapturedConsoleError) {
+                output = error.output;
+            }
+            printCheckHeading(label, true);
+            printCapturedOutput(output);
+            throw error instanceof CapturedConsoleError ? error.cause : error;
+        }
+    }
+}
+async function runBuild(ctx, options = {}) {
+    if (options.verbose) {
+        printCheckHeading('build', true);
+    }
+    const status = await runStatus('nx', ['run-many', '-t', 'build'], ctx.root, options.verbose !== true);
+    if (status !== 0) {
+        if (!options.verbose) {
+            printCheckHeading('build', true);
+        }
+        console.error('nx run-many -t build failed');
+        printCheckStatus('build', 1);
+        return 1;
+    }
+    printCheckStatus('build', 0);
+    return 0;
+}
+function printCheckStatus(label, failures) {
+    if (failures === 0) {
+        console.log(`🆗 ${label}`);
+        return;
+    }
+    const noun = failures === 1 ? 'problem' : 'problems';
+    console.log(`👎 ${label} (${failures} ${noun})\n`);
+}
+function printCheckHeading(label, separate) {
+    console.log(`${separate ? '\n' : ''}== ${label} ==`);
+}
+function emptyCapturedOutput() {
+    return { logs: [], errors: [] };
+}
+async function captureConsoleOutput(fn) {
+    const output = emptyCapturedOutput();
+    const originalLog = console.log;
+    const originalError = console.error;
+    console.log = (...args) => {
+        output.logs.push(args.join(' '));
+    };
+    console.error = (...args) => {
+        output.errors.push(args.join(' '));
+    };
+    try {
+        return { result: await fn(), output };
+    }
+    catch (error) {
+        throw new CapturedConsoleError(error, output);
+    }
+    finally {
+        console.log = originalLog;
+        console.error = originalError;
+    }
+}
+class CapturedConsoleError extends Error {
+    cause;
+    output;
+    constructor(cause, output) {
+        super(cause instanceof Error ? cause.message : String(cause));
+        this.cause = cause;
+        this.output = output;
+    }
+}
+function printCapturedOutput(output) {
+    for (const line of output.logs) {
+        console.log(line);
+    }
+    for (const line of output.errors) {
+        console.log(line);
+    }
+}
+async function readResolvedTargetsByProject(ctx) {
+    const projects = await readProjectTargets(ctx.root);
+    return new Map(projects.map((project) => [
+        project.project,
+        {
+            targets: new Set(project.targets),
+            ...(project.buildDependsOn ? { buildDependsOn: project.buildDependsOn } : {}),
+        },
+    ]));
 }
 function ensureLocalSmooShim(root) {
     const shim = join(root, 'tooling', 'smoo');

package/dist/monorepo/publish-workflow.d.ts

@@ -0,0 +1,82 @@
+export type PublishWorkflowBump = 'auto' | 'patch' | 'minor' | 'major' | 'prerelease';
+export type PublishWorkflowCondition = 'version-mode-not-none' | 'failure' | 'always';
+export type PublishWorkflowNxTarget = 'build' | 'lint' | 'test';
+export declare enum PublishWorkflowStepKind {
+    Checkout = "checkout",
+    SetupDevenv = "setup-devenv",
+    ConfigureReleaseAuthor = "configure-release-author",
+    BuildSelfHostedCli = "build-self-hosted-cli",
+    RepairPendingReleases = "repair-pending-releases",
+    VersionRelease = "version-release",
+    CheckManagedMonorepoFiles = "check-managed-monorepo-files",
+    Build = "build",
+    Lint = "lint",
+    UnitTests = "unit-tests",
+    UploadTraceDbs = "upload-trace-dbs",
+    ValidateMonorepoConfig = "validate-monorepo-config",
+    PublishRelease = "publish-release",
+    SaveNixDevenv = "save-nix-devenv"
+}
+export interface PublishWorkflowStep {
+    kind: PublishWorkflowStepKind;
+    name: string;
+    number: number;
+    id?: string;
+    condition?: PublishWorkflowCondition;
+    nxTarget?: PublishWorkflowNxTarget;
+}
+export interface PublishWorkflowDefinition {
+    steps: PublishWorkflowStep[];
+}
+export interface PublishWorkflowDefinitionOptions {
+    repoName?: string;
+}
+export interface PublishWorkflowInputs {
+    bump: PublishWorkflowBump;
+    dryRun: boolean;
+}
+export interface PublishWorkflowVersionOutputs {
+    mode: 'new' | 'none';
+    projects: string[];
+}
+export interface PublishWorkflowSetupOutputs {
+    nixCacheHit: string;
+    devenvCacheHit: string;
+}
+export interface PublishWorkflowCallbacks {
+    checkout(): Promise<void>;
+    setupDevenv(): Promise<PublishWorkflowSetupOutputs>;
+    configureReleaseAuthor(): Promise<void>;
+    buildSelfHostedCli(): Promise<void>;
+    repairPendingReleases(input: {
+        dryRun: boolean;
+    }): Promise<void>;
+    versionRelease(input: {
+        bump: PublishWorkflowBump;
+        dryRun: boolean;
+    }): Promise<PublishWorkflowVersionOutputs>;
+    checkManagedMonorepoFiles(): Promise<void>;
+    nxRunMany(input: {
+        target: PublishWorkflowNxTarget;
+        projects: string[];
+    }): Promise<void>;
+    uploadTraceDbs(): Promise<void>;
+    validateMonorepoConfig(): Promise<void>;
+    publishRelease(input: {
+        bump: PublishWorkflowBump;
+        dryRun: boolean;
+    }): Promise<void>;
+    saveNixDevenv(input: PublishWorkflowSetupOutputs): Promise<void>;
+}
+export interface PublishWorkflowRunContext {
+    inputs: PublishWorkflowInputs;
+    callbacks: PublishWorkflowCallbacks;
+}
+export interface PublishWorkflowRunResult {
+    version: PublishWorkflowVersionOutputs;
+    failed: boolean;
+}
+export declare function definePublishWorkflow(options?: PublishWorkflowDefinitionOptions): PublishWorkflowDefinition;
+export declare function runPublishWorkflow(workflow: PublishWorkflowDefinition, context: PublishWorkflowRunContext): Promise<PublishWorkflowRunResult>;
+export declare function renderPublishWorkflowYaml(options?: PublishWorkflowDefinitionOptions): string;
+//# sourceMappingURL=publish-workflow.d.ts.map

package/dist/monorepo/publish-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-workflow.d.ts","sourceRoot":"","sources":["../../src/monorepo/publish-workflow.ts"],"names":[],"mappings":"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"}