@mui/internal-code-infra 0.0.3-canary.6 → 0.0.3-canary.61

package/src/cli/cmdPublishCanary.mjs

@@ -3,31 +3,371 @@
 /* eslint-disable no-console */
 
 /**
- * @typedef {import('./pnpm.mjs').PublicPackage} PublicPackage
- * @typedef {import('./pnpm.mjs').VersionInfo} VersionInfo
- * @typedef {import('./pnpm.mjs').PublishOptions} PublishOptions
+ * @typedef {import('../utils/pnpm.mjs').PublicPackage} PublicPackage
+ * @typedef {import('../utils/pnpm.mjs').VersionInfo} VersionInfo
+ * @typedef {import('../utils/pnpm.mjs').PublishOptions} PublishOptions
  */
 
+import path from 'node:path';
+import { createActionAuth } from '@octokit/auth-action';
+import { Octokit } from '@octokit/rest';
 import { $ } from 'execa';
 import * as semver from 'semver';
 
-/**
- * @typedef {Object} Args
- * @property {boolean} [dryRun] - Whether to run in dry-run mode
- */
-
 import {
-  getWorkspacePackages,
   getPackageVersionInfo,
+  getWorkspacePackages,
   publishPackages,
   readPackageJson,
-  writePackageJson,
-  getCurrentGitSha,
   semverMax,
-} from './pnpm.mjs';
+  writePackageJson,
+} from '../utils/pnpm.mjs';
+import { getCurrentGitSha, getRepositoryInfo } from '../utils/git.mjs';
+
+/**
+ * @typedef {Object} Args
+ * @property {boolean} [dryRun] - Whether to run in dry-run mode
+ * @property {boolean} [githubRelease] - Whether to create GitHub releases for canary packages
+ */
 
 const CANARY_TAG = 'canary';
 
