@mui/internal-code-infra 0.0.4-canary.98 → 0.1.1-canary.0

package/src/untyped-plugins.d.ts

@@ -95,73 +95,35 @@ declare module '@next/eslint-plugin-next' {
   export default config;
 }
 
-declare module '@babel/plugin-transform-runtime' {
-  import type { PluginItem } from '@babel/core';
-
-  declare const plugin: PluginItem;
-  export default plugin;
-}
-
-declare module '@babel/plugin-syntax-jsx' {
-  import type { PluginItem } from '@babel/core';
-
-  declare const plugin: PluginItem;
-  export default plugin;
-}
-
-declare module '@babel/plugin-syntax-typescript' {
-  import type { PluginItem } from '@babel/core';
-
-  declare const plugin: PluginItem;
-  export default plugin;
-}
-
 declare module 'babel-plugin-optimize-clsx' {
-  import type { PluginItem } from '@babel/core';
+  import type { PluginTarget } from '@babel/core';
 
-  declare const plugin: PluginItem;
+  declare const plugin: PluginTarget;
   export default plugin;
 }
 
 declare module 'babel-plugin-transform-react-remove-prop-types' {
-  import type { PluginItem } from '@babel/core';
+  import type { PluginTarget } from '@babel/core';
 
-  declare const plugin: PluginItem;
+  declare const plugin: PluginTarget;
   export default plugin;
 }
 
