@smoothbricks/cli 0.1.1 → 0.3.0

package/dist/monorepo/package-policy.js

@@ -1,8 +1,57 @@
 import { join } from 'node:path';
+import { applyWorkspaceBoundedTestTargetPolicy, checkWorkspaceBoundedTestTargetPolicy, } from '@smoothbricks/nx-plugin/bounded-test-policy';
+import { applyPackageTargetPolicy, checkPackageTargetPolicy, } from '@smoothbricks/nx-plugin/package-target-policy';
+import { applyReleaseConfigPolicy, checkReleaseConfigPolicy, SMOO_NX_RELEASE_TAG_PATTERN, SMOO_NX_VERSION_ACTIONS, } from '@smoothbricks/nx-plugin/release-config-policy';
+import { applyTypecheckTestPolicy, checkTypecheckTestPolicy } from '@smoothbricks/nx-plugin/typecheck-test-policy';
+import { applyWorkspaceConfigPolicy, checkWorkspaceConfigPolicy, } from '@smoothbricks/nx-plugin/workspace-config-policy';
 import { getOrCreateRecord, hasOwnString, isRecord, readJsonObject, recordProperty, requiredJsonObject, setMissingStringProperty, setStringProperty, stringProperty, writeJsonObject, } from '../lib/json.js';
-import { getWorkspacePackages, listPackageJsonRecords, listPublicPackages, packageRepositoryInfo, repositoryInfo, sameRepositoryAfterNormalization, workspaceDependencyFields, } from '../lib/workspace.js';
-export const SMOO_NX_VERSION_ACTIONS = '@smoothbricks/cli/nx-version-actions';
-export const SMOO_NX_RELEASE_TAG_PATTERN = '{projectName}@{version}';
+import { getWorkspacePackageManifests, getWorkspacePackages, listPackageJsonRecords, listPublicPackages, packageRepositoryInfo, repositoryInfo, sameRepositoryAfterNormalization, workspaceDependencyFields, } from '../lib/workspace.js';
+export { SMOO_NX_RELEASE_TAG_PATTERN, SMOO_NX_VERSION_ACTIONS };
+const extraCommitScopes = ['release'];
+const rootScriptPolicy = {
+    lint: 'nx run-many -t lint',
+    'lint:fix': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml --unstaged',
+    'format:staged': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml',
+    'format:changed': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml --also-unstaged',
+};
+export function applyFixableMonorepoDefaults(root) {
+    applyRootScriptDefaults(root);
+    applyNxPluginDefaults(root);
+    applyNxProjectNameDefaults(root);
+}
+export function applyRootScriptDefaults(root) {
+    const rootPackagePath = join(root, 'package.json');
+    const rootPackage = readJsonObject(rootPackagePath);
+    if (!rootPackage) {
+        return;
+    }
+    const scripts = getOrCreateRecord(rootPackage, 'scripts');
+    let changed = false;
+    for (const [name, command] of Object.entries(rootScriptPolicy)) {
+        changed = setStringProperty(scripts, name, command) || changed;
+    }
+    const nx = getOrCreateRecord(rootPackage, 'nx');
+    if (!Array.isArray(nx.includedScripts) || nx.includedScripts.length !== 0) {
+        nx.includedScripts = [];
+        changed = true;
+    }
+    changed = sortRecordInPlace(scripts) || changed;
+    if (changed) {
+        writeJsonObject(rootPackagePath, rootPackage);
+        console.log('updated        package.json root smoo scripts');
+    }
+    else {
+        console.log('unchanged      package.json root smoo scripts');
+    }
+}
+export function applyNxPluginDefaults(root) {
+    if (applyWorkspaceConfigPolicy(root)) {
+        console.log('updated        nx.json smoo plugin config');
+    }
+    else {
+        console.log('unchanged      nx.json smoo plugin config');
+    }
+}
 export function applyPublicPackageDefaults(root) {
     const rootPackage = requiredJsonObject(join(root, 'package.json'));
     const rootLicense = stringProperty(rootPackage, 'license');
@@ -39,7 +88,7 @@ export function applyPublicPackageDefaults(root) {
         }
     }
 }
