@mui/internal-code-infra 0.0.4-canary.97 → 0.0.4-canary.99

package/build/brokenLinksChecker/index.d.mts

@@ -1,40 +1,103 @@
 export type LinkStructure = Map<string, Set<string>>;
 export type SerializedLinkStructure = {
+    /**
+     * - Object mapping page URLs to arrays of target IDs
+     */
     targets: Record<string, string[]>;
 };
 export type CrawlWorkerInput = {
+    /**
+     * - The page URL to crawl
+     */
     pageUrl: string;
+    /**
+     * - Fully resolved crawl options
+     */
     options: ResolvedCrawlOptions;
 };
 export type CrawlWorkerPageData = {
+    /**
+     * - The normalized page URL
+     */
     url: string;
+    /**
+     * - HTTP status code
+     */
     status: number;
+    /**
+     * - Array of anchor targets (e.g., '#intro')
+     */
     targets: string[];
+    /**
+     * - Content-type of the page
+     */
     contentType: string;
 };
 export type CrawlWorkerOutput = {
+    /**
+     * - Serialized page data
+     */
     pageData: CrawlWorkerPageData;
+    /**
+     * - Links discovered on the page
+     */
     links: Link[];
+    /**
+     * - HTML validation results, or null if validation was skipped/passed
+     */
     htmlValidateResults: {
         pageUrl: string;
         results: import('html-validate').Result[];
     } | null;
 };
 export type PageData = {
+    /**
+     * - The normalized page URL (without trailing slash unless root)
+     */
     url: string;
+    /**
+     * - HTTP status code from the response (e.g., 200, 404, 500)
+     */
     status: number;
+    /**
+     * - Set of available anchor targets on the page, keyed by hash (e.g., '#intro')
+     */
     targets: Set<string>;
+    /**
+     * - Content-type of the page (e.g., 'text/html', 'text/markdown')
+     */
     contentType: string;
 };
 export type Link = {
+    /**
+     * - URL of the page where this link was found, or null for seed URLs
+     */
     src: string | null;
+    /**
+     * - Accessible name/text content of the link element, or null for seed URLs
+     */
     text: string | null;
+    /**
+     * - The href attribute value (may be relative or absolute, with or without hash)
+     */
     href: string;
+    /**
+     * - Content-type of the source page (e.g., 'text/html', 'text/markdown')
+     */
     contentType?: string | null;
 };
 export type IgnoreRule = {
+    /**
+     * - Pattern(s) to match source page path
+     */
     path?: (string | RegExp) | (string | RegExp)[];
+    /**
+     * - Pattern(s) to match broken link href
+     */
     href?: (string | RegExp) | (string | RegExp)[];
+    /**
+     * - Pattern(s) to match source page content-type
+     */
     contentType?: (string | RegExp) | (string | RegExp)[];
 };
 export type NormalizedIgnoreRule = {
@@ -43,22 +106,67 @@ export type NormalizedIgnoreRule = {
     contentType: (string | RegExp)[] | undefined;
 };
 export type CrawlOptions = {
+    /**
+     * - Shell command to start the dev server (e.g., 'npm run dev'). If null, assumes server is already running
+     */
     startCommand?: string | null;
+    /**
+     * - Base URL of the site to crawl (e.g., 'http://localhost:3000')
+     */
     host: string;
+    /**
+     * - File path to write discovered link targets to. If null, targets are not persisted
+     */
     outPath?: string | null;
+    /**
+     * - Array of regex patterns to exclude from crawling (e.g., [/^\/api\//] to skip /api/* routes)
+     */
     ignoredPaths?: RegExp[];
+    /**
+     * - CSS selectors for elements whose nested links should be ignored (e.g., ['.sidebar', 'footer'])
+     */
     ignoredContent?: string[];
+    /**
+     * - Set of element IDs to ignore as link targets (defaults to '__next', '__NEXT_DATA__')
+     */
     ignoredTargets?: Set<string>;
+    /**
+     * - Pre-populated map of known valid targets to skip crawling (useful for external pages)
+     */
     knownTargets?: Map<string, Set<string>>;
+    /**
+     * - URLs to fetch known targets from (fetched JSON will be merged with knownTargets)
+     */
     knownTargetsDownloadUrl?: string[];
+    /**
+     * - Number of concurrent page fetches (defaults to 4)
+     */
     concurrency?: number;
+    /**
+     * - Starting URLs for the crawl (defaults to ['/'])
+     */
     seedUrls?: string[];
+    /**
+     * - Rules to ignore broken links. Each rule can have path, href, contentType, and/or has properties. All specified properties must match (AND logic). Within a property, multiple values use OR logic.
+     */
     ignores?: IgnoreRule[];
+    /**
+     * - Enable HTML validation on crawled pages. `false` (default): disabled. `true`: validate with recommended rules. Object: use as html-validate config — `mui:recommended` is always applied as the baseline, so most callers only need to set `rules`. Array: per-path config overrides — `mui:recommended` is applied once as the baseline and every entry whose `path` matches the page URL is layered on top; later matching entries win on conflicting rule keys. If an entry omits `extends`, it behaves like a rule patch and typically only changes the rules it names. If an entry includes `extends` (for example, re-extending `mui:recommended`), it can re-introduce or reset baseline presets rather than acting as a pure patch. An entry without `path` matches every page. If no entry matches, the page is not validated.
+     */
     htmlValidate?: HtmlValidateOption;
+    /**
+     * - Log extra diagnostics during crawling (e.g. resolved html-validate config per page). Defaults to `false`.
+     */
     verbose?: boolean;
 };
 export type HtmlValidateOverride = {
+    /**
+     * - Pattern(s) to match the page URL. Strings use exact match. Omit to match every page.
+     */
     path?: (string | RegExp) | (string | RegExp)[];
+    /**
+     * - html-validate config (or `true` for `mui:recommended`).
+     */
     config: true | import('html-validate').ConfigData;
 };
 export type HtmlValidateOption = boolean | import('html-validate').ConfigData | HtmlValidateOverride[];
@@ -71,26 +179,65 @@ export type ResolvedCrawlOptions = Omit<Required<CrawlOptions>, 'ignores' | 'htm
     htmlValidate: ResolvedHtmlValidateEntry[];
 };
 export type BrokenLinkIssue = {
+    /**
+     * - Type of issue: 'broken-link' for 404 pages, 'broken-target' for missing anchors
+     */
     type: 'broken-link' | 'broken-target';
+    /**
+     * - Human-readable description of the issue (e.g., 'Target not found', 'Page returned error 404')
+     */
     message: string;
+    /**
+     * - The link object that has the issue
+     */
     link: Link;
 };
 export type HtmlValidateIssue = {
+    /**
+     * - Issue type discriminator
+     */
     type: 'html-validate';
+    /**
+     * - Human-readable description of the issue
+     */
     message: string;
+    /**
+     * - The page URL where the issue was found
+     */
     pageUrl: string;
+    /**
+     * - The html-validate rule that triggered this issue (e.g., 'no-dup-id')
+     */
     ruleId: string;
+    /**
+     * - Severity level (1 = warning, 2 = error)
+     */
     severity: number;
+    /**
+     * - Source location of the issue
+     */
     location: {
         line: number;
         column: number;
     };
+    /**
+     * - DOM selector for the element, or null
+     */
     selector: string | null;
 };
 export type Issue = BrokenLinkIssue | HtmlValidateIssue;
 export type CrawlResult = {
+    /**
+     * - All links discovered during the crawl
+     */
     links: Set<Link>;
+    /**
+     * - All pages crawled, keyed by normalized URL
+     */
     pages: Map<string, PageData>;
+    /**
+     * - All issues found (broken links, broken targets, and HTML validation issues)
+     */
     issues: Issue[];
 };
 /**

package/build/changelog/fetchChangelogs.d.mts

@@ -4,6 +4,9 @@ export type FetchCommitsOptions = {
     repo: string;
     lastRelease: string;
     release: string;
+    /**
+     * - GitHub organization name, defaults to 'mui'
+     */
     org?: string;
 };
 /**

package/build/cli/cmdArgosPush.d.mts

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
 export type Args = {
+    /**
+     * - Run with verbose logging
+     */
     verbose?: boolean;