-declare module 'babel-plugin-transform-import-meta' {
-  import type { PluginItem } from '@babel/core';
+declare module 'babel-plugin-transform-remove-imports' {
+  // The package's own bundled types mislabel the export's signature.
+  import type { PluginTarget } from '@babel/core';
 
-  declare const plugin: PluginItem;
+  declare const plugin: PluginTarget;
   export default plugin;
 }
 
-declare module 'babel-plugin-transform-inline-environment-variables' {
-  import type { PluginItem } from '@babel/core';
+declare module 'babel-plugin-transform-import-meta' {
+  import type { PluginTarget } from '@babel/core';
 
-  declare const plugin: PluginItem;
+  declare const plugin: PluginTarget;
   export default plugin;
 }
 
-declare module '@babel/preset-react' {
-  import type { PluginItem } from '@babel/core';
-
-  export type Options = {
-    runtime: 'string';
-  };
-
-  declare const preset: PluginItem;
-  export default preset;
-}
-
-declare module '@babel/preset-typescript' {
-  import type { PluginItem } from '@babel/core';
-
-  declare const preset: PluginItem;
-  export default preset;
-}
-
 declare module 'stylelint-config-standard' {
   import type { Config } from 'stylelint';
 

package/src/utils/build.mjs

@@ -894,42 +894,3 @@ export function measureFn(label) {
   const endMark = `${label}-end`;
   return performance.measure(label, startMark, endMark);
 }
-
-/**
- * A utility to map a function over an array of items in a worker pool.
- *
- * This function will create a pool of workers and distribute the items to be processed among them.
- * Each worker will process items sequentially, but multiple workers will run in parallel.
- *
- * @function
- * @template T
- * @template R
- * @param {T[]} items
- * @param {(item: T) => Promise<R>} mapper
- * @param {number} concurrency
- * @returns {Promise<(R|Error)[]>}
- */
-export async function mapConcurrently(items, mapper, concurrency) {
-  if (!items.length) {
-    return Promise.resolve([]); // nothing to do
-  }
-  const itemIterator = items.entries();
-  const count = Math.min(concurrency, items.length);
-  const workers = [];
-  /**
-   * @type {(R|Error)[]}
-   */
-  const results = new Array(items.length);
-  for (let i = 0; i < count; i += 1) {
-    const worker = Promise.resolve().then(async () => {
-      for (const [index, item] of itemIterator) {
-        // eslint-disable-next-line no-await-in-loop
-        const res = await mapper(item);
-        results[index] = res;
-      }
-    });
-    workers.push(worker);
-  }
-  await Promise.all(workers);
-  return results;
-}

package/src/utils/extractErrorCodes.mjs

@@ -6,9 +6,12 @@ import minifyErrorsPlugin from '@mui/internal-babel-plugin-minify-errors';
 import { globby } from 'globby';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { mapAsync } from 'es-toolkit/array';
 
 import { getWorkspacePackages } from './pnpm.mjs';
-import { BASE_IGNORES, mapConcurrently } from './build.mjs';
+import { BASE_IGNORES } from './build.mjs';
+
+const PLAIN_TS_EXTENSION = /\.[cm]?ts$/;
 
 /**
  * @typedef {Object} Args
@@ -51,18 +54,20 @@ async function getFilesForPackage(pkg) {
  * @param {Set<string | Error>} errors
  * @param {import('@mui/internal-babel-plugin-minify-errors').Options['detection']} [detection='opt-in']
  */
-async function extractErrorCodesForWorkspace(files, errors, detection = 'opt-in') {
-  await mapConcurrently(
+export async function extractErrorCodesForFiles(files, errors, detection = 'opt-in') {
+  await mapAsync(
     files,
     async (fullPath) => {
       const code = await fs.readFile(fullPath, 'utf8');
+      // Plain .ts files must not get the JSX parser: `<T = unknown>(x) => x` would be read as JSX.
+      const isPlainTs = PLAIN_TS_EXTENSION.test(fullPath);
       // Replicate how Babel is run when preparing the source to be published on npm, so we can extract the same messages.
       await transformAsync(code, {
         filename: fullPath,
         sourceType: 'module',
         plugins: [
-          [babelSyntaxTypescript, { isTSX: true }],
-          [babelSyntaxJsx],
+          [babelSyntaxTypescript, { isTSX: !isPlainTs }],
+          ...(isPlainTs ? [] : [babelSyntaxJsx]),
           [minifyErrorsPlugin, { collectErrors: errors, detection }],
         ],
         configFile: false,
@@ -71,7 +76,7 @@ async function extractErrorCodesForWorkspace(files, errors, detection = 'opt-in'
         code: false,
       });
     },
-    30,
+    { concurrency: 30 },
   );
 }
 
@@ -108,7 +113,7 @@ export default async function extractErrorCodes(args) {
   // Extract error codes from said files.
   const filesToProcess = files.flat();
   console.log(`🔍 Extracting error codes from ${filesToProcess.length} files...`);
-  await extractErrorCodesForWorkspace(filesToProcess, errors, detection);
+  await extractErrorCodesForFiles(filesToProcess, errors, detection);
 
   // Partition collected entries into valid messages and unminifyable errors.
   /** @type {string[]} */

package/src/utils/pnpm.mjs

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 
+import { getPublishedByPolicy } from '@pnpm/config.version-policy';
+import { parseWantedDependency } from '@pnpm/parse-wanted-dependency';
 import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
 import { $ } from 'execa';
 import * as fs from 'node:fs/promises';
@@ -160,6 +162,21 @@ export async function getPublishRegistry(packagePath) {
   return registryUrl.href;
 }
 
+/**
+ * Get the version to release from the workspace-root package.json.
+ *
+ * Resolves the workspace root so the version is the monorepo's regardless of
+ * which directory publish runs from.
+ *
+ * @param {string} [cwd] - Directory to resolve the workspace root from
+ * @returns {Promise<string | null>} Version string, or null when absent/invalid
+ */
+export async function getReleaseVersion(cwd = process.cwd()) {
+  const workspaceDir = (await findWorkspaceDir(cwd)) ?? cwd;
+  const { version } = await readPackageJson(workspaceDir);
+  return version ? semver.valid(version) : null;
+}
+
 /**
  * Whether a registry requires a package to exist before CI can publish to it.
  * @param {string} registry - Normalized registry URL
@@ -303,11 +320,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 { alias, bareSpecifier } = parseWantedDependency(spec.slice('workspace:'.length));
+  // A plain range parses as one half or the other (`*` as an alias, `^1.0.0` as a
+  // specifier); only an aliased spec carries both.
+  return bareSpecifier === undefined ? null : (alias ?? null);
+}
+
 /**
  * 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 +379,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])]);
@@ -541,26 +577,354 @@ export async function writeOverridesToWorkspace(workspaceDir, overrides) {
 }
 
 /**
- * Resolve a package@version specifier to an exact version
+ * 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;
+}
+
+/**
+ * The versions a `minimumReleaseAgeExclude` policy exempts from the cooldown. A
+ * policy answers `true` for a package that is exempt at any version, or the list
+ * of versions exempted individually.
+ *
+ * @param {import('@pnpm/config.version-policy').PublishedByPolicy} policy - Policy from {@link getMinimumReleaseAgePolicy}
+ * @param {string} name - Package name
+ * @returns {true | string[]} `true` when every version is exempt, otherwise the exempt versions
+ */
+function cooldownExemptions(policy, name) {
+  const exemption = policy.publishedByExclude?.(name);
+  if (exemption === true) {
+    return true;
+  }
+  return Array.isArray(exemption) ? exemption : [];
+}
+
+/**
+ * Pick the version to pin for a specifier whose newest match is too recent to
+ * satisfy a `minimumReleaseAge` cooldown.
+ *
+ * Only the three specifier shapes this tool is given are handled. An exact
+ * version is not a choice, so it stands and the install reports it. A range
+ * resolves within itself. A dist-tag repoints to the highest aged-in version
+ * sharing the major and prerelease-ness — except `latest`, which pnpm allows to
+ * cross majors. Unlike pnpm, a deprecated version is not passed over: `pnpm info`
+ * lists bare version strings, so that flag would cost a request per candidate.
+ *
+ * @param {string} requested - The specifier as given: a dist-tag, range or exact version
+ * @param {string} resolvedVersion - Version the specifier resolves to today
+ * @param {string[]} versions - Every published version, from `pnpm info <pkg> versions`
+ * @param {Record<string, string>} publishTimes - Version to ISO publish date, from `pnpm info <pkg> time`
+ * @param {number} cutoff - Epoch ms; versions published after this are too recent
+ * @param {string[]} [exemptVersions] - Versions `minimumReleaseAgeExclude` installs regardless of age
+ * @returns {string | null} Version to pin, or null when nothing qualifies
+ * @internal exported for unit tests
+ */
+export function selectAgedVersion(
+  requested,
+  resolvedVersion,
+  versions,
+  publishTimes,
+  cutoff,
+  exemptVersions = [],
+) {
+  const exempt = new Set(exemptVersions);
+
+  /**
+   * Whether the install would accept this version: old enough, or excluded from
+   * the cooldown altogether.
+   *
+   * @param {string} version
+   * @returns {boolean}
+   */
+  const isInstallable = (version) => {
+    if (exempt.has(version)) {
+      return true;
+    }
+    const published = Date.parse(publishTimes[version]);
+    return Number.isFinite(published) && published <= cutoff;
+  };
+
+  // An unknown publish date leaves nothing to compare against, so the
+  // resolution stands rather than being swapped for another build.
+  if (!Object.hasOwn(publishTimes, resolvedVersion) || isInstallable(resolvedVersion)) {
+    return resolvedVersion;
+  }
+
+  if (semver.valid(requested)) {
+    return resolvedVersion;
+  }
+
+  // `time` keeps an entry for a version after it is unpublished, so candidates
+  // come from the version list rather than from the dates.
+  const candidates = versions.filter(isInstallable);
+
+  if (semver.validRange(requested)) {
+    return semver.maxSatisfying(candidates, requested, true);
+  }
+
+  const resolved = semver.parse(resolvedVersion, true);
+  if (!resolved) {
+    return resolvedVersion;
+  }
+  const resolvedIsPrerelease = resolved.prerelease.length > 0;
+
+  let best = null;
+  for (const version of candidates) {
+    const parsed = semver.parse(version, true);
+    if (
+      !parsed ||
+      (requested !== 'latest' && parsed.major !== resolved.major) ||
+      parsed.prerelease.length > 0 !== resolvedIsPrerelease
+    ) {
+      continue;
+    }
+    if (!best || semver.gt(version, best, true)) {
+      best = version;
+    }
+  }
+  return best;
+}
+
+/**
+ * Read the effective pnpm configuration, including everything resolved from
+ * pnpm-workspace.yaml. `config list` types the values and omits unset keys,
+ * where `config get` stringifies everything and prints `undefined`.
+ *
+ * @returns {Promise<Record<string, any>>} Parsed configuration
+ */
+export async function readPnpmConfig() {
+  const result = await $`pnpm config list --json`;
+  return JSON.parse(result.stdout);
+}
+
+/**
+ * Read the registry cooldown from pnpm config, so resolution stays in step with
+ * what the subsequent install will enforce.
+ *
+ * @returns {Promise<import('@pnpm/config.version-policy').PublishedByPolicy>} Cutoff date and exemption policy, both undefined when no cooldown is configured
+ */
+export async function getMinimumReleaseAgePolicy() {
+  const config = await readPnpmConfig();
+  // pnpm's own parser, so exclude entries keep their full grammar — wildcards,
+  // version unions (`pkg@1.0.0 || 2.0.0`) and `!` negation.
+  return getPublishedByPolicy({
+    minimumReleaseAge: config.minimumReleaseAge,
+    minimumReleaseAgeExclude: config.minimumReleaseAgeExclude,
+  });
+}
+
+/**
+ * Resolve a package@version specifier to an exact version.
+ *
+ * Given a cooldown policy, the result is the newest version the install will
+ * actually accept — a dist-tag on a daily channel always points at a build too
+ * recent to install under one. See {@link selectAgedVersion}.
+ *
  * @param {string} packageSpec - Package specifier in format "package@version"
+ * @param {import('@pnpm/config.version-policy').PublishedByPolicy} policy - Cooldown from {@link getMinimumReleaseAgePolicy}
  * @returns {Promise<string>} Exact version string
  */
-export async function resolveVersion(packageSpec) {
-  const result = await $`pnpm info ${packageSpec} version --json`;
-  const versions = JSON.parse(result.stdout);
-  return typeof versions === 'string' ? versions : versions[versions.length - 1];
+export async function resolveVersion(packageSpec, policy) {
+  // The unprojected document carries both the resolved version and every
+  // publish date, so honouring the cooldown costs no extra round-trip.
+  const info = JSON.parse((await $`pnpm info ${packageSpec} --json`).stdout);
+  const manifest = Array.isArray(info) ? info[info.length - 1] : info;
+  const { name, version: exactVersion, time: publishTimes = {}, versions = [] } = manifest;
+
+  if (!policy.publishedBy) {
+    return exactVersion;
+  }
+
+  const exemptVersions = cooldownExemptions(policy, name);
+  if (exemptVersions === true || exemptVersions.includes(exactVersion)) {
+    return exactVersion;
+  }
+
+  const cutoff = policy.publishedBy.toISOString();
+  const { bareSpecifier: requested } = parseWantedDependency(packageSpec);
+  const agedVersion = selectAgedVersion(
+    requested ?? '',
+    exactVersion,
+    versions,
+    publishTimes,
+    policy.publishedBy.getTime(),
+    exemptVersions,
+  );
+
+  if (!agedVersion) {
+    throw new Error(
+      `No version matching ${packageSpec} was published before the minimumReleaseAge cutoff ` +
+        `(${cutoff}). The newest match, ${exactVersion}, was published at ` +
+        `${publishTimes[exactVersion]}, and no earlier match qualifies. Lower ` +
+        `minimumReleaseAge, add ${name} to minimumReleaseAgeExclude, or wait for ${exactVersion} ` +
+        `to age in.`,
+    );
+  }
+
+  if (agedVersion !== exactVersion) {
+    // eslint-disable-next-line no-console
+    console.log(
+      `Resolved ${packageSpec} to ${agedVersion} rather than ${exactVersion}, which was published after the minimumReleaseAge cutoff (${cutoff}).`,
+    );
+  }
+
+  return agedVersion;
 }
 
 /**
  * Find the version of a dependency for a specific package@version
+ *
+ * The parent's spec is often a range, so the cooldown applies here too. Stepping
+ * back stays within that range and so never contradicts the parent.
+ *
  * @param {string} packageSpec - Package specifier in format "package@version"
  * @param {string} dependency - Dependency name to look up
+ * @param {import('@pnpm/config.version-policy').PublishedByPolicy} policy - Registry cooldown to resolve within
  * @returns {Promise<string>} Exact version string of the dependency
  */
-export async function findDependencyVersionFromSpec(packageSpec, dependency) {
+export async function findDependencyVersionFromSpec(packageSpec, dependency, policy) {
   const result = await $`pnpm info ${packageSpec} dependencies.${dependency}`;
   const spec = result.stdout.trim();
-  return resolveVersion(`${dependency}@${spec}`);
+  return resolveVersion(`${dependency}@${spec}`, policy);
 }
 
 /**

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 };
+}