+/**
+ * Get Octokit instance with authentication
+ * @returns {Octokit} Authenticated Octokit instance
+ */
+function getOctokit() {
+  return new Octokit({ authStrategy: createActionAuth });
+}
+
+/**
+ * @typedef {Object} Commit
+ * @property {string} sha - Commit SHA
+ * @property {string} message - Commit message
+ * @property {string} author - Commit author
+ */
+
+/**
+ * @param {Object} param0
+ * @param {string} param0.packagePath
+ * @returns {Promise<Commit[]>} Commits between the tag and current HEAD for the package
+ */
+async function fetchCommitsForPackage({ packagePath }) {
+  /**
+   * @type {Commit[]}
+   */
+  const results = [];
+  const fieldSeparator = '\u001f'; // ASCII unit separator is extremely unlikely to appear in git metadata
+  const formatArg = '--format=%H%x1f%s%x1f%an%x1f%ae'; // SHA, subject, author name, author email separated by unit separator
+  const res = $`git log --oneline --no-decorate ${
+    // to avoid escaping by execa
+    [formatArg]
+  } ${CANARY_TAG}..HEAD -- ${packagePath}`;
+  for await (const line of res) {
+    const commitLine = line.trimEnd();
+    if (!commitLine) {
+      continue;
+    }
+    const parts = commitLine.split(fieldSeparator);
+    if (parts.length < 3) {
+      console.error(`Failed to parse commit log line: ${commitLine}`);
+      continue;
+    }
+    const [sha, message, commitAuthor, commitEmail] = parts;
+    let author = commitAuthor;
+    // try to get github username from email
+    if (commitEmail) {
+      const emailUsername = commitEmail.split('@')[0];
+      if (emailUsername) {
+        const [, githubUserName] = emailUsername.split('+');
+        if (githubUserName) {
+          author = `@${githubUserName}`;
+        }
+      }
+    }
+    results.push({ sha, message, author });
+  }
+  return results;
+}
+
+const AUTHOR_EXCLUDE_LIST = ['renovate[bot]', 'dependabot[bot]'];
+
+/**
+ * @param {string} message
+ * @returns {string}
+ */
+function cleanupCommitMessage(message) {
+  // AI generated: clean up commit message by removing leading bracketed tokens except [breaking]
+  let msg = message || '';
+
+  // Extract and remove leading bracketed tokens like "[foo][bar] message"
+  const tokens = [];
+  const bracketRe = /^\s*\[([^\]]+)\]\s*/;
+  let match = msg.match(bracketRe);
+  while (match) {
+    tokens.push(match[1]);
+    msg = msg.slice(match[0].length);
+    match = msg.match(bracketRe);
+  }
+  msg = msg.trim();
+
+  // If any of the leading tokens is "breaking" keep that token (preserve original casing)
+  const breakingToken = tokens.find((t) => t.toLowerCase() === 'breaking');
+  const prefix = breakingToken ? `[${breakingToken}]${msg ? ' ' : ''}` : '';
+
+  return `${prefix}${msg}`.trim();
+}
+
+async function getPackageToDependencyMap() {
+  /**
+   * @type {(PublicPackage & { dependencies: Record<string, unknown>; private: boolean; })[]}
+   */
+  const packagesWithDeps = JSON.parse(
+    (await $`pnpm ls -r --json --exclude-peers --only-projects --prod`).stdout,
+  );
+  /** @type {Record<string, string[]>} */
+  const directPkgDependencies = packagesWithDeps
+    .filter((pkg) => !pkg.private)
+    .reduce((acc, pkg) => {
+      if (!pkg.name) {
+        return acc;
+      }
+      const deps = Object.keys(pkg.dependencies || {});
+      if (!deps.length) {
+        return acc;
+      }
+      acc[pkg.name] = deps;
+      return acc;
+    }, /** @type {Record<string, string[]>} */ ({}));
+  return directPkgDependencies;
+}
+
+/**
+ * @param {Record<string, string[]>} pkgGraph
+ */
+function resolveTransitiveDependencies(pkgGraph = {}) {
+  // Compute transitive (nested) dependencies limited to workspace packages and avoid cycles.
+  const workspacePkgNames = new Set(Object.keys(pkgGraph));
+  const nestedMap = /** @type {Record<string, string[]>} */ ({});
+
+  /**
+   *
+   * @param {string} pkgName
+   * @returns {string[]}
+   */
+  const getTransitiveDeps = (pkgName) => {
+    /**
+     * @type {Set<string>}
+     */
+    const seen = new Set();
+    const stack = (pkgGraph[pkgName] || []).slice();
+
+    while (stack.length) {
+      const dep = stack.pop();
+      if (!dep || seen.has(dep)) {
+        continue;
+      }
+      // Only consider workspace packages for transitive expansion
+      if (!workspacePkgNames.has(dep)) {
+        // still record external deps as direct deps but don't traverse into them
+        seen.add(dep);
+        continue;
+      }
+      seen.add(dep);
+      const children = pkgGraph[dep] || [];
+      for (const c of children) {
+        if (!seen.has(c)) {
+          stack.push(c);
+        }
+      }
+    }
+
+    return Array.from(seen);
+  };
+
+  for (const name of Object.keys(pkgGraph)) {
+    nestedMap[name] = getTransitiveDeps(name);
+  }
+
+  return nestedMap;
+}
+
+/**
+ * Prepare changelog data for packages using GitHub API
+ * @param {PublicPackage[]} packagesToPublish - Packages that will be published
+ * @param {PublicPackage[]} allPackages - All packages in the repository
+ * @param {Map<string, string>} canaryVersions - Map of package names to their canary versions
+ * @returns {Promise<Map<string, string[]>>} Map of package names to their changelogs
+ */
+async function prepareChangelogsFromGitCli(packagesToPublish, allPackages, canaryVersions) {
+  /**
+   * @type {Map<string, string[]>}
+   */
+  const changelogs = new Map();
+
+  await Promise.all(
+    packagesToPublish.map(async (pkg) => {
+      const commits = await fetchCommitsForPackage({ packagePath: pkg.path });
+      if (commits.length > 0) {
+        console.log(`Found ${commits.length} commits for package ${pkg.name}`);
+      }
+      const changeLogStrs = commits
+        // Exclude commits authored by bots
+        .filter(
+          // We want to allow commits from copilot or other AI tools, so only filter known bots
+          (commit) => !AUTHOR_EXCLUDE_LIST.includes(commit.author),
+        )
+        .map((commit) => `- ${cleanupCommitMessage(commit.message)} by ${commit.author}`);
+
+      if (changeLogStrs.length > 0) {
+        changelogs.set(pkg.name, changeLogStrs);
+      }
+    }),
+  );
+  // Second pass: check for dependency updates in other packages not part of git history
+  const pkgDependencies = await getPackageToDependencyMap();
+  const transitiveDependencies = resolveTransitiveDependencies(pkgDependencies);
+
+  for (let i = 0; i < allPackages.length; i += 1) {
+    const pkg = allPackages[i];
+    const depsToPublish = (transitiveDependencies[pkg.name] ?? []).filter((dep) =>
+      packagesToPublish.some((p) => p.name === dep),
+    );
+    if (depsToPublish.length === 0) {
+      continue;
+    }
+    const changelog = changelogs.get(pkg.name) ?? [];
+    changelog.push('- Updated dependencies:');
+    depsToPublish.forEach((dep) => {
+      const depVersion = canaryVersions.get(dep);
+      if (depVersion) {
+        changelog.push(`  - Bumped \`${dep}@${depVersion}\``);
+      }
+    });
+  }
+  return changelogs;
+}
+
+/**
+ * Prepare changelog data for packages
+ * @param {PublicPackage[]} packagesToPublish - Packages that will be published
+ * @param {PublicPackage[]} allPackages - All packages in the repository
+ * @param {Map<string, string>} canaryVersions - Map of package names to their canary versions
+ * @returns {Promise<Map<string, string[]>>} Map of package names to their changelogs
+ */
+async function prepareChangelogsForPackages(packagesToPublish, allPackages, canaryVersions) {
+  console.log('\n📝 Preparing changelogs for packages...');
+
+  const repoInfo = await getRepositoryInfo();
+  console.log(`📂 Repository: ${repoInfo.owner}/${repoInfo.repo}`);
+
+  /**
+   * @type {Map<string, string[]>}
+   */
+  const changelogs = await prepareChangelogsFromGitCli(
+    packagesToPublish,
+    allPackages,
+    canaryVersions,
+  );
+
+  // Log changelog content for each package
+  for (const pkg of packagesToPublish) {
+    const version = canaryVersions.get(pkg.name);
+    if (!version) {
+      continue;
+    }
+
+    const changelog = changelogs.get(pkg.name) || [];
+    console.log(`\n📦 ${pkg.name}@${version}`);
+    if (changelog.length > 0) {
+      console.log(
+        `   Changelog:\n${changelog.map((/** @type {string} */ line) => `   ${line}`).join('\n')}`,
+      );
+    }
+  }
+
+  console.log('\n✅ Changelogs prepared successfully');
+  return changelogs;
+}
+
+/**
+ * Create GitHub releases and tags for published packages
+ * @param {PublicPackage[]} publishedPackages - Packages that were published
+ * @param {Map<string, string>} canaryVersions - Map of package names to their canary versions
+ * @param {Map<string, string[]>} changelogs - Map of package names to their changelogs
+ * @param {{dryRun?: boolean}} options - Publishing options
+ * @returns {Promise<void>}
+ */
+async function createGitHubReleasesForPackages(
+  publishedPackages,
+  canaryVersions,
+  changelogs,
+  options,
+) {
+  console.log('\n🚀 Creating GitHub releases and tags for published packages...');
+
+  const repoInfo = await getRepositoryInfo();
+  const gitSha = await getCurrentGitSha();
+  const octokit = getOctokit();
+
+  for (const pkg of publishedPackages) {
+    const version = canaryVersions.get(pkg.name);
+    if (!version) {
+      console.log(`⚠️  No version found for ${pkg.name}, skipping...`);
+      continue;
+    }
+
+    const changelog = changelogs.get(pkg.name);
+    if (!changelog) {
+      console.log(`⚠️  No changelog found for ${pkg.name}, skipping release creation...`);
+      continue;
+    }
+    const tagName = `${pkg.name}@${version}`;
+    const releaseName = tagName;
+
+    console.log(`\n📦 Processing ${pkg.name}@${version}...`);
+
+    // Create git tag
+    if (options.dryRun) {
+      console.log(`🏷️  Would create and push git tag: ${tagName} (dry-run)`);
+      console.log(`📝  Would publish a Github release:`);
+      console.log(`     - Name: ${releaseName}`);
+      console.log(`     - Tag: ${tagName}`);
+      console.log(`     - Body:\n${changelog.join('\n')}`);
+    } else {
+      // eslint-disable-next-line no-await-in-loop
+      await $({
+        env: {
+          ...process.env,
+          GIT_COMMITTER_NAME: 'Code infra',
+          GIT_COMMITTER_EMAIL: 'code-infra@mui.com',
+        },
+      })`git tag -a ${tagName} -m ${`Canary release ${pkg.name}@${version}`}`;
+
+      // eslint-disable-next-line no-await-in-loop
+      await $`git push origin ${tagName}`;
+      console.log(`✅ Created and pushed git tag: ${tagName}`);
+
+      // Create GitHub release
+      // eslint-disable-next-line no-await-in-loop
+      const res = await octokit.repos.createRelease({
+        owner: repoInfo.owner,
+        repo: repoInfo.repo,
+        tag_name: tagName,
+        target_commitish: gitSha,
+        name: releaseName,
+        body: changelog.join('\n'),
+        draft: false,
+        prerelease: true, // Mark as prerelease since these are canary versions
+      });
+
+      console.log(`✅ Created GitHub release: ${releaseName} at ${res.data.html_url}`);
+    }
+  }
+
+  console.log('\n✅ Finished creating GitHub releases');
+}
+
 /**
  * Check if the canary git tag exists
  * @returns {Promise<string|null>} Canary tag name if exists, null otherwise
@@ -66,11 +406,13 @@ async function createCanaryTag(dryRun = false) {
 }
 
 /**
- * Publish canary versions with updated dependencies
+ * Publish canary versions with updated dependencies. A big assumption here is that
+ * all packages are already built before calling this function.
+ *
  * @param {PublicPackage[]} packagesToPublish - Packages that need canary publishing
  * @param {PublicPackage[]} allPackages - All workspace packages
  * @param {Map<string, VersionInfo>} packageVersionInfo - Version info map
- * @param {PublishOptions} [options={}] - Publishing options
+ * @param {PublishOptions & {githubRelease?: boolean}} [options={}] - Publishing options
  * @returns {Promise<void>}
  */
 async function publishCanaryVersions(
@@ -90,7 +432,6 @@ async function publishCanaryVersions(
 
   const gitSha = await getCurrentGitSha();
   const canaryVersions = new Map();
-  const originalPackageJsons = new Map();
 
   // First pass: determine canary version numbers for all packages
   const changedPackageNames = new Set(packagesToPublish.map((pkg) => pkg.name));
@@ -117,41 +458,44 @@ async function publishCanaryVersions(
   }
 
   // Second pass: read and update ALL package.json files in parallel
+  // Packages are already built at this point.
   const packageUpdatePromises = allPackages.map(async (pkg) => {
-    const originalPackageJson = await readPackageJson(pkg.path);
+    let basePkgJson = await readPackageJson(pkg.path);
+    let pkgJsonDirectory = pkg.path;
+    if (basePkgJson.publishConfig?.directory) {
+      pkgJsonDirectory = path.join(pkg.path, basePkgJson.publishConfig.directory);
+      basePkgJson = await readPackageJson(pkgJsonDirectory);
+    }
 
     const canaryVersion = canaryVersions.get(pkg.name);
     if (canaryVersion) {
       const updatedPackageJson = {
-        ...originalPackageJson,
+        ...basePkgJson,
         version: canaryVersion,
         gitSha,
       };
-
-      await writePackageJson(pkg.path, updatedPackageJson);
+      await writePackageJson(pkgJsonDirectory, updatedPackageJson);
       console.log(`📝 Updated ${pkg.name} package.json to ${canaryVersion}`);
     }
-
-    return { pkg, originalPackageJson };
+    return { pkg, basePkgJson, pkgJsonDirectory };
   });
 
   const updateResults = await Promise.all(packageUpdatePromises);
 
-  // Build the original package.json map
-  for (const { pkg, originalPackageJson } of updateResults) {
-    originalPackageJsons.set(pkg.name, originalPackageJson);
+  // Prepare changelogs before building and publishing (so it can error out early if there are issues)
+  /**
+   * @type {Map<string, string[]>}
+   */
+  let changelogs = new Map();
+  if (options.githubRelease) {
+    changelogs = await prepareChangelogsForPackages(packagesToPublish, allPackages, canaryVersions);
   }
 
-  // Run release build after updating package.json files
-  console.log('\n🔨 Running release build...');
-  await $({ stdio: 'inherit' })`pnpm release:build`;
-  console.log('✅ Release build completed successfully');
-
   // Third pass: publish only the changed packages using recursive publish
   let publishSuccess = false;
   try {
     console.log(`📤 Publishing ${packagesToPublish.length} canary versions...`);
-    await publishPackages(packagesToPublish, 'canary', { ...options, noGitChecks: true });
+    await publishPackages(packagesToPublish, { ...options, noGitChecks: true, tag: CANARY_TAG });
 
     packagesToPublish.forEach((pkg) => {
       const canaryVersion = canaryVersions.get(pkg.name);
@@ -161,9 +505,11 @@ async function publishCanaryVersions(
   } finally {
     // Always restore original package.json files in parallel
     console.log('\n🔄 Restoring original package.json files...');
-    const restorePromises = allPackages.map(async (pkg) => {
-      const originalPackageJson = originalPackageJsons.get(pkg.name);
-      await writePackageJson(pkg.path, originalPackageJson);
+    const restorePromises = updateResults.map(async ({ pkg, basePkgJson, pkgJsonDirectory }) => {
+      // no need to restore package.json files in build directories
+      if (pkgJsonDirectory === pkg.path) {
+        await writePackageJson(pkg.path, basePkgJson);
+      }
     });
 
     await Promise.all(restorePromises);
@@ -172,6 +518,12 @@ async function publishCanaryVersions(
   if (publishSuccess) {
     // Create/update the canary tag after successful publish
     await createCanaryTag(options.dryRun);
+
+    // Create GitHub releases if requested
+    if (options.githubRelease) {
+      await createGitHubReleasesForPackages(packagesToPublish, canaryVersions, changelogs, options);
+    }
+
     console.log('\n🎉 All canary versions published successfully!');
   }
 }
@@ -180,21 +532,31 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
   command: 'publish-canary',
   describe: 'Publish canary packages to npm',
   builder: (yargs) => {
-    return yargs.option('dry-run', {
-      type: 'boolean',
-      default: false,
-      description: 'Run in dry-run mode without publishing',
-    });
+    return yargs
+      .option('dry-run', {
+        type: 'boolean',
+        default: false,
+        description: 'Run in dry-run mode without publishing',
+      })
+      .option('github-release', {
+        type: 'boolean',
+        default: false,
+        description: 'Create GitHub releases for published packages',
+      });
   },
   handler: async (argv) => {
-    const { dryRun = false } = argv;
+    const { dryRun = false, githubRelease = false } = argv;
 
-    const options = { dryRun };
+    const options = { dryRun, githubRelease };
 
     if (dryRun) {
       console.log('🧪 Running in DRY RUN mode - no actual publishing will occur\n');
     }
 
+    if (githubRelease) {
+      console.log('📝 GitHub releases will be created for published packages\n');
+    }
+
     // Always get all packages first
     console.log('🔍 Discovering all workspace packages...');
     const allPackages = await getWorkspacePackages({ publicOnly: true });
@@ -207,16 +569,12 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
     // Check for canary tag to determine selective publishing
     const canaryTag = await getLastCanaryTag();
 
-    console.log(
-      canaryTag
-        ? '🔍 Checking for packages changed since canary tag...'
-        : '🔍 No canary tag found, will publish all packages',
-    );
+    console.log('🔍 Checking for packages changed since canary tag...');
     const packages = canaryTag
       ? await getWorkspacePackages({ sinceRef: canaryTag, publicOnly: true })
       : allPackages;
 
-    console.log(`📋 Found ${packages.length} packages that need canary publishing:`);
+    console.log(`📋 Found ${packages.length} packages(s) for canary publishing:`);
     packages.forEach((pkg) => {
       console.log(`   • ${pkg.name}@${pkg.version}`);
     });

package/src/cli/cmdPublishNewPackage.mjs

@@ -0,0 +1,86 @@
+/* eslint-disable no-console */
+
+import confirm from '@inquirer/confirm';
+import chalk from 'chalk';
+import { $ } from 'execa';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { getWorkspacePackages } from '../utils/pnpm.mjs';
+
+/**
+ * @typedef {Object} Args
+ * @property {boolean} [dryRun] If true, will only log the commands without executing them
+ */
+
+export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
+  command: 'publish-new-package [pkg...]',
+  describe: 'Publish new empty package(s) to the npm registry.',
+  builder: (yargs) =>
+    yargs.option('dryRun', {
+      type: 'boolean',
+      default: false,
+      description: 'If true, will only log the commands without executing them.',
+    }),
+  async handler(args) {
+    console.log(`🔍 Detecting new packages to publish in workspace...`);
+    const newPackages = await getWorkspacePackages({ nonPublishedOnly: true });
+
+    if (!newPackages.length) {
+      console.log('No new packages to publish.');
+      return;
+    }
+
+    console.log(`Found ${newPackages.map((pkg) => pkg.name).join(', ')} to publish.`);
+
+    const answer = await confirm({
+      message: `Do you want to publish ${newPackages.length} new package(s) to the npm registry?`,
+    });
+
+    if (!answer) {
+      return;
+    }
+
+    await Promise.all(
+      newPackages.map(async (pkg) => {
+        const newPkgDir = await fs.mkdtemp(path.join(os.tmpdir(), 'publish-new-package-'));
+        try {
+          await fs.mkdir(newPkgDir, { recursive: true });
+          const packageJson = {
+            name: pkg.name,
+            version: '0.0.1',
+          };
+          await fs.writeFile(
+            path.join(newPkgDir, 'package.json'),
+            `${JSON.stringify(packageJson, null, 2)}\n`,
+          );
+          /**
+           * @type {string[]}
+           */
+          const publishArgs = [];
+
+          if (args.dryRun) {
+            publishArgs.push('--dry-run');
+          }
+          await $({
+            cwd: newPkgDir,
+          })`npm publish --access public --tag=canary ${publishArgs}`;
+          console.log(
+            `✅ ${args.dryRun ? '[Dry run] ' : ''}Published ${chalk.bold(`${pkg.name}@${packageJson.version}`)} to npm registry.`,
+          );
+        } finally {
+          await fs.rm(newPkgDir, { recursive: true, force: true });
+        }
+      }),
+    );
+
+    const trustedPublisherLinks = newPackages
+      .map((pkg) => `https://www.npmjs.com/package/${pkg.name}/access`)
+      .join('\n');
+    console.log(`
+📝 Please ensure that the ${chalk.underline(chalk.bold('Trusted Publishers'))} settings are configured for the new package(s):
+${trustedPublisherLinks}
+Read how to do that here - https://github.com/mui/mui-public/blob/master/packages/code-infra/README.md#adding-and-publishing-new-packages`);
+  },
+});

package/src/cli/cmdSetVersionOverrides.mjs

@@ -5,7 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import * as semver from 'semver';
 import { $ } from 'execa';
-import { resolveVersion, findDependencyVersionFromSpec } from './pnpm.mjs';
+import { resolveVersion, findDependencyVersionFromSpec } from '../utils/pnpm.mjs';
 
 /**
  * @typedef {Object} Args
@@ -51,6 +51,22 @@ async function processPackageOverride(packageSpec) {
     if (reactMajor === 17) {
       overrides['@testing-library/react'] = await resolveVersion('@testing-library/react@^12.1.0');
     }
+  } else if (packageName === '@mui/material') {
+    // Special case for MUI - also override related packages
+    overrides['@mui/material'] = await resolveVersion(`@mui/material@${version}`);
+    overrides['@mui/system'] = await resolveVersion(`@mui/system@${version}`);
+    overrides['@mui/icons-material'] = await resolveVersion(`@mui/icons-material@${version}`);
+    overrides['@mui/utils'] = await resolveVersion(`@mui/utils@${version}`);
+    overrides['@mui/material-nextjs'] = await resolveVersion(`@mui/material-nextjs@${version}`);
+
+    const latest = await resolveVersion(`@mui/material@latest`);
+    const latestMajor = semver.major(latest);
+    const muiMajor = semver.major(overrides['@mui/material']);
+    if (muiMajor < latestMajor) {
+      overrides['@mui/lab'] = await resolveVersion(`@mui/lab@latest-v${muiMajor}`);
+    } else {
+      overrides['@mui/lab'] = await resolveVersion(`@mui/lab@latest`);
+    }
   } else {
     // Generic case for other packages
     overrides[packageName] = await resolveVersion(packageSpec);