+    /**
+     * - Screenshots folder path
+     */
     folder: string;
 };
 /**

package/build/cli/cmdBuild.d.mts

@@ -1,18 +1,63 @@
 export type Args = {
+    /**
+     * - The bundles to build.
+     */
     bundle: import('../utils/build.mjs').BundleType[];
+    /**
+     * - The large files to build.
+     */
     hasLargeFiles: boolean;
+    /**
+     * - Whether to skip generating a package.json file in the /esm folder.
+     */
     skipBundlePackageJson: boolean;
+    /**
+     * - Whether to enable verbose logging.
+     */
     verbose: boolean;
+    /**
+     * - Whether to build types for the package.
+     */
     buildTypes: boolean;
+    /**
+     * - Whether to build types for the package.
+     */
     skipTsc: boolean;
+    /**
+     * - Whether to skip checking for Babel runtime dependencies in the package.
+     */
     skipBabelRuntimeCheck: boolean;
+    /**
+     * - Whether to skip generating the package.json file in the bundle output.
+     */
     skipPackageJson: boolean;
+    /**
+     * - Whether to skip checking for main field in package.json.
+     */
     skipMainCheck: boolean;
+    /**
+     * - Globs to be ignored by Babel.
+     */
     ignore: string[];
+    /**
+     * - Files/Directories to be copied. Can be a glob pattern.
+     */
     copy?: string[];
+    /**
+     * - Whether to use the React compiler.
+     */
     enableReactCompiler?: boolean;
+    /**
+     * - Whether to build types using typescript native (tsgo).
+     */
     tsgo?: boolean;
+    /**
+     * - Deprecated no-op; flat builds are always used.
+     */
     flat?: boolean;
+    /**
+     * - Whether to enumerate glob patterns in exports/imports into concrete entries.
+     */
     expand: boolean;
 };
 declare const _default: import('yargs').CommandModule<{}, Args>;

package/build/cli/cmdCopyFiles.d.mts