-export function applyWorkspaceDependencyDefaults(root) {
+export function applyWorkspaceDependencyDefaults(root, options = {}) {
     const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
     for (const pkg of listPackageJsonRecords(root)) {
         const changed = fixWorkspaceDependencyRanges(pkg.json, workspaceNames);
@@ -47,49 +96,76 @@ export function applyWorkspaceDependencyDefaults(root) {
             writeJsonObject(pkg.packageJsonPath, pkg.json);
             console.log(`updated        ${pkg.path}/package.json workspace dependency ranges`);
         }
-        else {
-            console.log(`unchanged      ${pkg.path}/package.json workspace dependency ranges`);
-        }
     }
-}
-export function applyNxReleaseDefaults(root) {
-    const nxJsonPath = join(root, 'nx.json');
-    const nxJson = requiredJsonObject(nxJsonPath);
-    let changed = false;
-    const release = getOrCreateRecord(nxJson, 'release');
-    changed = setStringProperty(release, 'projectsRelationship', 'independent') || changed;
-    const version = getOrCreateRecord(release, 'version');
-    changed = setStringProperty(version, 'specifierSource', 'conventional-commits') || changed;
-    changed = setStringProperty(version, 'currentVersionResolver', 'git-tag') || changed;
-    changed = setStringProperty(version, 'fallbackCurrentVersionResolver', 'disk') || changed;
-    changed = setStringProperty(version, 'versionActions', SMOO_NX_VERSION_ACTIONS) || changed;
-    if (delete version.preVersionCommand) {
-        changed = true;
+    if (applyPackageTargetPolicy(root, options)) {
+        console.log('updated        package Nx target policy');
     }
-    const releaseTag = getOrCreateRecord(release, 'releaseTag');
-    changed = setStringProperty(releaseTag, 'pattern', SMOO_NX_RELEASE_TAG_PATTERN) || changed;
-    const changelog = getOrCreateRecord(release, 'changelog');
-    changed = setBooleanProperty(changelog, 'workspaceChangelog', false) || changed;
-    const projectChangelogs = getOrCreateRecord(changelog, 'projectChangelogs');
-    changed = setBooleanProperty(projectChangelogs, 'createRelease', false) || changed;
-    changed = setBooleanProperty(projectChangelogs, 'file', false) || changed;
-    const renderOptions = getOrCreateRecord(projectChangelogs, 'renderOptions');
-    if (typeof renderOptions.authors !== 'boolean') {
-        renderOptions.authors = true;
-        changed = true;
+    else {
+        console.log('unchanged      package Nx target policy');
     }
-    if (typeof renderOptions.applyUsernameToAuthors !== 'boolean') {
-        renderOptions.applyUsernameToAuthors = true;
-        changed = true;
+    if (applyTypecheckTestPolicy(root)) {
+        console.log('updated        tsconfig.test.json policy');
     }
-    if (changed) {
-        writeJsonObject(nxJsonPath, nxJson);
+    else {
+        console.log('unchanged      tsconfig.test.json policy');
+    }
+    if (applyWorkspaceBoundedTestTargetPolicy(root)) {
+        console.log('updated        package test targets bounded execution policy');
+    }
+    else {
+        console.log('unchanged      package test targets bounded execution policy');
+    }
+}
+export function applyNxReleaseDefaults(root) {
+    if (applyReleaseConfigPolicy(root)) {
         console.log('updated        nx.json release config');
     }
     else {
         console.log('unchanged      nx.json release config');
     }
 }
+export function applyNxProjectNameDefaults(root) {
+    const rootPackage = requiredJsonObject(join(root, 'package.json'));
+    const rootName = stringProperty(rootPackage, 'name');
+    if (!rootName) {
+        return;
+    }
+    for (const pkg of getWorkspacePackageManifests(root)) {
+        const suggestedName = suggestNxProjectName(rootName, pkg.name);
+        if (!suggestedName) {
+            continue;
+        }
+        const nx = getOrCreateRecord(pkg.json, 'nx');
+        const changed = setStringProperty(nx, 'name', suggestedName);
+        if (changed) {
+            writeJsonObject(pkg.packageJsonPath, pkg.json);
+            console.log(`updated        ${pkg.path}/package.json nx.name`);
+        }
+        else {
+            console.log(`unchanged      ${pkg.path}/package.json nx.name`);
+        }
+    }
+}
+export function listValidCommitScopes(root) {
+    return new Set([...listNxProjectNames(root), ...extraCommitScopes]);
+}
+export function listNxProjectNames(root) {
+    const rootPackage = readJsonObject(join(root, 'package.json'));
+    const rootName = rootPackage ? stringProperty(rootPackage, 'name') : null;
+    const names = [];
+    for (const pkg of getWorkspacePackageManifests(root)) {
+        const nx = recordProperty(pkg.json, 'nx');
+        const configuredName = nx ? stringProperty(nx, 'name') : null;
+        const suggestedName = rootName ? suggestNxProjectName(rootName, pkg.name) : null;
+        if (configuredName) {
+            names.push(configuredName);
+        }
+        else if (suggestedName) {
+            names.push(suggestedName);
+        }
+    }
+    return names;
+}
 export function validateRootPackagePolicy(root) {
     const rootPackage = readJsonObject(join(root, 'package.json'));
     if (!rootPackage) {
@@ -109,6 +185,8 @@ export function validateRootPackagePolicy(root) {
         console.error('package.json must define repository.url');
         failures++;
     }
+    failures += validateRootScripts(rootPackage);
+    failures += validateRootNxScriptInference(rootPackage);
     const packageManager = stringProperty(rootPackage, 'packageManager');
     if (!packageManager?.startsWith('bun@')) {
         console.error('package.json packageManager must use bun@<version>');
@@ -128,83 +206,38 @@ export function validateRootPackagePolicy(root) {
     return failures;
 }
 export function validateNxReleaseConfig(root) {
-    const nxJson = readJsonObject(join(root, 'nx.json'));
-    if (!nxJson) {
-        console.error('nx.json not found or invalid');
-        return 1;
-    }
-    const release = recordProperty(nxJson, 'release');
-    const version = release ? recordProperty(release, 'version') : null;
-    const releaseTag = release ? recordProperty(release, 'releaseTag') : null;
-    const changelog = release ? recordProperty(release, 'changelog') : null;
-    const projectChangelogs = changelog ? recordProperty(changelog, 'projectChangelogs') : null;
-    const renderOptions = projectChangelogs ? recordProperty(projectChangelogs, 'renderOptions') : null;
     let failures = 0;
-    if (!release) {
-        console.error('nx.json release config is missing');
-        failures++;
-    }
-    if (release && stringProperty(release, 'projectsRelationship') !== 'independent') {
-        console.error('nx.json release.projectsRelationship must be independent');
-        failures++;
-    }
-    if (!version) {
-        console.error('nx.json release.version config is missing');
+    for (const issue of checkWorkspaceConfigPolicy(root)) {
+        console.error(issue.message);
         failures++;
     }
-    if (version && stringProperty(version, 'specifierSource') !== 'conventional-commits') {
-        console.error('nx.json release.version.specifierSource must be conventional-commits');
+    for (const issue of checkReleaseConfigPolicy(root)) {
+        console.error(issue.message);
         failures++;
     }
-    // Nx requires git-tag as the primary resolver when deriving versions from
-    // conventional commits. Disk is only a fallback for initial untagged packages.
-    if (version && stringProperty(version, 'currentVersionResolver') !== 'git-tag') {
-        console.error('nx.json release.version.currentVersionResolver must be git-tag');
-        failures++;
-    }
-    if (version && stringProperty(version, 'fallbackCurrentVersionResolver') !== 'disk') {
-        console.error('nx.json release.version.fallbackCurrentVersionResolver must be disk');
-        failures++;
-    }
-    if (version && stringProperty(version, 'versionActions') !== SMOO_NX_VERSION_ACTIONS) {
-        console.error(`nx.json release.version.versionActions must be ${SMOO_NX_VERSION_ACTIONS}`);
-        failures++;
-    }
-    if (version && stringProperty(version, 'preVersionCommand')) {
-        console.error('nx.json release.version.preVersionCommand must not be defined; smoo builds npm-missing packages before publish');
-        failures++;
-    }
-    if (!releaseTag) {
-        console.error('nx.json release.releaseTag config is missing');
-        failures++;
-    }
-    if (releaseTag && stringProperty(releaseTag, 'pattern') !== SMOO_NX_RELEASE_TAG_PATTERN) {
-        console.error(`nx.json release.releaseTag.pattern must be ${SMOO_NX_RELEASE_TAG_PATTERN}`);
-        failures++;
-    }
-    if (!changelog) {
-        console.error('nx.json release.changelog config is missing');
-        failures++;
-    }
-    if (changelog && changelog.workspaceChangelog !== false) {
-        console.error('nx.json release.changelog.workspaceChangelog must be false');
-        failures++;
-    }
-    if (!projectChangelogs) {
-        console.error('nx.json release.changelog.projectChangelogs config is missing');
-        failures++;
-    }
-    if (projectChangelogs && projectChangelogs.createRelease !== false) {
-        console.error('nx.json release.changelog.projectChangelogs.createRelease must be false');
-        failures++;
+    return failures;
+}
+export function validateNxProjectNames(root) {
+    const rootPackage = readJsonObject(join(root, 'package.json'));
+    const rootName = rootPackage ? stringProperty(rootPackage, 'name') : null;
+    if (!rootName) {
+        return 0;
     }
-    if (projectChangelogs && projectChangelogs.file !== false) {
-        console.error('nx.json release.changelog.projectChangelogs.file must be false');
-        failures++;
+    let failures = 0;
+    for (const pkg of getWorkspacePackageManifests(root)) {
+        const suggestedName = suggestNxProjectName(rootName, pkg.name);
+        if (!suggestedName) {
+            continue;
+        }
+        const nx = recordProperty(pkg.json, 'nx');
+        const configuredName = nx ? stringProperty(nx, 'name') : null;
+        if (configuredName !== suggestedName) {
+            console.error(`${pkg.path}: package.json nx.name must be "${suggestedName}" so fix(${suggestedName}): maps to this project`);
+            failures++;
+        }
     }
-    if (!renderOptions) {
-        console.error('nx.json release.changelog.projectChangelogs.renderOptions config is missing');
-        failures++;
+    if (failures === 0) {
+        console.log('Nx project names are valid.');
     }
     return failures;
 }
@@ -278,9 +311,9 @@ export function validatePublicPackageMetadata(root) {
     }
     return failures;
 }
-export function validateWorkspaceDependencies(root) {
-    const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
+export function validateWorkspaceDependencies(root, options = {}) {
     let failures = 0;
+    const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
     for (const pkg of listPackageJsonRecords(root)) {
         for (const field of workspaceDependencyFields) {
             const dependencies = recordProperty(pkg.json, field);
@@ -295,11 +328,26 @@ export function validateWorkspaceDependencies(root) {
             }
         }
     }
+    for (const issue of checkPackageTargetPolicy(root, options)) {
+        console.error(`${issue.path}: ${issue.message}`);
+        failures++;
+    }
+    for (const issue of checkTypecheckTestPolicy(root)) {
+        console.error(`${issue.path}: ${issue.message}`);
+        failures++;
+    }
+    for (const issue of checkWorkspaceBoundedTestTargetPolicy(root)) {
+        console.error(`${issue.path}: ${issue.message}`);
+        failures++;
+    }
     if (failures === 0) {
-        console.log('Workspace dependency ranges are valid.');
+        console.log('Workspace dependency policy is valid.');
     }
     return failures;
 }
+// ---------------------------------------------------------------------------
+// Helpers kept in CLI (not Nx-specific)
+// ---------------------------------------------------------------------------
 function fixWorkspaceDependencyRanges(pkg, workspaceNames) {
     let changed = false;
     for (const field of workspaceDependencyFields) {
@@ -316,11 +364,58 @@ function fixWorkspaceDependencyRanges(pkg, workspaceNames) {
     }
     return changed;
 }
-function setBooleanProperty(record, key, value) {
-    if (record[key] === value) {
+function validateRootScripts(rootPackage) {
+    const scripts = recordProperty(rootPackage, 'scripts');
+    let failures = 0;
+    for (const [name, command] of Object.entries(rootScriptPolicy)) {
+        if (scripts?.[name] !== command) {
+            console.error(`package.json scripts.${name} must be ${command}`);
+            failures++;
+        }
+    }
+    if (scripts && !recordKeysAreSorted(scripts)) {
+        console.error('package.json scripts must be sorted alphabetically so root command policy stays stable across fixes.');
+        failures++;
+    }
+    return failures;
+}
+function validateRootNxScriptInference(rootPackage) {
+    const nx = recordProperty(rootPackage, 'nx');
+    if (nx && Array.isArray(nx.includedScripts) && nx.includedScripts.length === 0) {
+        return 0;
+    }
+    console.error('package.json nx.includedScripts must be [] so root scripts do not become recursive Nx targets.');
+    return 1;
+}
+function suggestNxProjectName(rootPackageName, packageName) {
+    const rootScope = npmScope(rootPackageName);
+    if (!rootScope || npmScope(packageName) !== rootScope) {
+        return null;
+    }
+    return unscopedPackageName(packageName);
+}
+function npmScope(packageName) {
+    const match = /^(@[^/]+)\//.exec(packageName);
+    return match?.[1] ?? null;
+}
+function unscopedPackageName(packageName) {
+    return packageName.startsWith('@') ? packageName.slice(packageName.indexOf('/') + 1) : packageName;
+}
+function recordKeysAreSorted(record) {
+    const keys = Object.keys(record);
+    return keys.every((key, index) => index === 0 || keys[index - 1] <= key);
+}
+function sortRecordInPlace(record) {
+    if (recordKeysAreSorted(record)) {
         return false;
     }
-    record[key] = value;
+    const entries = Object.entries(record).sort(([a], [b]) => a.localeCompare(b));
+    for (const key of Object.keys(record)) {
+        delete record[key];
+    }
+    for (const [key, value] of entries) {
+        record[key] = value;
+    }
     return true;
 }
 function normalizeExportConditionOrder(value) {

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":"AAUA,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,64 +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 packedPackage = await readPackedPackageJson(root, packed.path, pkg.name);
-        for (const message of validatePackedWorkspaceDependencies(root, pkg, packedPackage)) {
-            console.error(message);
-            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":"AAmBA,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;AAyDD,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"}