@@ -1,7 +1,19 @@
 export type Args = {
+    /**
+     * Run in silent mode without logging
+     */
     silent?: boolean;
+    /**
+     * Exclude default files from the copy operation
+     */
     excludeDefaults?: boolean;
+    /**
+     * Glob patterns to copy
+     */
     glob?: string[];
+    /**
+     * Extra files to copy
+     */
     files?: string[];
 };
 declare const _default: import('yargs').CommandModule<{}, Args>;

package/build/cli/cmdGenerateChangelog.d.mts

@@ -1,8 +1,23 @@
 export type Args = {
+    /**
+     * Path to the changelog configuration file
+     */
     config: string;
+    /**
+     * The git reference (tag/commit) of the last release
+     */
     lastRelease: string;
+    /**
+     * The git reference (tag/commit) of the new release
+     */
     release: string;
+    /**
+     * The version number for the new release
+     */
     releaseVersion: string;
+    /**
+     * The current working directory to run the command in
+     */
     cwd: string;
 };
 /**

package/build/cli/cmdListWorkspaces.d.mts

@@ -1,9 +1,21 @@
 #!/usr/bin/env node
 export type PublicPackage = import('../utils/pnpm.mjs').PublicPackage;
 export type Args = {
+    /**
+     * - Whether to filter to only public packages
+     */
     publicOnly?: boolean;
+    /**
+     * - Output format (name, path, or json)
+     */
     output?: 'json' | 'path' | 'name' | 'publish-dir';
+    /**
+     * - Git reference to filter changes since
+     */
     sinceRef?: string;
+    /**
+     * - Same as filtering packages with --filter in pnpm. Only include packages matching the filter. See https://pnpm.io/filtering.
+     */
     filter?: string[];
 };
 /**

package/build/cli/cmdNetlifyIgnore.d.mts

@@ -1,7 +1,16 @@
 #!/usr/bin/env node
 export type Args = {
+    /**
+     * - List of workspace names to process
+     */
     workspaces: string[];
+    /**
+     * - Check mode - error if the generated content differs from current
+     */
     check?: boolean;
+    /**
+     * - Branch to compare PRs against (default: master)
+     */
     baseBranch?: string;
 };
 declare const _default: import('yargs').CommandModule<{}, Args>;

package/build/cli/cmdPublish.d.mts

@@ -3,11 +3,29 @@ export type PublicPackage = import('../utils/pnpm.mjs').PublicPackage;
 export type PublishOptions = import('../utils/pnpm.mjs').PublishOptions;
 export type PublishSummaryEntry = import('../utils/pnpm.mjs').PublishSummaryEntry;
 export type Args = {
-    dry-run: boolean;
-    github-release: boolean;
+    /**
+     * Run in dry-run mode without publishing
+     */
+    "dry-run": boolean;
+    /**
+     * Create a GitHub draft release after publishing
+     */
+    "github-release": boolean;
+    /**
+     * NPM dist tag to publish to
+     */
     tag: string;
+    /**
+     * Runs in CI environment
+     */
     ci: boolean;
+    /**
+     * Git SHA to use for the GitHub release workflow (local only)
+     */
     sha?: string;
+    /**
+     * Same as filtering packages with --filter in pnpm. Only publish packages matching the filter. See https://pnpm.io/filtering.
+     */
     filter?: string[];
 };
 declare const _default: import('yargs').CommandModule<{}, Args>;

package/build/cli/cmdPublishCanary.d.mts

@@ -3,13 +3,31 @@ export type PublicPackage = import('../utils/pnpm.mjs').PublicPackage;
 export type VersionInfo = import('../utils/pnpm.mjs').VersionInfo;
 export type PublishOptions = import('../utils/pnpm.mjs').PublishOptions;
 export type Args = {
+    /**
+     * - Whether to run in dry-run mode
+     */
     dryRun?: boolean;
+    /**
+     * - Whether to create GitHub releases for canary packages
+     */
     githubRelease?: boolean;
+    /**
+     * - Same as filtering packages with --filter in pnpm. Only publish packages matching the filter. See https://pnpm.io/filtering.
+     */
     filter?: string[];
 };
 export type Commit = {
+    /**
+     * - Commit SHA
+     */
     sha: string;
+    /**
+     * - Commit message
+     */
     message: string;
+    /**
+     * - Commit author
+     */
     author: string;
 };
 declare const _default: import('yargs').CommandModule<{}, Args>;

package/build/cli/cmdPublishNewPackage.d.mts

@@ -1,5 +1,11 @@
 export type Args = {
+    /**
+     * If true, will only log the commands without executing them
+     */
     dryRun?: boolean;
+    /**
+     * 6 digit auth code to forward to npm for two-factor authentication
+     */
     otp?: string;
 };
 /**

package/build/cli/cmdRenameScope.d.mts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+export type Args = {
+    /**
+     * Source and target scope
+     */
+    alias: [string, string];
+};
+/**
+ * @typedef {Object} Args
+ * @property {[string, string]} alias Source and target scope
+ */
+/**
+ * @param {string} alias
+ * @returns {[string, string]}
+ */
+export declare function parseAlias(alias: string): [string, string];
+declare const _default: import('yargs').CommandModule<{}, Args>;
+export default _default;

package/build/cli/cmdSetVersionOverrides.d.mts

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 export type Args = {
+    /**
+     * - Package version specifiers in format 'package@version'
+     */
     pkg?: string[];
 };
 declare const _default: import('yargs').CommandModule<{}, Args>;

package/build/eslint/mui/rules/no-restricted-resolved-imports.d.mts

@@ -1,5 +1,11 @@
 export type PatternConfig = {
+    /**
+     * - The pattern to match against resolved imports
+     */
     pattern: string;
+    /**
+     * - Custom message to show when the pattern matches
+     */
     message?: string;
 };
 /**

package/build/utils/babel.d.mts

@@ -15,7 +15,13 @@ export declare function cjsCopy({ from, to }: {
     to: string;
 }): Promise<void>;
 export type ErrorCodeMetadata = {
+    /**
+     * - The path where the error code file should be written.
+     */
     outputPath: string;
+    /**
+     * - The runtime module to replace the errors with.
+     */
     runtimeModule?: string;
 };
 /**

package/build/utils/build.d.mts

@@ -2,6 +2,9 @@ export type BundleType = 'esm' | 'cjs';
 export type BundleMeta = {
     type: BundleType;
     dir: string;
+    /**
+     * - The package.json condition this bundle maps to.
+     */
     condition: 'import' | 'require';
     outExtension: string;
     typeOutExtension: string;

package/build/utils/extractErrorCodes.d.mts

@@ -1,6 +1,15 @@
 export type Args = {
+    /**
+     * - The output path to write the extracted error codes.
+     */
     errorCodesPath: string;
+    /**
+     * - List of package names to skip. By default, all workspace packages are considered.
+     */
     skip?: string[];
+    /**
+     * - The detection strategy to use when extracting error codes.
+     */
     detection?: import('@mui/internal-babel-plugin-minify-errors').Options['detection'];
 };
 /**

package/build/utils/git.d.mts

@@ -1,6 +1,15 @@
 export type RepoInfo = {
+    /**
+     * - Repository owner
+     */
     owner: string;
+    /**
+     * - Repository name
+     */
     repo: string;
+    /**
+     * - Remote name
+     */
     remoteName: string;
 };
 /**

package/build/utils/github.d.mts

@@ -7,9 +7,21 @@
  *
  */
 export type GitHubAppAuthenticationWithRefreshToken = {
+    /**
+     * - The access token
+     */
     token: string;
+    /**
+     * - ISO string when the access token expires
+     */
     expiresAt?: string;
+    /**
+     * - The refresh token
+     */
     refreshToken?: string;
+    /**
+     * - ISO string when the refresh token expires
+     */
     refreshTokenExpiresAt?: string;
 };
 /**

package/build/utils/pnpm.d.mts

@@ -1,35 +1,98 @@
 #!/usr/bin/env node
 export type PrivatePackage = {
+    /**
+     * - Package name
+     */
     name?: string;
+    /**
+     * - Package version
+     */
     version?: string;
+    /**
+     * - Package directory path
+     */
     path: string;
+    /**
+     * - Whether the package is private
+     */
     isPrivate: true;
 };
 export type PublicPackage = {
+    /**
+     * - Package name
+     */
     name: string;
+    /**
+     * - Package version
+     */
     version: string;
+    /**
+     * - Package directory path
+     */
     path: string;
+    /**
+     * - Whether the package is private
+     */
     isPrivate: false;
 };
 export type VersionInfo = {
+    /**
+     * - Whether current version exists on npm
+     */
     currentVersionExists: boolean;
+    /**
+     * - Latest canary version if available
+     */
     latestCanaryVersion: string | null;
 };
 export type PublishOptions = {
+    /**
+     * - Whether to run in dry-run mode
+     */
     dryRun?: boolean;
+    /**
+     * - Whether to skip git checks
+     */
     noGitChecks?: boolean;
+    /**
+     * - NPM dist tag to publish to
+     */
     tag?: string;
 };
 export type PnpmListResultItem = {
+    /**
+     * - Package name
+     */
     name?: string;
+    /**
+     * - Package version
+     */
     version?: string;
+    /**
+     * - Package directory path
+     */
     path: string;
+    /**
+     * - Whether the package is private
+     */
     private: boolean;
 };
 export type GetWorkspacePackagesOptions = {
+    /**
+     * - Git reference to filter changes since
+     */
     sinceRef?: string | null;
+    /**
+     * - Whether to filter to only public packages
+     */
     publicOnly?: boolean;
+    /**
+     * - Current working directory to run pnpm command in
+     */
     cwd?: string;
+    /**
+     * - Same as filtering packages with --filter in pnpm. Only include packages matching the filter. See https://pnpm.io/filtering.
+     */
     filter?: string[];
 };
 export declare function getWorkspacePackages(options?: {
@@ -90,19 +153,22 @@ export type PublishSummaryEntry = {
  */
 export declare function publishPackages(packages: PublicPackage[], options?: PublishOptions): Promise<PublishSummaryEntry[]>;
 export type GetTransitiveDependenciesOptions = {
+    /**
+     * - Map of workspace package name to directory path
+     */
     workspacePathByName?: Map<string, string>;
+    /**
+     * - Whether to include devDependencies in the traversal
+     */
     includeDev?: boolean;
 };
-/**
- * @typedef {Object} GetTransitiveDependenciesOptions
- * @property {Map<string, string>} [workspacePathByName] - Map of workspace package name to directory path
- * @property {boolean} [includeDev=true] - Whether to include devDependencies in the traversal
- */
 /**
  * Get all transitive workspace dependencies for a set of packages.
  *
  * Only follows deps whose version spec starts with `workspace:` (e.g. `workspace:*`
- * or `workspace:^`), meaning they are sourced directly from the monorepo. Pinned
+ * or `workspace:^`), meaning they are sourced directly from the monorepo. An
+ * alias spec (`workspace:@scope/name@range`) is followed to the package it
+ * targets, which need not match the dependency key. Pinned
  * external versions (e.g. `^1.0.0`) are ignored even when the package name exists
  * in the workspace. Traverses `dependencies` and optionally `devDependencies`.
  * Results are cached per package so each package is read from disk at most once
@@ -171,6 +237,21 @@ export declare function writePackageJson(packagePath: string, packageJson: Objec
  * @returns {Promise<void>}
  */
 export declare function writeOverridesToWorkspace(workspaceDir: string, overrides: Record<string, string>): Promise<void>;
+/**
+ * Move the publishable workspace packages in one scope to another.
+ *
+ * Only packages that are part of the workspace are touched, so dependencies
+ * that merely share the scope but come from the registry (say `@base-ui/react`
+ * alongside a workspace `@base-ui/mosaic`) are left alone. Dependents keep the
+ * original dependency name and gain a `workspace:` alias, so imports in the
+ * repo resolve exactly as before.
+ *
+ * @param {(PublicPackage | PrivatePackage)[]} packages - All workspace packages
+ * @param {string} fromScope - Scope to move away from
+ * @param {string} toScope - Scope to move to
+ * @returns {Promise<Map<string, string>>} Old package name to new package name
+ */
+export declare function renameWorkspaceScope(packages: (PublicPackage | PrivatePackage)[], fromScope: string, toScope: string): Promise<Map<string, string>>;
 /**
  * Resolve a package@version specifier to an exact version
  * @param {string} packageSpec - Package specifier in format "package@version"

package/build/utils/testUtils.d.mts

@@ -5,3 +5,24 @@
  * @returns {Promise<string>} The path of the created temporary directory.
  */
 export declare function makeTempDir(): Promise<string>;
+/**
+ * Write a package.json into a subdirectory of a temp workspace.
+ *
+ * @param {string} root - Workspace root
+ * @param {string} dir - Subdirectory to create
+ * @param {object} pkgJson - Manifest contents
+ * @returns {Promise<string>} The package directory
+ */
+export declare function writePackage(root: string, dir: string, pkgJson: object): Promise<string>;
+/**
+ * @param {string} name
+ * @param {string} pkgPath
+ * @returns {import('./pnpm.mjs').PublicPackage}
+ */
+export declare function publicPkg(name: string, pkgPath: string): import('./pnpm.mjs').PublicPackage;
+/**
+ * @param {string} name
+ * @param {string} pkgPath
+ * @returns {import('./pnpm.mjs').PrivatePackage}
+ */
+export declare function privatePkg(name: string, pkgPath: string): import('./pnpm.mjs').PrivatePackage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-code-infra",
-  "version": "0.0.4-canary.97",
+  "version": "0.0.4-canary.99",
   "author": "MUI Team",
   "description": "Infra scripts and configs to be used across MUI repos.",
   "license": "MIT",
@@ -82,12 +82,12 @@
     "babel-plugin-transform-react-remove-prop-types": "^0.4.24",
     "babel-plugin-transform-remove-imports": "^1.8.1",
     "chalk": "^5.6.2",
-    "clipboardy": "^5.3.1",
+    "clipboardy": "^5.3.2",
     "content-type": "^2.0.0",
     "env-ci": "^11.2.0",
     "es-toolkit": "^1.49.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-module-utils": "^2.14.0",
     "eslint-plugin-compat": "^7.0.2",
     "eslint-plugin-import": "^2.32.0",
@@ -101,12 +101,12 @@
     "execa": "^9.6.1",
     "git-url-parse": "^16.1.0",
     "globals": "^17.7.0",
-    "globby": "^16.2.0",
-    "html-validate": "^11.5.5",
+    "globby": "^16.2.2",
+    "html-validate": "^11.5.6",
     "minimatch": "^10.2.5",
     "node-html-parser": "^9.0.0",
     "open": "^11.0.0",
-    "postcss-styled-syntax": "^0.7.1",
+    "postcss-styled-syntax": "^0.7.2",
     "regexp.escape": "^2.0.1",
     "rehype-slug": "^6.0.0",
     "rehype-stringify": "^10.0.1",
@@ -127,7 +127,7 @@
     "remark-parse": "^11.0.0",
     "remark-rehype": "^11.1.2",
     "resolve-pkg-maps": "^1.0.0",
-    "semver": "^7.8.0",
+    "semver": "^7.8.5",
     "stylelint-config-standard": "^40.0.0",
     "typescript-eslint": "^8.64.0",
     "unified": "^11.0.5",
@@ -136,8 +136,8 @@
     "yaml": "^2.9.0",
     "yargs": "^18.0.0",
     "@mui/internal-babel-plugin-display-name": "1.0.4-canary.23",
-    "@mui/internal-babel-plugin-minify-errors": "2.0.8-canary.30",
-    "@mui/internal-babel-plugin-resolve-imports": "2.0.7-canary.40"
+    "@mui/internal-babel-plugin-resolve-imports": "2.0.7-canary.41",
+    "@mui/internal-babel-plugin-minify-errors": "2.0.8-canary.30"
   },
   "peerDependencies": {
     "@next/eslint-plugin-next": "*",
@@ -188,7 +188,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "f5098e75e68dc8dcfc3c4535b1a0a3fb97c6c68d",
+  "gitSha": "327b1eabb817e566026fbeb46767736701766d0d",
   "scripts": {
     "build": "tsgo -p tsconfig.build.json",
     "typescript": "tsgo -noEmit",

package/src/cli/cmdRenameScope.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+/* eslint-disable no-console */
+
+import chalk from 'chalk';
+
+import { getWorkspacePackages, renameWorkspaceScope } from '../utils/pnpm.mjs';
+
+/**
+ * A scope is a single `@`-prefixed segment. Letting a `/` through would build
+ * names like `@acme/private/pkg`, which only npm rejects, long after every
+ * matching manifest has been rewritten.
+ */
+const SCOPE_PATTERN = /^@[a-z0-9-~][a-z0-9-._~]*$/;
+
+/**
+ * @typedef {Object} Args
+ * @property {[string, string]} alias Source and target scope
+ */
+
+/**
+ * @param {string} alias
+ * @returns {[string, string]}
+ */
+export function parseAlias(alias) {
+  const parts = alias.split(':');
+  const [from, to] = parts;
+  if (parts.length !== 2 || !SCOPE_PATTERN.test(from) || !SCOPE_PATTERN.test(to)) {
+    throw new Error(
+      `Invalid scope mapping "${alias}". Expected exactly two npm scopes separated by a colon, e.g. "@acme:@acme-private".`,
+    );
+  }
+  if (from === to) {
+    throw new Error(`Invalid scope mapping "${alias}". The source and target scope are the same.`);
+  }
+  return [from, to];
+}
+
+export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
+  command: 'rename-scope <alias>',
+  describe: 'Move publishable workspace packages to a different npm scope',
+  builder: (yargs) =>
+    yargs
+      .positional('alias', {
+        type: 'string',
+        describe: 'Scope mapping written as "@from:@to"',
+        coerce: parseAlias,
+      })
+      .example(
+        '$0 rename-scope @acme:@acme-private',
+        'Publish the workspace @acme packages under @acme-private',
+      ),
+  handler: async (argv) => {
+    const [from, to] = argv.alias;
+    const packages = await getWorkspacePackages();
+    const renamed = await renameWorkspaceScope(packages, from, to);
+
+    // Matching nothing means the mapping is wrong or stale. Carrying on would
+    // publish under the original scope, so fail instead of reporting success.
+    if (renamed.size === 0) {
+      throw new Error(
+        `No publishable workspace packages found in ${from}. Check the scope mapping "${from}:${to}", or the workspace may already have been renamed.`,
+      );
+    }
+
+    for (const [oldName, newName] of renamed) {
+      console.log(`📦 ${oldName} → ${chalk.bold(newName)}`);
+    }
+
+    console.log(
+      chalk.yellow(
+        '\n⚠️  Workspace manifests were rewritten in place and are not restored. Discard them before committing.',
+      ),
+    );
+  },
+});

package/src/cli/index.mjs

@@ -14,6 +14,7 @@ import cmdNetlifyIgnore from './cmdNetlifyIgnore.mjs';
 import cmdPublish from './cmdPublish.mjs';
 import cmdPublishCanary from './cmdPublishCanary.mjs';
 import cmdPublishNewPackage from './cmdPublishNewPackage.mjs';
+import cmdRenameScope from './cmdRenameScope.mjs';
 import cmdSetVersionOverrides from './cmdSetVersionOverrides.mjs';
 import cmdVale from './cmdVale.mjs';
 import cmdValidateBuiltTypes from './cmdValidateBuiltTypes.mjs';
@@ -47,6 +48,7 @@ await yargs(hideBin(process.argv))
   .command(cmdPublish)
   .command(cmdPublishCanary)
   .command(cmdPublishNewPackage)
+  .command(cmdRenameScope)
   .command(cmdSetVersionOverrides)
   .command(cmdVale)
   .command(cmdValidateBuiltTypes)

package/src/stylelint/index.mjs

@@ -1,4 +1,4 @@
-import postcssStylesSyntax from 'postcss-styled-syntax';
+import * as postcssStyledSyntax from 'postcss-styled-syntax';
 
 /** @type {import('stylelint').Config} */
 export default {
@@ -39,7 +39,7 @@ export default {
   overrides: [
     {
       files: ['**/*.?(c|m)[jt]s?(x)'],
-      customSyntax: /** @type {any} */ (postcssStylesSyntax),
+      customSyntax: postcssStyledSyntax,
     },
   ],
 };

package/src/untyped-plugins.d.ts

@@ -169,8 +169,8 @@ declare module 'stylelint-config-standard' {
   export default configExtends;
 }
 declare module 'postcss-styled-syntax' {
-  import type { Syntax } from 'postcss';
+  import type { Parser, Stringifier } from 'postcss';
 
-  declare const syntax: Syntax;
-  export default syntax;
+  export const parse: Parser;
+  export const stringify: Stringifier;
 }

package/src/utils/pnpm.mjs

@@ -303,11 +303,29 @@ export async function publishPackages(packages, options = {}) {
  * @property {boolean} [includeDev=true] - Whether to include devDependencies in the traversal
  */
 
+/**
+ * The package a `workspace:` alias spec resolves to, if it is one.
+ *
+ * @param {string} spec - Dependency spec
+ * @returns {string | null} The aliased package name, or null for a plain spec
+ */
+function aliasTarget(spec) {
+  if (!spec.startsWith('workspace:')) {
+    return null;
+  }
+  const range = spec.slice('workspace:'.length);
+  // Search from 1 so a scoped name's own leading `@` isn't read as the separator.
+  const separator = range.indexOf('@', 1);
+  return separator === -1 ? null : range.slice(0, separator);
+}
+
 /**
  * Get all transitive workspace dependencies for a set of packages.
  *
  * Only follows deps whose version spec starts with `workspace:` (e.g. `workspace:*`
- * or `workspace:^`), meaning they are sourced directly from the monorepo. Pinned
+ * or `workspace:^`), meaning they are sourced directly from the monorepo. An
+ * alias spec (`workspace:@scope/name@range`) is followed to the package it
+ * targets, which need not match the dependency key. Pinned
  * external versions (e.g. `^1.0.0`) are ignored even when the package name exists
  * in the workspace. Traverses `dependencies` and optionally `devDependencies`.
  * Results are cached per package so each package is read from disk at most once
@@ -344,14 +362,15 @@ export async function getTransitiveDependencies(packageNames, options = {}) {
         ...Object.entries(pkgJson.dependencies ?? {}),
         ...(includeDev ? Object.entries(pkgJson.devDependencies ?? {}) : []),
       ];
-      const workspaceDeps = allDepEntries
-        .filter(
-          ([dep, spec]) =>
-            workspacePathByName.has(dep) &&
-            typeof spec === 'string' &&
-            spec.startsWith('workspace:'),
-        )
-        .map(([dep]) => dep);
+      const workspaceDeps = allDepEntries.flatMap(([dep, spec]) => {
+        if (typeof spec !== 'string' || !spec.startsWith('workspace:')) {
+          return [];
+        }
+        // An aliased spec (`workspace:@scope/name@range`) names the workspace
+        // package it resolves to, which need not match the dependency key.
+        const name = aliasTarget(spec) ?? dep;
+        return workspacePathByName.has(name) ? [name] : [];
+      });
 
       const recursiveResults = await Promise.all(workspaceDeps.map(collectDeps));
       return new Set([...workspaceDeps, ...recursiveResults.flatMap((s) => [...s])]);
@@ -540,6 +559,151 @@ export async function writeOverridesToWorkspace(workspaceDir, overrides) {
   await fs.writeFile(workspaceYamlPath, doc.toString());
 }
 
+/**
+ * Map a package name onto a different npm scope.
+ * @param {string} name - Package name, e.g. `@base-ui/mosaic`
+ * @param {string} fromScope - Scope to replace, e.g. `@base-ui`
+ * @param {string} toScope - Replacement scope, e.g. `@base-ui-private`
+ * @returns {string | null} The renamed package, or null when the scope doesn't match
+ */
+function renameScope(name, fromScope, toScope) {
+  const prefix = `${fromScope}/`;
+  return name.startsWith(prefix) ? `${toScope}/${name.slice(prefix.length)}` : null;
+}
+
+/**
+ * Move the publishable workspace packages in one scope to another.
+ *
+ * Only packages that are part of the workspace are touched, so dependencies
+ * that merely share the scope but come from the registry (say `@base-ui/react`
+ * alongside a workspace `@base-ui/mosaic`) are left alone. Dependents keep the
+ * original dependency name and gain a `workspace:` alias, so imports in the
+ * repo resolve exactly as before.
+ *
+ * @param {(PublicPackage | PrivatePackage)[]} packages - All workspace packages
+ * @param {string} fromScope - Scope to move away from
+ * @param {string} toScope - Scope to move to
+ * @returns {Promise<Map<string, string>>} Old package name to new package name
+ */
+export async function renameWorkspaceScope(packages, fromScope, toScope) {
+  // Renaming a scope onto itself only rewrites every manifest to itself. The
+  // CLI rejects this earlier, but the guard belongs with the operation so a
+  // direct caller cannot trip the silent churn either.
+  if (fromScope === toScope) {
+    throw new Error(`Cannot rename ${fromScope} to itself.`);
+  }
+
+  /** @type {Map<string, string>} */
+  const renamed = new Map();
+
+  for (const pkg of packages) {
+    if (pkg.isPrivate) {
+      continue;
+    }
+    const newName = renameScope(pkg.name, fromScope, toScope);
+    if (newName) {
+      renamed.set(pkg.name, newName);
+    }
+  }
+
+  // A rename that lands on a name another package keeps would leave the
+  // workspace with two packages sharing a name. Catch it up front, before any
+  // manifest is written.
+  /** @type {Map<string, string>} */
+  const finalNames = new Map();
+  for (const pkg of packages) {
+    if (!pkg.name) {
+      continue;
+    }
+    const finalName = renamed.get(pkg.name) ?? pkg.name;
+    const owner = finalNames.get(finalName);
+    if (owner) {
+      throw new Error(
+        `Cannot rename ${fromScope} to ${toScope}: ${pkg.name} and ${owner} would both be named ${finalName}.`,
+      );
+    }
+    finalNames.set(finalName, pkg.name);
+  }
+
+  // Rewrite in memory first. A dependency that cannot be pointed at its renamed
+  // package has to fail before anything is written, or the workspace is left
+  // half renamed with nothing to restore it.
+  const rewritten = await Promise.all(
+    packages.map(async (pkg) => {
+      const packageJson = await readPackageJson(pkg.path);
+      const label = pkg.name ?? pkg.path;
+      /** @type {string[]} */
+      const problems = [];
+      let changed = false;
+
+      const newName = pkg.name ? renamed.get(pkg.name) : undefined;
+      if (newName) {
+        packageJson.name = newName;
+        changed = true;
+      }
+
+      // peerDependencies are deliberately absent: a peer is supplied by the
+      // consumer, who installs the package under its original name. An alias
+      // range would be unsatisfiable for them.
+      for (const deps of [
+        packageJson.dependencies,
+        packageJson.devDependencies,
+        packageJson.optionalDependencies,
+      ]) {
+        if (!deps) {
+          continue;
+        }
+        for (const [depName, spec] of Object.entries(deps)) {
+          if (!spec) {
+            continue;
+          }
+
+          const existingTarget = aliasTarget(spec);
+          if (existingTarget) {
+            if (renamed.has(existingTarget)) {
+              problems.push(
+                `"${depName}" in ${label} already aliases ${existingTarget}, which is being renamed. Point it at the package directly so it can be rewritten.`,
+              );
+            }
+            // Otherwise it already aliases what it should, as a re-run does.
+            continue;
+          }
+
+          const target = renamed.get(depName);
+          if (!target) {
+            continue;
+          }
+          if (!spec.startsWith('workspace:')) {
+            // Only `workspace:` specs can be aliased. Anything else would keep
+            // resolving the original name from the registry after the rename.
+            problems.push(
+              `"${depName}" in ${label} is required as "${spec}" rather than a workspace: dependency, so it cannot be pointed at ${target}.`,
+            );
+            continue;
+          }
+          deps[depName] = `workspace:${target}@${spec.slice('workspace:'.length)}`;
+          changed = true;
+        }
+      }
+
+      return { path: pkg.path, packageJson, changed, problems };
+    }),
+  );
+
+  const problems = rewritten.flatMap((entry) => entry.problems);
+  if (problems.length > 0) {
+    throw new Error(`Cannot rename ${fromScope} to ${toScope}:\n  ${problems.join('\n  ')}`);
+  }
+
+  await Promise.all(
+    rewritten
+      .filter((entry) => entry.changed)
+      .map((entry) => writePackageJson(entry.path, entry.packageJson)),
+  );
+
+  return renamed;
+}
+
 /**
  * Resolve a package@version specifier to an exact version
  * @param {string} packageSpec - Package specifier in format "package@version"

package/src/utils/testUtils.mjs

@@ -3,6 +3,8 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { onTestFinished } from 'vitest';
 
+import { writePackageJson } from './pnpm.mjs';
+
 /**
  * Creates a temporary directory and registers an `onTestFinished` hook to
  * remove it automatically when the current test ends — even if the test throws.
@@ -16,3 +18,36 @@ export async function makeTempDir() {
   });
   return tmpDir;
 }
+
+/**
+ * Write a package.json into a subdirectory of a temp workspace.
+ *
+ * @param {string} root - Workspace root
+ * @param {string} dir - Subdirectory to create
+ * @param {object} pkgJson - Manifest contents
+ * @returns {Promise<string>} The package directory
+ */
+export async function writePackage(root, dir, pkgJson) {
+  const pkgDir = path.join(root, dir);
+  await fs.mkdir(pkgDir, { recursive: true });
+  await writePackageJson(pkgDir, pkgJson);
+  return pkgDir;
+}
+
+/**
+ * @param {string} name
+ * @param {string} pkgPath
+ * @returns {import('./pnpm.mjs').PublicPackage}
+ */
+export function publicPkg(name, pkgPath) {
+  return { name, version: '1.0.0', path: pkgPath, isPrivate: false };
+}
+
+/**
+ * @param {string} name
+ * @param {string} pkgPath
+ * @returns {import('./pnpm.mjs').PrivatePackage}
+ */
+export function privatePkg(name, pkgPath) {
+  return { name, version: '1.0.0', path: pkgPath, isPrivate: true };
+}